GnssAPIClient.cpp 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728
  1. /* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
  2. *
  3. * Redistribution and use in source and binary forms, with or without
  4. * modification, are permitted provided that the following conditions are
  5. * met:
  6. * * Redistributions of source code must retain the above copyright
  7. * notice, this list of conditions and the following disclaimer.
  8. * * Redistributions in binary form must reproduce the above
  9. * copyright notice, this list of conditions and the following
  10. * disclaimer in the documentation and/or other materials provided
  11. * with the distribution.
  12. * * Neither the name of The Linux Foundation, nor the names of its
  13. * contributors may be used to endorse or promote products derived
  14. * from this software without specific prior written permission.
  15. *
  16. * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
  17. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18. * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
  19. * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  20. * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21. * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22. * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  23. * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  24. * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  25. * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  26. * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27. *
  28. */
  29. #define LOG_NDEBUG 0
  30. #define LOG_TAG "LocSvc_GnssAPIClient"
  31. #define SINGLE_SHOT_MIN_TRACKING_INTERVAL_MSEC (590 * 60 * 60 * 1000) // 590 hours
  32. #include <inttypes.h>
  33. #include <log_util.h>
  34. #include <loc_cfg.h>
  35. #include "LocationUtil.h"
  36. #include "GnssAPIClient.h"
  37. #include <LocContext.h>
  38. namespace android {
  39. namespace hardware {
  40. namespace gnss {
  41. namespace V2_0 {
  42. namespace implementation {
  43. using ::android::hardware::gnss::V2_0::IGnss;
  44. using ::android::hardware::gnss::V2_0::IGnssCallback;
  45. using ::android::hardware::gnss::V1_0::IGnssNiCallback;
  46. using ::android::hardware::gnss::V2_0::GnssLocation;
  47. static void convertGnssSvStatus(GnssSvNotification& in, V1_0::IGnssCallback::GnssSvStatus& out);
  48. static void convertGnssSvStatus(GnssSvNotification& in,
  49. hidl_vec<V2_0::IGnssCallback::GnssSvInfo>& out);
  50. GnssAPIClient::GnssAPIClient(const sp<V1_0::IGnssCallback>& gpsCb,
  51. const sp<V1_0::IGnssNiCallback>& niCb) :
  52. LocationAPIClientBase(),
  53. mGnssCbIface(nullptr),
  54. mGnssNiCbIface(nullptr),
  55. mControlClient(new LocationAPIControlClient()),
  56. mLocationCapabilitiesMask(0),
  57. mLocationCapabilitiesCached(false),
  58. mTracking(false),
  59. mGnssCbIface_2_0(nullptr)
  60. {
  61. LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb);
  62. initLocationOptions();
  63. gnssUpdateCallbacks(gpsCb, niCb);
  64. }
  65. GnssAPIClient::GnssAPIClient(const sp<V2_0::IGnssCallback>& gpsCb) :
  66. LocationAPIClientBase(),
  67. mGnssCbIface(nullptr),
  68. mGnssNiCbIface(nullptr),
  69. mControlClient(new LocationAPIControlClient()),
  70. mLocationCapabilitiesMask(0),
  71. mLocationCapabilitiesCached(false),
  72. mTracking(false),
  73. mGnssCbIface_2_0(nullptr)
  74. {
  75. LOC_LOGD("%s]: (%p)", __FUNCTION__, &gpsCb);
  76. initLocationOptions();
  77. gnssUpdateCallbacks_2_0(gpsCb);
  78. }
  79. GnssAPIClient::~GnssAPIClient()
  80. {
  81. LOC_LOGD("%s]: ()", __FUNCTION__);
  82. if (mControlClient) {
  83. delete mControlClient;
  84. mControlClient = nullptr;
  85. }
  86. }
  87. void GnssAPIClient::initLocationOptions()
  88. {
  89. // set default LocationOptions.
  90. memset(&mTrackingOptions, 0, sizeof(TrackingOptions));
  91. mTrackingOptions.size = sizeof(TrackingOptions);
  92. mTrackingOptions.minInterval = 1000;
  93. mTrackingOptions.minDistance = 0;
  94. mTrackingOptions.mode = GNSS_SUPL_MODE_STANDALONE;
  95. }
  96. void GnssAPIClient::setCallbacks()
  97. {
  98. LocationCallbacks locationCallbacks;
  99. memset(&locationCallbacks, 0, sizeof(LocationCallbacks));
  100. locationCallbacks.size = sizeof(LocationCallbacks);
  101. locationCallbacks.trackingCb = nullptr;
  102. locationCallbacks.trackingCb = [this](Location location) {
  103. onTrackingCb(location);
  104. };
  105. locationCallbacks.batchingCb = nullptr;
  106. locationCallbacks.geofenceBreachCb = nullptr;
  107. locationCallbacks.geofenceStatusCb = nullptr;
  108. locationCallbacks.gnssLocationInfoCb = nullptr;
  109. locationCallbacks.gnssNiCb = nullptr;
  110. if (mGnssNiCbIface != nullptr) {
  111. loc_core::ContextBase* context =
  112. loc_core::LocContext::getLocContext(loc_core::LocContext::mLocationHalName);
  113. if (!context->hasAgpsExtendedCapabilities()) {
  114. LOC_LOGD("Registering NI CB");
  115. locationCallbacks.gnssNiCb = [this](uint32_t id, GnssNiNotification gnssNiNotify) {
  116. onGnssNiCb(id, gnssNiNotify);
  117. };
  118. }
  119. }
  120. locationCallbacks.gnssSvCb = nullptr;
  121. locationCallbacks.gnssSvCb = [this](GnssSvNotification gnssSvNotification) {
  122. onGnssSvCb(gnssSvNotification);
  123. };
  124. locationCallbacks.gnssNmeaCb = nullptr;
  125. locationCallbacks.gnssNmeaCb = [this](GnssNmeaNotification gnssNmeaNotification) {
  126. onGnssNmeaCb(gnssNmeaNotification);
  127. };
  128. locationCallbacks.gnssMeasurementsCb = nullptr;
  129. locAPISetCallbacks(locationCallbacks);
  130. }
  131. // for GpsInterface
  132. void GnssAPIClient::gnssUpdateCallbacks(const sp<V1_0::IGnssCallback>& gpsCb,
  133. const sp<IGnssNiCallback>& niCb)
  134. {
  135. LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb);
  136. mMutex.lock();
  137. mGnssCbIface = gpsCb;
  138. mGnssNiCbIface = niCb;
  139. mMutex.unlock();
  140. if (mGnssCbIface != nullptr || mGnssNiCbIface != nullptr) {
  141. setCallbacks();
  142. }
  143. }
  144. void GnssAPIClient::gnssUpdateCallbacks_2_0(const sp<V2_0::IGnssCallback>& gpsCb)
  145. {
  146. LOC_LOGD("%s]: (%p)", __FUNCTION__, &gpsCb);
  147. mMutex.lock();
  148. mGnssCbIface_2_0 = gpsCb;
  149. mMutex.unlock();
  150. if (mGnssCbIface_2_0 != nullptr) {
  151. setCallbacks();
  152. }
  153. }
  154. bool GnssAPIClient::gnssStart()
  155. {
  156. LOC_LOGD("%s]: ()", __FUNCTION__);
  157. mMutex.lock();
  158. mTracking = true;
  159. mMutex.unlock();
  160. bool retVal = true;
  161. locAPIStartTracking(mTrackingOptions);
  162. return retVal;
  163. }
  164. bool GnssAPIClient::gnssStop()
  165. {
  166. LOC_LOGD("%s]: ()", __FUNCTION__);
  167. mMutex.lock();
  168. mTracking = false;
  169. mMutex.unlock();
  170. bool retVal = true;
  171. locAPIStopTracking();
  172. return retVal;
  173. }
  174. bool GnssAPIClient::gnssSetPositionMode(IGnss::GnssPositionMode mode,
  175. IGnss::GnssPositionRecurrence recurrence, uint32_t minIntervalMs,
  176. uint32_t preferredAccuracyMeters, uint32_t preferredTimeMs,
  177. GnssPowerMode powerMode, uint32_t timeBetweenMeasurement)
  178. {
  179. LOC_LOGD("%s]: (%d %d %d %d %d %d %d)", __FUNCTION__,
  180. (int)mode, recurrence, minIntervalMs, preferredAccuracyMeters,
  181. preferredTimeMs, (int)powerMode, timeBetweenMeasurement);
  182. bool retVal = true;
  183. memset(&mTrackingOptions, 0, sizeof(TrackingOptions));
  184. mTrackingOptions.size = sizeof(TrackingOptions);
  185. mTrackingOptions.minInterval = minIntervalMs;
  186. if (IGnss::GnssPositionMode::MS_ASSISTED == mode ||
  187. IGnss::GnssPositionRecurrence::RECURRENCE_SINGLE == recurrence) {
  188. // We set a very large interval to simulate SINGLE mode. Once we report a fix,
  189. // the caller should take the responsibility to stop the session.
  190. // For MSA, we always treat it as SINGLE mode.
  191. mTrackingOptions.minInterval = SINGLE_SHOT_MIN_TRACKING_INTERVAL_MSEC;
  192. }
  193. if (mode == IGnss::GnssPositionMode::STANDALONE)
  194. mTrackingOptions.mode = GNSS_SUPL_MODE_STANDALONE;
  195. else if (mode == IGnss::GnssPositionMode::MS_BASED)
  196. mTrackingOptions.mode = GNSS_SUPL_MODE_MSB;
  197. else if (mode == IGnss::GnssPositionMode::MS_ASSISTED)
  198. mTrackingOptions.mode = GNSS_SUPL_MODE_MSA;
  199. else {
  200. LOC_LOGD("%s]: invalid GnssPositionMode: %d", __FUNCTION__, (int)mode);
  201. retVal = false;
  202. }
  203. if (GNSS_POWER_MODE_INVALID != powerMode) {
  204. mTrackingOptions.powerMode = powerMode;
  205. mTrackingOptions.tbm = timeBetweenMeasurement;
  206. }
  207. locAPIUpdateTrackingOptions(mTrackingOptions);
  208. return retVal;
  209. }
  210. // for GpsNiInterface
  211. void GnssAPIClient::gnssNiRespond(int32_t notifId,
  212. IGnssNiCallback::GnssUserResponseType userResponse)
  213. {
  214. LOC_LOGD("%s]: (%d %d)", __FUNCTION__, notifId, static_cast<int>(userResponse));
  215. GnssNiResponse data;
  216. switch (userResponse) {
  217. case IGnssNiCallback::GnssUserResponseType::RESPONSE_ACCEPT:
  218. data = GNSS_NI_RESPONSE_ACCEPT;
  219. break;
  220. case IGnssNiCallback::GnssUserResponseType::RESPONSE_DENY:
  221. data = GNSS_NI_RESPONSE_DENY;
  222. break;
  223. case IGnssNiCallback::GnssUserResponseType::RESPONSE_NORESP:
  224. data = GNSS_NI_RESPONSE_NO_RESPONSE;
  225. break;
  226. default:
  227. data = GNSS_NI_RESPONSE_IGNORE;
  228. break;
  229. }
  230. locAPIGnssNiResponse(notifId, data);
  231. }
  232. // these apis using LocationAPIControlClient
  233. void GnssAPIClient::gnssDeleteAidingData(IGnss::GnssAidingData aidingDataFlags)
  234. {
  235. LOC_LOGD("%s]: (%02hx)", __FUNCTION__, aidingDataFlags);
  236. if (mControlClient == nullptr) {
  237. return;
  238. }
  239. GnssAidingData data;
  240. memset(&data, 0, sizeof (GnssAidingData));
  241. data.sv.svTypeMask = GNSS_AIDING_DATA_SV_TYPE_GPS_BIT |
  242. GNSS_AIDING_DATA_SV_TYPE_GLONASS_BIT |
  243. GNSS_AIDING_DATA_SV_TYPE_QZSS_BIT |
  244. GNSS_AIDING_DATA_SV_TYPE_BEIDOU_BIT |
  245. GNSS_AIDING_DATA_SV_TYPE_GALILEO_BIT |
  246. GNSS_AIDING_DATA_SV_TYPE_NAVIC_BIT;
  247. data.posEngineMask = STANDARD_POSITIONING_ENGINE;
  248. if (aidingDataFlags == IGnss::GnssAidingData::DELETE_ALL)
  249. data.deleteAll = true;
  250. else {
  251. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_EPHEMERIS)
  252. data.sv.svMask |= GNSS_AIDING_DATA_SV_EPHEMERIS_BIT;
  253. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_ALMANAC)
  254. data.sv.svMask |= GNSS_AIDING_DATA_SV_ALMANAC_BIT;
  255. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_POSITION)
  256. data.common.mask |= GNSS_AIDING_DATA_COMMON_POSITION_BIT;
  257. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_TIME)
  258. data.common.mask |= GNSS_AIDING_DATA_COMMON_TIME_BIT;
  259. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_IONO)
  260. data.sv.svMask |= GNSS_AIDING_DATA_SV_IONOSPHERE_BIT;
  261. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_UTC)
  262. data.common.mask |= GNSS_AIDING_DATA_COMMON_UTC_BIT;
  263. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_HEALTH)
  264. data.sv.svMask |= GNSS_AIDING_DATA_SV_HEALTH_BIT;
  265. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SVDIR)
  266. data.sv.svMask |= GNSS_AIDING_DATA_SV_DIRECTION_BIT;
  267. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SVSTEER)
  268. data.sv.svMask |= GNSS_AIDING_DATA_SV_STEER_BIT;
  269. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SADATA)
  270. data.sv.svMask |= GNSS_AIDING_DATA_SV_SA_DATA_BIT;
  271. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_RTI)
  272. data.common.mask |= GNSS_AIDING_DATA_COMMON_RTI_BIT;
  273. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_CELLDB_INFO)
  274. data.common.mask |= GNSS_AIDING_DATA_COMMON_CELLDB_BIT;
  275. }
  276. mControlClient->locAPIGnssDeleteAidingData(data);
  277. }
  278. void GnssAPIClient::gnssEnable(LocationTechnologyType techType)
  279. {
  280. LOC_LOGD("%s]: (%0d)", __FUNCTION__, techType);
  281. if (mControlClient == nullptr) {
  282. return;
  283. }
  284. mControlClient->locAPIEnable(techType);
  285. }
  286. void GnssAPIClient::gnssDisable()
  287. {
  288. LOC_LOGD("%s]: ()", __FUNCTION__);
  289. if (mControlClient == nullptr) {
  290. return;
  291. }
  292. mControlClient->locAPIDisable();
  293. }
  294. void GnssAPIClient::gnssConfigurationUpdate(const GnssConfig& gnssConfig)
  295. {
  296. LOC_LOGD("%s]: (%02x)", __FUNCTION__, gnssConfig.flags);
  297. if (mControlClient == nullptr) {
  298. return;
  299. }
  300. mControlClient->locAPIGnssUpdateConfig(gnssConfig);
  301. }
  302. void GnssAPIClient::requestCapabilities() {
  303. // only send capablities if it's already cached, otherwise the first time LocationAPI
  304. // is initialized, capabilities will be sent by LocationAPI
  305. if (mLocationCapabilitiesCached) {
  306. onCapabilitiesCb(mLocationCapabilitiesMask);
  307. }
  308. }
  309. // callbacks
  310. void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask)
  311. {
  312. LOC_LOGD("%s]: (%" PRIu64 ")", __FUNCTION__, capabilitiesMask);
  313. mLocationCapabilitiesMask = capabilitiesMask;
  314. mLocationCapabilitiesCached = true;
  315. mMutex.lock();
  316. auto gnssCbIface(mGnssCbIface);
  317. auto gnssCbIface_2_0(mGnssCbIface_2_0);
  318. mMutex.unlock();
  319. if (gnssCbIface_2_0 != nullptr || gnssCbIface != nullptr) {
  320. uint32_t data = 0;
  321. if ((capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT) ||
  322. (capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT) ||
  323. (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT) ||
  324. (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT))
  325. data |= IGnssCallback::Capabilities::SCHEDULING;
  326. if (capabilitiesMask & LOCATION_CAPABILITIES_GEOFENCE_BIT)
  327. data |= V1_0::IGnssCallback::Capabilities::GEOFENCING;
  328. if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT)
  329. data |= V1_0::IGnssCallback::Capabilities::MEASUREMENTS;
  330. if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSB_BIT)
  331. data |= IGnssCallback::Capabilities::MSB;
  332. if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSA_BIT)
  333. data |= IGnssCallback::Capabilities::MSA;
  334. if (capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT)
  335. data |= IGnssCallback::Capabilities::LOW_POWER_MODE;
  336. if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT)
  337. data |= IGnssCallback::Capabilities::SATELLITE_BLACKLIST;
  338. IGnssCallback::GnssSystemInfo gnssInfo = { .yearOfHw = 2015 };
  339. if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) {
  340. gnssInfo.yearOfHw++; // 2016
  341. if (capabilitiesMask & LOCATION_CAPABILITIES_DEBUG_NMEA_BIT) {
  342. gnssInfo.yearOfHw++; // 2017
  343. if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT ||
  344. capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT) {
  345. gnssInfo.yearOfHw++; // 2018
  346. if (capabilitiesMask & LOCATION_CAPABILITIES_PRIVACY_BIT) {
  347. gnssInfo.yearOfHw++; // 2019
  348. }
  349. }
  350. }
  351. }
  352. LOC_LOGV("%s:%d] set_system_info_cb (%d)", __FUNCTION__, __LINE__, gnssInfo.yearOfHw);
  353. if (gnssCbIface_2_0 != nullptr) {
  354. auto r = gnssCbIface_2_0->gnssSetCapabilitiesCb_2_0(data);
  355. if (!r.isOk()) {
  356. LOC_LOGE("%s] Error from gnssSetCapabilitiesCb_2_0 description=%s",
  357. __func__, r.description().c_str());
  358. }
  359. r = gnssCbIface_2_0->gnssSetSystemInfoCb(gnssInfo);
  360. if (!r.isOk()) {
  361. LOC_LOGE("%s] Error from gnssSetSystemInfoCb description=%s",
  362. __func__, r.description().c_str());
  363. }
  364. } else if (gnssCbIface != nullptr) {
  365. auto r = gnssCbIface->gnssSetCapabilitesCb(data);
  366. if (!r.isOk()) {
  367. LOC_LOGE("%s] Error from gnssSetCapabilitesCb description=%s",
  368. __func__, r.description().c_str());
  369. }
  370. r = gnssCbIface->gnssSetSystemInfoCb(gnssInfo);
  371. if (!r.isOk()) {
  372. LOC_LOGE("%s] Error from gnssSetSystemInfoCb description=%s",
  373. __func__, r.description().c_str());
  374. }
  375. }
  376. }
  377. }
  378. void GnssAPIClient::onTrackingCb(Location location)
  379. {
  380. mMutex.lock();
  381. auto gnssCbIface(mGnssCbIface);
  382. auto gnssCbIface_2_0(mGnssCbIface_2_0);
  383. bool isTracking = mTracking;
  384. mMutex.unlock();
  385. LOC_LOGD("%s]: (flags: %02x isTracking: %d)", __FUNCTION__, location.flags, isTracking);
  386. if (!isTracking) {
  387. return;
  388. }
  389. if (gnssCbIface_2_0 != nullptr) {
  390. V2_0::GnssLocation gnssLocation;
  391. convertGnssLocation(location, gnssLocation);
  392. auto r = gnssCbIface_2_0->gnssLocationCb_2_0(gnssLocation);
  393. if (!r.isOk()) {
  394. LOC_LOGE("%s] Error from gnssLocationCb_2_0 description=%s",
  395. __func__, r.description().c_str());
  396. }
  397. } else if (gnssCbIface != nullptr) {
  398. V1_0::GnssLocation gnssLocation;
  399. convertGnssLocation(location, gnssLocation);
  400. auto r = gnssCbIface->gnssLocationCb(gnssLocation);
  401. if (!r.isOk()) {
  402. LOC_LOGE("%s] Error from gnssLocationCb description=%s",
  403. __func__, r.description().c_str());
  404. }
  405. } else {
  406. LOC_LOGW("%s] No GNSS Interface ready for gnssLocationCb ", __FUNCTION__);
  407. }
  408. }
  409. void GnssAPIClient::onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotification)
  410. {
  411. LOC_LOGD("%s]: (id: %d)", __FUNCTION__, id);
  412. mMutex.lock();
  413. auto gnssNiCbIface(mGnssNiCbIface);
  414. mMutex.unlock();
  415. if (gnssNiCbIface == nullptr) {
  416. LOC_LOGE("%s]: mGnssNiCbIface is nullptr", __FUNCTION__);
  417. return;
  418. }
  419. IGnssNiCallback::GnssNiNotification notificationGnss = {};
  420. notificationGnss.notificationId = id;
  421. if (gnssNiNotification.type == GNSS_NI_TYPE_VOICE)
  422. notificationGnss.niType = IGnssNiCallback::GnssNiType::VOICE;
  423. else if (gnssNiNotification.type == GNSS_NI_TYPE_SUPL)
  424. notificationGnss.niType = IGnssNiCallback::GnssNiType::UMTS_SUPL;
  425. else if (gnssNiNotification.type == GNSS_NI_TYPE_CONTROL_PLANE)
  426. notificationGnss.niType = IGnssNiCallback::GnssNiType::UMTS_CTRL_PLANE;
  427. else if (gnssNiNotification.type == GNSS_NI_TYPE_EMERGENCY_SUPL)
  428. notificationGnss.niType = IGnssNiCallback::GnssNiType::EMERGENCY_SUPL;
  429. if (gnssNiNotification.options & GNSS_NI_OPTIONS_NOTIFICATION_BIT)
  430. notificationGnss.notifyFlags |= IGnssNiCallback::GnssNiNotifyFlags::NEED_NOTIFY;
  431. if (gnssNiNotification.options & GNSS_NI_OPTIONS_VERIFICATION_BIT)
  432. notificationGnss.notifyFlags |= IGnssNiCallback::GnssNiNotifyFlags::NEED_VERIFY;
  433. if (gnssNiNotification.options & GNSS_NI_OPTIONS_PRIVACY_OVERRIDE_BIT)
  434. notificationGnss.notifyFlags |= IGnssNiCallback::GnssNiNotifyFlags::PRIVACY_OVERRIDE;
  435. notificationGnss.timeoutSec = gnssNiNotification.timeout;
  436. if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_ACCEPT)
  437. notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_ACCEPT;
  438. else if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_DENY)
  439. notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_DENY;
  440. else if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_NO_RESPONSE ||
  441. gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_IGNORE)
  442. notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_NORESP;
  443. notificationGnss.requestorId = gnssNiNotification.requestor;
  444. notificationGnss.notificationMessage = gnssNiNotification.message;
  445. if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_NONE)
  446. notificationGnss.requestorIdEncoding =
  447. IGnssNiCallback::GnssNiEncodingType::ENC_NONE;
  448. else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_GSM_DEFAULT)
  449. notificationGnss.requestorIdEncoding =
  450. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_GSM_DEFAULT;
  451. else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_UTF8)
  452. notificationGnss.requestorIdEncoding =
  453. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UTF8;
  454. else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_UCS2)
  455. notificationGnss.requestorIdEncoding =
  456. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UCS2;
  457. if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_NONE)
  458. notificationGnss.notificationIdEncoding =
  459. IGnssNiCallback::GnssNiEncodingType::ENC_NONE;
  460. else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_GSM_DEFAULT)
  461. notificationGnss.notificationIdEncoding =
  462. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_GSM_DEFAULT;
  463. else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_UTF8)
  464. notificationGnss.notificationIdEncoding =
  465. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UTF8;
  466. else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_UCS2)
  467. notificationGnss.notificationIdEncoding =
  468. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UCS2;
  469. gnssNiCbIface->niNotifyCb(notificationGnss);
  470. }
  471. void GnssAPIClient::onGnssSvCb(GnssSvNotification gnssSvNotification)
  472. {
  473. LOC_LOGD("%s]: (count: %u)", __FUNCTION__, gnssSvNotification.count);
  474. mMutex.lock();
  475. auto gnssCbIface(mGnssCbIface);
  476. auto gnssCbIface_2_0(mGnssCbIface_2_0);
  477. mMutex.unlock();
  478. if (gnssCbIface_2_0 != nullptr) {
  479. hidl_vec<V2_0::IGnssCallback::GnssSvInfo> svInfoList;
  480. convertGnssSvStatus(gnssSvNotification, svInfoList);
  481. auto r = gnssCbIface_2_0->gnssSvStatusCb_2_0(svInfoList);
  482. if (!r.isOk()) {
  483. LOC_LOGE("%s] Error from gnssSvStatusCb_2_0 description=%s",
  484. __func__, r.description().c_str());
  485. }
  486. } else if (gnssCbIface != nullptr) {
  487. V1_0::IGnssCallback::GnssSvStatus svStatus;
  488. convertGnssSvStatus(gnssSvNotification, svStatus);
  489. auto r = gnssCbIface->gnssSvStatusCb(svStatus);
  490. if (!r.isOk()) {
  491. LOC_LOGE("%s] Error from gnssSvStatusCb description=%s",
  492. __func__, r.description().c_str());
  493. }
  494. }
  495. }
  496. void GnssAPIClient::onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification)
  497. {
  498. mMutex.lock();
  499. auto gnssCbIface(mGnssCbIface);
  500. auto gnssCbIface_2_0(mGnssCbIface_2_0);
  501. mMutex.unlock();
  502. if (gnssCbIface != nullptr || gnssCbIface_2_0 != nullptr) {
  503. const std::string s(gnssNmeaNotification.nmea);
  504. std::stringstream ss(s);
  505. std::string each;
  506. while(std::getline(ss, each, '\n')) {
  507. each += '\n';
  508. android::hardware::hidl_string nmeaString;
  509. nmeaString.setToExternal(each.c_str(), each.length());
  510. if (gnssCbIface_2_0 != nullptr) {
  511. auto r = gnssCbIface_2_0->gnssNmeaCb(
  512. static_cast<V1_0::GnssUtcTime>(gnssNmeaNotification.timestamp), nmeaString);
  513. if (!r.isOk()) {
  514. LOC_LOGE("%s] Error from gnssCbIface_2_0 nmea=%s length=%u description=%s",
  515. __func__, gnssNmeaNotification.nmea, gnssNmeaNotification.length,
  516. r.description().c_str());
  517. }
  518. } else if (gnssCbIface != nullptr) {
  519. auto r = gnssCbIface->gnssNmeaCb(
  520. static_cast<V1_0::GnssUtcTime>(gnssNmeaNotification.timestamp), nmeaString);
  521. if (!r.isOk()) {
  522. LOC_LOGE("%s] Error from gnssNmeaCb nmea=%s length=%u description=%s",
  523. __func__, gnssNmeaNotification.nmea, gnssNmeaNotification.length,
  524. r.description().c_str());
  525. }
  526. }
  527. }
  528. }
  529. }
  530. void GnssAPIClient::onStartTrackingCb(LocationError error)
  531. {
  532. LOC_LOGD("%s]: (%d)", __FUNCTION__, error);
  533. mMutex.lock();
  534. auto gnssCbIface(mGnssCbIface);
  535. auto gnssCbIface_2_0(mGnssCbIface_2_0);
  536. mMutex.unlock();
  537. if (error == LOCATION_ERROR_SUCCESS) {
  538. if (gnssCbIface_2_0 != nullptr) {
  539. auto r = gnssCbIface_2_0->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_ON);
  540. if (!r.isOk()) {
  541. LOC_LOGE("%s] Error from gnssStatusCb 2.0 ENGINE_ON description=%s",
  542. __func__, r.description().c_str());
  543. }
  544. r = gnssCbIface_2_0->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_BEGIN);
  545. if (!r.isOk()) {
  546. LOC_LOGE("%s] Error from gnssStatusCb 2.0 SESSION_BEGIN description=%s",
  547. __func__, r.description().c_str());
  548. }
  549. } else if (gnssCbIface != nullptr) {
  550. auto r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_ON);
  551. if (!r.isOk()) {
  552. LOC_LOGE("%s] Error from gnssStatusCb ENGINE_ON description=%s",
  553. __func__, r.description().c_str());
  554. }
  555. r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_BEGIN);
  556. if (!r.isOk()) {
  557. LOC_LOGE("%s] Error from gnssStatusCb SESSION_BEGIN description=%s",
  558. __func__, r.description().c_str());
  559. }
  560. }
  561. }
  562. }
  563. void GnssAPIClient::onStopTrackingCb(LocationError error)
  564. {
  565. LOC_LOGD("%s]: (%d)", __FUNCTION__, error);
  566. mMutex.lock();
  567. auto gnssCbIface(mGnssCbIface);
  568. auto gnssCbIface_2_0(mGnssCbIface_2_0);
  569. mMutex.unlock();
  570. if (error == LOCATION_ERROR_SUCCESS) {
  571. if (gnssCbIface_2_0 != nullptr) {
  572. auto r = gnssCbIface_2_0->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_END);
  573. if (!r.isOk()) {
  574. LOC_LOGE("%s] Error from gnssStatusCb 2.0 SESSION_END description=%s",
  575. __func__, r.description().c_str());
  576. }
  577. r = gnssCbIface_2_0->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_OFF);
  578. if (!r.isOk()) {
  579. LOC_LOGE("%s] Error from gnssStatusCb 2.0 ENGINE_OFF description=%s",
  580. __func__, r.description().c_str());
  581. }
  582. } else if (gnssCbIface != nullptr) {
  583. auto r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_END);
  584. if (!r.isOk()) {
  585. LOC_LOGE("%s] Error from gnssStatusCb SESSION_END description=%s",
  586. __func__, r.description().c_str());
  587. }
  588. r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_OFF);
  589. if (!r.isOk()) {
  590. LOC_LOGE("%s] Error from gnssStatusCb ENGINE_OFF description=%s",
  591. __func__, r.description().c_str());
  592. }
  593. }
  594. }
  595. }
  596. static void convertGnssSvStatus(GnssSvNotification& in, V1_0::IGnssCallback::GnssSvStatus& out)
  597. {
  598. memset(&out, 0, sizeof(IGnssCallback::GnssSvStatus));
  599. out.numSvs = in.count;
  600. if (out.numSvs > static_cast<uint32_t>(V1_0::GnssMax::SVS_COUNT)) {
  601. LOC_LOGW("%s]: Too many satellites %u. Clamps to %d.",
  602. __FUNCTION__, out.numSvs, V1_0::GnssMax::SVS_COUNT);
  603. out.numSvs = static_cast<uint32_t>(V1_0::GnssMax::SVS_COUNT);
  604. }
  605. for (size_t i = 0; i < out.numSvs; i++) {
  606. convertGnssSvid(in.gnssSvs[i], out.gnssSvList[i].svid);
  607. convertGnssConstellationType(in.gnssSvs[i].type, out.gnssSvList[i].constellation);
  608. out.gnssSvList[i].cN0Dbhz = in.gnssSvs[i].cN0Dbhz;
  609. out.gnssSvList[i].elevationDegrees = in.gnssSvs[i].elevation;
  610. out.gnssSvList[i].azimuthDegrees = in.gnssSvs[i].azimuth;
  611. out.gnssSvList[i].carrierFrequencyHz = in.gnssSvs[i].carrierFrequencyHz;
  612. out.gnssSvList[i].svFlag = static_cast<uint8_t>(IGnssCallback::GnssSvFlags::NONE);
  613. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_EPHEMER_BIT)
  614. out.gnssSvList[i].svFlag |= IGnssCallback::GnssSvFlags::HAS_EPHEMERIS_DATA;
  615. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_ALMANAC_BIT)
  616. out.gnssSvList[i].svFlag |= IGnssCallback::GnssSvFlags::HAS_ALMANAC_DATA;
  617. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)
  618. out.gnssSvList[i].svFlag |= IGnssCallback::GnssSvFlags::USED_IN_FIX;
  619. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_CARRIER_FREQUENCY_BIT)
  620. out.gnssSvList[i].svFlag |= IGnssCallback::GnssSvFlags::HAS_CARRIER_FREQUENCY;
  621. }
  622. }
  623. static void convertGnssSvStatus(GnssSvNotification& in,
  624. hidl_vec<V2_0::IGnssCallback::GnssSvInfo>& out)
  625. {
  626. out.resize(in.count);
  627. for (size_t i = 0; i < in.count; i++) {
  628. convertGnssSvid(in.gnssSvs[i], out[i].v1_0.svid);
  629. out[i].v1_0.cN0Dbhz = in.gnssSvs[i].cN0Dbhz;
  630. out[i].v1_0.elevationDegrees = in.gnssSvs[i].elevation;
  631. out[i].v1_0.azimuthDegrees = in.gnssSvs[i].azimuth;
  632. out[i].v1_0.carrierFrequencyHz = in.gnssSvs[i].carrierFrequencyHz;
  633. out[i].v1_0.svFlag = static_cast<uint8_t>(IGnssCallback::GnssSvFlags::NONE);
  634. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_EPHEMER_BIT)
  635. out[i].v1_0.svFlag |= IGnssCallback::GnssSvFlags::HAS_EPHEMERIS_DATA;
  636. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_ALMANAC_BIT)
  637. out[i].v1_0.svFlag |= IGnssCallback::GnssSvFlags::HAS_ALMANAC_DATA;
  638. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)
  639. out[i].v1_0.svFlag |= IGnssCallback::GnssSvFlags::USED_IN_FIX;
  640. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_CARRIER_FREQUENCY_BIT)
  641. out[i].v1_0.svFlag |= IGnssCallback::GnssSvFlags::HAS_CARRIER_FREQUENCY;
  642. convertGnssConstellationType(in.gnssSvs[i].type, out[i].constellation);
  643. }
  644. }
  645. } // namespace implementation
  646. } // namespace V2_0
  647. } // namespace gnss
  648. } // namespace hardware
  649. } // namespace android