GnssAPIClient.cpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565
  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 V1_1 {
  42. namespace implementation {
  43. using ::android::hardware::gnss::V1_0::IGnss;
  44. using ::android::hardware::gnss::V1_0::IGnssCallback;
  45. using ::android::hardware::gnss::V1_0::IGnssNiCallback;
  46. using ::android::hardware::gnss::V1_0::GnssLocation;
  47. static void convertGnssSvStatus(GnssSvNotification& in, IGnssCallback::GnssSvStatus& out);
  48. GnssAPIClient::GnssAPIClient(const sp<IGnssCallback>& gpsCb,
  49. const sp<IGnssNiCallback>& niCb) :
  50. LocationAPIClientBase(),
  51. mGnssCbIface(nullptr),
  52. mGnssNiCbIface(nullptr),
  53. mControlClient(new LocationAPIControlClient()),
  54. mLocationCapabilitiesMask(0),
  55. mLocationCapabilitiesCached(false)
  56. {
  57. LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb);
  58. // set default LocationOptions.
  59. memset(&mTrackingOptions, 0, sizeof(TrackingOptions));
  60. mTrackingOptions.size = sizeof(TrackingOptions);
  61. mTrackingOptions.minInterval = 1000;
  62. mTrackingOptions.minDistance = 0;
  63. mTrackingOptions.mode = GNSS_SUPL_MODE_STANDALONE;
  64. gnssUpdateCallbacks(gpsCb, niCb);
  65. }
  66. GnssAPIClient::~GnssAPIClient()
  67. {
  68. LOC_LOGD("%s]: ()", __FUNCTION__);
  69. if (mControlClient) {
  70. delete mControlClient;
  71. mControlClient = nullptr;
  72. }
  73. }
  74. // for GpsInterface
  75. void GnssAPIClient::gnssUpdateCallbacks(const sp<IGnssCallback>& gpsCb,
  76. const sp<IGnssNiCallback>& niCb)
  77. {
  78. LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb);
  79. mMutex.lock();
  80. mGnssCbIface = gpsCb;
  81. mGnssNiCbIface = niCb;
  82. mMutex.unlock();
  83. LocationCallbacks locationCallbacks;
  84. memset(&locationCallbacks, 0, sizeof(LocationCallbacks));
  85. locationCallbacks.size = sizeof(LocationCallbacks);
  86. locationCallbacks.trackingCb = nullptr;
  87. if (mGnssCbIface != nullptr) {
  88. locationCallbacks.trackingCb = [this](Location location) {
  89. onTrackingCb(location);
  90. };
  91. }
  92. locationCallbacks.batchingCb = nullptr;
  93. locationCallbacks.geofenceBreachCb = nullptr;
  94. locationCallbacks.geofenceStatusCb = nullptr;
  95. locationCallbacks.gnssLocationInfoCb = nullptr;
  96. locationCallbacks.gnssNiCb = nullptr;
  97. loc_core::ContextBase* context =
  98. loc_core::LocContext::getLocContext(loc_core::LocContext::mLocationHalName);
  99. if (mGnssNiCbIface != nullptr && !context->hasAgpsExtendedCapabilities()) {
  100. LOC_LOGD("Registering NI CB");
  101. locationCallbacks.gnssNiCb = [this](uint32_t id, GnssNiNotification gnssNiNotification) {
  102. onGnssNiCb(id, gnssNiNotification);
  103. };
  104. }
  105. locationCallbacks.gnssSvCb = nullptr;
  106. if (mGnssCbIface != nullptr) {
  107. locationCallbacks.gnssSvCb = [this](GnssSvNotification gnssSvNotification) {
  108. onGnssSvCb(gnssSvNotification);
  109. };
  110. }
  111. locationCallbacks.gnssNmeaCb = nullptr;
  112. if (mGnssCbIface != nullptr) {
  113. locationCallbacks.gnssNmeaCb = [this](GnssNmeaNotification gnssNmeaNotification) {
  114. onGnssNmeaCb(gnssNmeaNotification);
  115. };
  116. }
  117. locationCallbacks.gnssMeasurementsCb = nullptr;
  118. locAPISetCallbacks(locationCallbacks);
  119. }
  120. bool GnssAPIClient::gnssStart()
  121. {
  122. LOC_LOGD("%s]: ()", __FUNCTION__);
  123. bool retVal = true;
  124. locAPIStartTracking(mTrackingOptions);
  125. return retVal;
  126. }
  127. bool GnssAPIClient::gnssStop()
  128. {
  129. LOC_LOGD("%s]: ()", __FUNCTION__);
  130. bool retVal = true;
  131. locAPIStopTracking();
  132. return retVal;
  133. }
  134. bool GnssAPIClient::gnssSetPositionMode(IGnss::GnssPositionMode mode,
  135. IGnss::GnssPositionRecurrence recurrence, uint32_t minIntervalMs,
  136. uint32_t preferredAccuracyMeters, uint32_t preferredTimeMs,
  137. GnssPowerMode powerMode, uint32_t timeBetweenMeasurement)
  138. {
  139. LOC_LOGD("%s]: (%d %d %d %d %d %d %d)", __FUNCTION__,
  140. (int)mode, recurrence, minIntervalMs, preferredAccuracyMeters,
  141. preferredTimeMs, (int)powerMode, timeBetweenMeasurement);
  142. bool retVal = true;
  143. memset(&mTrackingOptions, 0, sizeof(TrackingOptions));
  144. mTrackingOptions.size = sizeof(TrackingOptions);
  145. mTrackingOptions.minInterval = minIntervalMs;
  146. if (IGnss::GnssPositionMode::MS_ASSISTED == mode ||
  147. IGnss::GnssPositionRecurrence::RECURRENCE_SINGLE == recurrence) {
  148. // We set a very large interval to simulate SINGLE mode. Once we report a fix,
  149. // the caller should take the responsibility to stop the session.
  150. // For MSA, we always treat it as SINGLE mode.
  151. mTrackingOptions.minInterval = SINGLE_SHOT_MIN_TRACKING_INTERVAL_MSEC;
  152. }
  153. if (mode == IGnss::GnssPositionMode::STANDALONE)
  154. mTrackingOptions.mode = GNSS_SUPL_MODE_STANDALONE;
  155. else if (mode == IGnss::GnssPositionMode::MS_BASED)
  156. mTrackingOptions.mode = GNSS_SUPL_MODE_MSB;
  157. else if (mode == IGnss::GnssPositionMode::MS_ASSISTED)
  158. mTrackingOptions.mode = GNSS_SUPL_MODE_MSA;
  159. else {
  160. LOC_LOGD("%s]: invalid GnssPositionMode: %d", __FUNCTION__, (int)mode);
  161. retVal = false;
  162. }
  163. if (GNSS_POWER_MODE_INVALID != powerMode) {
  164. mTrackingOptions.powerMode = powerMode;
  165. mTrackingOptions.tbm = timeBetweenMeasurement;
  166. }
  167. locAPIUpdateTrackingOptions(mTrackingOptions);
  168. return retVal;
  169. }
  170. // for GpsNiInterface
  171. void GnssAPIClient::gnssNiRespond(int32_t notifId,
  172. IGnssNiCallback::GnssUserResponseType userResponse)
  173. {
  174. LOC_LOGD("%s]: (%d %d)", __FUNCTION__, notifId, static_cast<int>(userResponse));
  175. GnssNiResponse data;
  176. switch (userResponse) {
  177. case IGnssNiCallback::GnssUserResponseType::RESPONSE_ACCEPT:
  178. data = GNSS_NI_RESPONSE_ACCEPT;
  179. break;
  180. case IGnssNiCallback::GnssUserResponseType::RESPONSE_DENY:
  181. data = GNSS_NI_RESPONSE_DENY;
  182. break;
  183. case IGnssNiCallback::GnssUserResponseType::RESPONSE_NORESP:
  184. data = GNSS_NI_RESPONSE_NO_RESPONSE;
  185. break;
  186. default:
  187. data = GNSS_NI_RESPONSE_IGNORE;
  188. break;
  189. }
  190. locAPIGnssNiResponse(notifId, data);
  191. }
  192. // these apis using LocationAPIControlClient
  193. void GnssAPIClient::gnssDeleteAidingData(IGnss::GnssAidingData aidingDataFlags)
  194. {
  195. LOC_LOGD("%s]: (%02hx)", __FUNCTION__, aidingDataFlags);
  196. if (mControlClient == nullptr) {
  197. return;
  198. }
  199. GnssAidingData data;
  200. memset(&data, 0, sizeof (GnssAidingData));
  201. data.sv.svTypeMask = GNSS_AIDING_DATA_SV_TYPE_GPS_BIT |
  202. GNSS_AIDING_DATA_SV_TYPE_GLONASS_BIT |
  203. GNSS_AIDING_DATA_SV_TYPE_QZSS_BIT |
  204. GNSS_AIDING_DATA_SV_TYPE_BEIDOU_BIT |
  205. GNSS_AIDING_DATA_SV_TYPE_GALILEO_BIT;
  206. data.posEngineMask = STANDARD_POSITIONING_ENGINE;
  207. if (aidingDataFlags == IGnss::GnssAidingData::DELETE_ALL)
  208. data.deleteAll = true;
  209. else {
  210. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_EPHEMERIS)
  211. data.sv.svMask |= GNSS_AIDING_DATA_SV_EPHEMERIS_BIT;
  212. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_ALMANAC)
  213. data.sv.svMask |= GNSS_AIDING_DATA_SV_ALMANAC_BIT;
  214. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_POSITION)
  215. data.common.mask |= GNSS_AIDING_DATA_COMMON_POSITION_BIT;
  216. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_TIME)
  217. data.common.mask |= GNSS_AIDING_DATA_COMMON_TIME_BIT;
  218. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_IONO)
  219. data.sv.svMask |= GNSS_AIDING_DATA_SV_IONOSPHERE_BIT;
  220. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_UTC)
  221. data.common.mask |= GNSS_AIDING_DATA_COMMON_UTC_BIT;
  222. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_HEALTH)
  223. data.sv.svMask |= GNSS_AIDING_DATA_SV_HEALTH_BIT;
  224. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SVDIR)
  225. data.sv.svMask |= GNSS_AIDING_DATA_SV_DIRECTION_BIT;
  226. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SVSTEER)
  227. data.sv.svMask |= GNSS_AIDING_DATA_SV_STEER_BIT;
  228. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SADATA)
  229. data.sv.svMask |= GNSS_AIDING_DATA_SV_SA_DATA_BIT;
  230. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_RTI)
  231. data.common.mask |= GNSS_AIDING_DATA_COMMON_RTI_BIT;
  232. if (aidingDataFlags & IGnss::GnssAidingData::DELETE_CELLDB_INFO)
  233. data.common.mask |= GNSS_AIDING_DATA_COMMON_CELLDB_BIT;
  234. }
  235. mControlClient->locAPIGnssDeleteAidingData(data);
  236. }
  237. void GnssAPIClient::gnssEnable(LocationTechnologyType techType)
  238. {
  239. LOC_LOGD("%s]: (%0d)", __FUNCTION__, techType);
  240. if (mControlClient == nullptr) {
  241. return;
  242. }
  243. mControlClient->locAPIEnable(techType);
  244. }
  245. void GnssAPIClient::gnssDisable()
  246. {
  247. LOC_LOGD("%s]: ()", __FUNCTION__);
  248. if (mControlClient == nullptr) {
  249. return;
  250. }
  251. mControlClient->locAPIDisable();
  252. }
  253. void GnssAPIClient::gnssConfigurationUpdate(const GnssConfig& gnssConfig)
  254. {
  255. LOC_LOGD("%s]: (%02x)", __FUNCTION__, gnssConfig.flags);
  256. if (mControlClient == nullptr) {
  257. return;
  258. }
  259. mControlClient->locAPIGnssUpdateConfig(gnssConfig);
  260. }
  261. void GnssAPIClient::requestCapabilities() {
  262. // only send capablities if it's already cached, otherwise the first time LocationAPI
  263. // is initialized, capabilities will be sent by LocationAPI
  264. if (mLocationCapabilitiesCached) {
  265. onCapabilitiesCb(mLocationCapabilitiesMask);
  266. }
  267. }
  268. // callbacks
  269. void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask)
  270. {
  271. LOC_LOGD("%s]: (%" PRIu64 ")", __FUNCTION__, capabilitiesMask);
  272. mLocationCapabilitiesMask = capabilitiesMask;
  273. mLocationCapabilitiesCached = true;
  274. mMutex.lock();
  275. auto gnssCbIface(mGnssCbIface);
  276. mMutex.unlock();
  277. if (gnssCbIface != nullptr) {
  278. uint32_t data = 0;
  279. if ((capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT) ||
  280. (capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT) ||
  281. (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT) ||
  282. (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT))
  283. data |= IGnssCallback::Capabilities::SCHEDULING;
  284. if (capabilitiesMask & LOCATION_CAPABILITIES_GEOFENCE_BIT)
  285. data |= IGnssCallback::Capabilities::GEOFENCING;
  286. if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT)
  287. data |= IGnssCallback::Capabilities::MEASUREMENTS;
  288. if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSB_BIT)
  289. data |= IGnssCallback::Capabilities::MSB;
  290. if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSA_BIT)
  291. data |= IGnssCallback::Capabilities::MSA;
  292. auto r = gnssCbIface->gnssSetCapabilitesCb(data);
  293. if (!r.isOk()) {
  294. LOC_LOGE("%s] Error from gnssSetCapabilitesCb description=%s",
  295. __func__, r.description().c_str());
  296. }
  297. }
  298. if (gnssCbIface != nullptr) {
  299. IGnssCallback::GnssSystemInfo gnssInfo = { .yearOfHw = 2015 };
  300. if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) {
  301. gnssInfo.yearOfHw++; // 2016
  302. if (capabilitiesMask & LOCATION_CAPABILITIES_DEBUG_NMEA_BIT) {
  303. gnssInfo.yearOfHw++; // 2017
  304. if (capabilitiesMask & LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT ||
  305. capabilitiesMask & LOCATION_CAPABILITIES_AGPM_BIT) {
  306. gnssInfo.yearOfHw++; // 2018
  307. }
  308. }
  309. }
  310. LOC_LOGV("%s:%d] set_system_info_cb (%d)", __FUNCTION__, __LINE__, gnssInfo.yearOfHw);
  311. auto r = gnssCbIface->gnssSetSystemInfoCb(gnssInfo);
  312. if (!r.isOk()) {
  313. LOC_LOGE("%s] Error from gnssSetSystemInfoCb description=%s",
  314. __func__, r.description().c_str());
  315. }
  316. }
  317. }
  318. void GnssAPIClient::onTrackingCb(Location location)
  319. {
  320. LOC_LOGD("%s]: (flags: %02x)", __FUNCTION__, location.flags);
  321. mMutex.lock();
  322. auto gnssCbIface(mGnssCbIface);
  323. mMutex.unlock();
  324. if (gnssCbIface != nullptr) {
  325. GnssLocation gnssLocation;
  326. convertGnssLocation(location, gnssLocation);
  327. auto r = gnssCbIface->gnssLocationCb(gnssLocation);
  328. if (!r.isOk()) {
  329. LOC_LOGE("%s] Error from gnssLocationCb description=%s",
  330. __func__, r.description().c_str());
  331. }
  332. }
  333. }
  334. void GnssAPIClient::onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotification)
  335. {
  336. LOC_LOGD("%s]: (id: %d)", __FUNCTION__, id);
  337. mMutex.lock();
  338. auto gnssNiCbIface(mGnssNiCbIface);
  339. mMutex.unlock();
  340. if (gnssNiCbIface == nullptr) {
  341. LOC_LOGE("%s]: mGnssNiCbIface is nullptr", __FUNCTION__);
  342. return;
  343. }
  344. IGnssNiCallback::GnssNiNotification notificationGnss = {};
  345. notificationGnss.notificationId = id;
  346. if (gnssNiNotification.type == GNSS_NI_TYPE_VOICE)
  347. notificationGnss.niType = IGnssNiCallback::GnssNiType::VOICE;
  348. else if (gnssNiNotification.type == GNSS_NI_TYPE_SUPL)
  349. notificationGnss.niType = IGnssNiCallback::GnssNiType::UMTS_SUPL;
  350. else if (gnssNiNotification.type == GNSS_NI_TYPE_CONTROL_PLANE)
  351. notificationGnss.niType = IGnssNiCallback::GnssNiType::UMTS_CTRL_PLANE;
  352. else if (gnssNiNotification.type == GNSS_NI_TYPE_EMERGENCY_SUPL)
  353. notificationGnss.niType = IGnssNiCallback::GnssNiType::EMERGENCY_SUPL;
  354. if (gnssNiNotification.options & GNSS_NI_OPTIONS_NOTIFICATION_BIT)
  355. notificationGnss.notifyFlags |= IGnssNiCallback::GnssNiNotifyFlags::NEED_NOTIFY;
  356. if (gnssNiNotification.options & GNSS_NI_OPTIONS_VERIFICATION_BIT)
  357. notificationGnss.notifyFlags |= IGnssNiCallback::GnssNiNotifyFlags::NEED_VERIFY;
  358. if (gnssNiNotification.options & GNSS_NI_OPTIONS_PRIVACY_OVERRIDE_BIT)
  359. notificationGnss.notifyFlags |= IGnssNiCallback::GnssNiNotifyFlags::PRIVACY_OVERRIDE;
  360. notificationGnss.timeoutSec = gnssNiNotification.timeout;
  361. if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_ACCEPT)
  362. notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_ACCEPT;
  363. else if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_DENY)
  364. notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_DENY;
  365. else if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_NO_RESPONSE ||
  366. gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_IGNORE)
  367. notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_NORESP;
  368. notificationGnss.requestorId = gnssNiNotification.requestor;
  369. notificationGnss.notificationMessage = gnssNiNotification.message;
  370. if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_NONE)
  371. notificationGnss.requestorIdEncoding =
  372. IGnssNiCallback::GnssNiEncodingType::ENC_NONE;
  373. else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_GSM_DEFAULT)
  374. notificationGnss.requestorIdEncoding =
  375. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_GSM_DEFAULT;
  376. else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_UTF8)
  377. notificationGnss.requestorIdEncoding =
  378. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UTF8;
  379. else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_UCS2)
  380. notificationGnss.requestorIdEncoding =
  381. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UCS2;
  382. if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_NONE)
  383. notificationGnss.notificationIdEncoding =
  384. IGnssNiCallback::GnssNiEncodingType::ENC_NONE;
  385. else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_GSM_DEFAULT)
  386. notificationGnss.notificationIdEncoding =
  387. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_GSM_DEFAULT;
  388. else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_UTF8)
  389. notificationGnss.notificationIdEncoding =
  390. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UTF8;
  391. else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_UCS2)
  392. notificationGnss.notificationIdEncoding =
  393. IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UCS2;
  394. gnssNiCbIface->niNotifyCb(notificationGnss);
  395. }
  396. void GnssAPIClient::onGnssSvCb(GnssSvNotification gnssSvNotification)
  397. {
  398. LOC_LOGD("%s]: (count: %zu)", __FUNCTION__, gnssSvNotification.count);
  399. mMutex.lock();
  400. auto gnssCbIface(mGnssCbIface);
  401. mMutex.unlock();
  402. if (gnssCbIface != nullptr) {
  403. IGnssCallback::GnssSvStatus svStatus;
  404. convertGnssSvStatus(gnssSvNotification, svStatus);
  405. auto r = gnssCbIface->gnssSvStatusCb(svStatus);
  406. if (!r.isOk()) {
  407. LOC_LOGE("%s] Error from gnssSvStatusCb description=%s",
  408. __func__, r.description().c_str());
  409. }
  410. }
  411. }
  412. void GnssAPIClient::onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification)
  413. {
  414. mMutex.lock();
  415. auto gnssCbIface(mGnssCbIface);
  416. mMutex.unlock();
  417. if (gnssCbIface != nullptr) {
  418. const std::string s(gnssNmeaNotification.nmea);
  419. std::stringstream ss(s);
  420. std::string each;
  421. while(std::getline(ss, each, '\n')) {
  422. each += '\n';
  423. android::hardware::hidl_string nmeaString;
  424. nmeaString.setToExternal(each.c_str(), each.length());
  425. auto r = gnssCbIface->gnssNmeaCb(
  426. static_cast<V1_0::GnssUtcTime>(gnssNmeaNotification.timestamp), nmeaString);
  427. if (!r.isOk()) {
  428. LOC_LOGE("%s] Error from gnssNmeaCb nmea=%s length=%zu description=%s", __func__,
  429. gnssNmeaNotification.nmea, gnssNmeaNotification.length,
  430. r.description().c_str());
  431. }
  432. }
  433. }
  434. }
  435. void GnssAPIClient::onStartTrackingCb(LocationError error)
  436. {
  437. LOC_LOGD("%s]: (%d)", __FUNCTION__, error);
  438. mMutex.lock();
  439. auto gnssCbIface(mGnssCbIface);
  440. mMutex.unlock();
  441. if (error == LOCATION_ERROR_SUCCESS && gnssCbIface != nullptr) {
  442. auto r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_ON);
  443. if (!r.isOk()) {
  444. LOC_LOGE("%s] Error from gnssStatusCb ENGINE_ON description=%s",
  445. __func__, r.description().c_str());
  446. }
  447. r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_BEGIN);
  448. if (!r.isOk()) {
  449. LOC_LOGE("%s] Error from gnssStatusCb SESSION_BEGIN description=%s",
  450. __func__, r.description().c_str());
  451. }
  452. }
  453. }
  454. void GnssAPIClient::onStopTrackingCb(LocationError error)
  455. {
  456. LOC_LOGD("%s]: (%d)", __FUNCTION__, error);
  457. mMutex.lock();
  458. auto gnssCbIface(mGnssCbIface);
  459. mMutex.unlock();
  460. if (error == LOCATION_ERROR_SUCCESS && gnssCbIface != nullptr) {
  461. auto r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_END);
  462. if (!r.isOk()) {
  463. LOC_LOGE("%s] Error from gnssStatusCb SESSION_END description=%s",
  464. __func__, r.description().c_str());
  465. }
  466. r = gnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_OFF);
  467. if (!r.isOk()) {
  468. LOC_LOGE("%s] Error from gnssStatusCb ENGINE_OFF description=%s",
  469. __func__, r.description().c_str());
  470. }
  471. }
  472. }
  473. static void convertGnssSvStatus(GnssSvNotification& in, IGnssCallback::GnssSvStatus& out)
  474. {
  475. memset(&out, 0, sizeof(IGnssCallback::GnssSvStatus));
  476. out.numSvs = in.count;
  477. if (out.numSvs > static_cast<uint32_t>(V1_0::GnssMax::SVS_COUNT)) {
  478. LOC_LOGW("%s]: Too many satellites %u. Clamps to %d.",
  479. __FUNCTION__, out.numSvs, V1_0::GnssMax::SVS_COUNT);
  480. out.numSvs = static_cast<uint32_t>(V1_0::GnssMax::SVS_COUNT);
  481. }
  482. for (size_t i = 0; i < out.numSvs; i++) {
  483. IGnssCallback::GnssSvInfo& info = out.gnssSvList[i];
  484. convertGnssSvid(in.gnssSvs[i], info.svid);
  485. convertGnssConstellationType(in.gnssSvs[i].type, info.constellation);
  486. info.cN0Dbhz = in.gnssSvs[i].cN0Dbhz;
  487. info.elevationDegrees = in.gnssSvs[i].elevation;
  488. info.azimuthDegrees = in.gnssSvs[i].azimuth;
  489. info.carrierFrequencyHz = in.gnssSvs[i].carrierFrequencyHz;
  490. info.svFlag = static_cast<uint8_t>(IGnssCallback::GnssSvFlags::NONE);
  491. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_EPHEMER_BIT)
  492. info.svFlag |= IGnssCallback::GnssSvFlags::HAS_EPHEMERIS_DATA;
  493. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_ALMANAC_BIT)
  494. info.svFlag |= IGnssCallback::GnssSvFlags::HAS_ALMANAC_DATA;
  495. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT)
  496. info.svFlag |= IGnssCallback::GnssSvFlags::USED_IN_FIX;
  497. if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_CARRIER_FREQUENCY_BIT)
  498. info.svFlag |= IGnssCallback::GnssSvFlags::HAS_CARRIER_FREQUENCY;
  499. }
  500. }
  501. } // namespace implementation
  502. } // namespace V1_1
  503. } // namespace gnss
  504. } // namespace hardware
  505. } // namespace android