LocationAPIClientBase.h 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592
  1. /* Copyright (c) 2017,2020-2021 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. #ifndef LOCATION_API_CLINET_BASE_H
  29. #define LOCATION_API_CLINET_BASE_H
  30. #include <stdint.h>
  31. #include <stdlib.h>
  32. #include <pthread.h>
  33. #include <queue>
  34. #include <map>
  35. #include "LocationAPI.h"
  36. #include <loc_pla.h>
  37. #include <log_util.h>
  38. enum SESSION_MODE {
  39. SESSION_MODE_NONE = 0,
  40. SESSION_MODE_ON_FULL,
  41. SESSION_MODE_ON_FIX,
  42. SESSION_MODE_ON_TRIP_COMPLETED
  43. };
  44. enum REQUEST_TYPE {
  45. REQUEST_TRACKING = 0,
  46. REQUEST_SESSION,
  47. REQUEST_GEOFENCE,
  48. REQUEST_NIRESPONSE,
  49. REQUEST_MAX,
  50. };
  51. enum CTRL_REQUEST_TYPE {
  52. CTRL_REQUEST_DELETEAIDINGDATA = 0,
  53. CTRL_REQUEST_CONTROL,
  54. CTRL_REQUEST_CONFIG_UPDATE,
  55. CTRL_REQUEST_CONFIG_GET,
  56. CTRL_REQUEST_MAX,
  57. };
  58. class LocationAPIClientBase;
  59. class LocationAPIRequest {
  60. public:
  61. LocationAPIRequest() {}
  62. virtual ~LocationAPIRequest() {}
  63. virtual void onResponse(LocationError /*error*/, uint32_t /*id*/) {}
  64. virtual void onCollectiveResponse(
  65. size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
  66. };
  67. class RequestQueue {
  68. public:
  69. RequestQueue(): mSession(0), mSessionArrayPtr(nullptr) {
  70. }
  71. virtual ~RequestQueue() {
  72. reset((uint32_t)0);
  73. }
  74. void inline setSession(uint32_t session) { mSession = session; }
  75. void inline setSessionArrayPtr(uint32_t* ptr) { mSessionArrayPtr = ptr; }
  76. void reset(uint32_t session) {
  77. LocationAPIRequest* request = nullptr;
  78. while (!mQueue.empty()) {
  79. request = mQueue.front();
  80. mQueue.pop();
  81. delete request;
  82. }
  83. mSession = session;
  84. }
  85. void reset(uint32_t* sessionArrayPtr) {
  86. reset((uint32_t)0);
  87. mSessionArrayPtr = sessionArrayPtr;
  88. }
  89. void push(LocationAPIRequest* request) {
  90. mQueue.push(request);
  91. }
  92. LocationAPIRequest* pop() {
  93. LocationAPIRequest* request = nullptr;
  94. if (!mQueue.empty()) {
  95. request = mQueue.front();
  96. mQueue.pop();
  97. }
  98. return request;
  99. }
  100. uint32_t getSession() { return mSession; }
  101. uint32_t* getSessionArrayPtr() { return mSessionArrayPtr; }
  102. private:
  103. uint32_t mSession;
  104. uint32_t* mSessionArrayPtr;
  105. std::queue<LocationAPIRequest*> mQueue;
  106. };
  107. class LocationAPIControlClient {
  108. public:
  109. LocationAPIControlClient();
  110. virtual ~LocationAPIControlClient();
  111. LocationAPIControlClient(const LocationAPIControlClient&) = delete;
  112. LocationAPIControlClient& operator=(const LocationAPIControlClient&) = delete;
  113. LocationAPIRequest* getRequestBySession(uint32_t session);
  114. LocationAPIRequest* getRequestBySessionArrayPtr(uint32_t* sessionArrayPtr);
  115. // LocationControlAPI
  116. uint32_t locAPIGnssDeleteAidingData(GnssAidingData& data);
  117. uint32_t locAPIEnable(LocationTechnologyType techType);
  118. void locAPIDisable();
  119. uint32_t locAPIGnssUpdateConfig(GnssConfig config);
  120. uint32_t locAPIGnssGetConfig(GnssConfigFlagsMask config);
  121. inline LocationControlAPI* getControlAPI() { return mLocationControlAPI; }
  122. // callbacks
  123. void onCtrlResponseCb(LocationError error, uint32_t id);
  124. void onCtrlCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids);
  125. inline virtual void onGnssDeleteAidingDataCb(LocationError /*error*/) {}
  126. inline virtual void onEnableCb(LocationError /*error*/) {}
  127. inline virtual void onDisableCb(LocationError /*error*/) {}
  128. inline virtual void onGnssUpdateConfigCb(
  129. size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
  130. inline virtual void onGnssGetConfigCb(
  131. size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
  132. class GnssDeleteAidingDataRequest : public LocationAPIRequest {
  133. public:
  134. GnssDeleteAidingDataRequest(LocationAPIControlClient& API) : mAPI(API) {}
  135. inline void onResponse(LocationError error, uint32_t /*id*/) {
  136. mAPI.onGnssDeleteAidingDataCb(error);
  137. }
  138. LocationAPIControlClient& mAPI;
  139. };
  140. class EnableRequest : public LocationAPIRequest {
  141. public:
  142. EnableRequest(LocationAPIControlClient& API) : mAPI(API) {}
  143. inline void onResponse(LocationError error, uint32_t /*id*/) {
  144. mAPI.onEnableCb(error);
  145. }
  146. LocationAPIControlClient& mAPI;
  147. };
  148. class DisableRequest : public LocationAPIRequest {
  149. public:
  150. DisableRequest(LocationAPIControlClient& API) : mAPI(API) {}
  151. inline void onResponse(LocationError error, uint32_t /*id*/) {
  152. mAPI.onDisableCb(error);
  153. }
  154. LocationAPIControlClient& mAPI;
  155. };
  156. class GnssUpdateConfigRequest : public LocationAPIRequest {
  157. public:
  158. GnssUpdateConfigRequest(LocationAPIControlClient& API) : mAPI(API) {}
  159. inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* ids) {
  160. mAPI.onGnssUpdateConfigCb(count, errors, ids);
  161. }
  162. LocationAPIControlClient& mAPI;
  163. };
  164. class GnssGetConfigRequest : public LocationAPIRequest {
  165. public:
  166. GnssGetConfigRequest(LocationAPIControlClient& API) : mAPI(API) {}
  167. inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* ids) {
  168. mAPI.onGnssGetConfigCb(count, errors, ids);
  169. }
  170. LocationAPIControlClient& mAPI;
  171. };
  172. private:
  173. pthread_mutex_t mMutex;
  174. LocationControlAPI* mLocationControlAPI;
  175. RequestQueue mRequestQueues[CTRL_REQUEST_MAX];
  176. bool mEnabled;
  177. };
  178. class LocationAPIClientBase {
  179. public:
  180. LocationAPIClientBase();
  181. LocationAPIClientBase(const LocationAPIClientBase&) = delete;
  182. LocationAPIClientBase& operator=(const LocationAPIClientBase&) = delete;
  183. void destroy();
  184. void onLocationApiDestroyCompleteCb();
  185. void locAPISetCallbacks(LocationCallbacks& locationCallbacks);
  186. void removeSession(uint32_t session);
  187. LocationAPIRequest* getRequestBySession(uint32_t session);
  188. // LocationAPI
  189. uint32_t locAPIStartTracking(TrackingOptions& trackingOptions);
  190. void locAPIStopTracking();
  191. void locAPIUpdateTrackingOptions(TrackingOptions& trackingOptions);
  192. int32_t locAPIGetBatchSize();
  193. uint32_t locAPIStartSession(
  194. uint32_t id, uint32_t sessionMode, TrackingOptions&& trackingOptions);
  195. uint32_t locAPIStopSession(uint32_t id);
  196. uint32_t locAPIUpdateSessionOptions(
  197. uint32_t id, uint32_t sessionMode, TrackingOptions&& trackingOptions);
  198. uint32_t locAPIGetBatchedLocations(uint32_t id, size_t count);
  199. uint32_t locAPIAddGeofences(size_t count, uint32_t* ids,
  200. GeofenceOption* options, GeofenceInfo* data);
  201. void locAPIRemoveGeofences(size_t count, uint32_t* ids);
  202. void locAPIModifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options);
  203. void locAPIPauseGeofences(size_t count, uint32_t* ids);
  204. void locAPIResumeGeofences(size_t count, uint32_t* ids, GeofenceBreachTypeMask* mask);
  205. void locAPIRemoveAllGeofences();
  206. void locAPIGnssNiResponse(uint32_t id, GnssNiResponse response);
  207. // callbacks
  208. void onResponseCb(LocationError error, uint32_t id);
  209. void onCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids);
  210. void beforeGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification);
  211. inline virtual void onCapabilitiesCb(LocationCapabilitiesMask /*capabilitiesMask*/) {}
  212. inline virtual void onGnssNmeaCb(GnssNmeaNotification /*gnssNmeaNotification*/) {}
  213. inline virtual void onGnssDataCb(GnssDataNotification /*gnssDataNotification*/) {}
  214. inline virtual void onGnssMeasurementsCb(
  215. GnssMeasurementsNotification /*gnssMeasurementsNotification*/) {}
  216. inline virtual void onGnssNHzMeasurementsCb(
  217. GnssMeasurementsNotification /*gnssMeasurementsNotification*/) {}
  218. inline virtual void onTrackingCb(Location /*location*/) {}
  219. inline virtual void onGnssSvCb(GnssSvNotification /*gnssSvNotification*/) {}
  220. inline virtual void onStartTrackingCb(LocationError /*error*/) {}
  221. inline virtual void onStopTrackingCb(LocationError /*error*/) {}
  222. inline virtual void onUpdateTrackingOptionsCb(LocationError /*error*/) {}
  223. inline virtual void onGnssLocationInfoCb(
  224. GnssLocationInfoNotification /*gnssLocationInfoNotification*/) {}
  225. inline virtual void onBatchingCb(size_t /*count*/, Location* /*location*/,
  226. BatchingOptions /*batchingOptions*/) {}
  227. inline virtual void onBatchingStatusCb(BatchingStatusInfo /*batchingStatus*/,
  228. std::list<uint32_t> &/*listOfCompletedTrips*/) {}
  229. void beforeBatchingStatusCb(BatchingStatusInfo batchStatus,
  230. std::list<uint32_t> & tripCompletedList);
  231. inline virtual void onStartBatchingCb(LocationError /*error*/) {}
  232. inline virtual void onStopBatchingCb(LocationError /*error*/) {}
  233. inline virtual void onUpdateBatchingOptionsCb(LocationError /*error*/) {}
  234. inline virtual void onGetBatchedLocationsCb(LocationError /*error*/) {}
  235. inline virtual void onGeofenceBreachCb(
  236. GeofenceBreachNotification /*geofenceBreachNotification*/) {}
  237. inline virtual void onGeofenceStatusCb(
  238. GeofenceStatusNotification /*geofenceStatusNotification*/) {}
  239. inline virtual void onAddGeofencesCb(
  240. size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
  241. inline virtual void onRemoveGeofencesCb(
  242. size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
  243. inline virtual void onModifyGeofencesCb(
  244. size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
  245. inline virtual void onPauseGeofencesCb(
  246. size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
  247. inline virtual void onResumeGeofencesCb(
  248. size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
  249. inline virtual void onGnssNiCb(uint32_t /*id*/, GnssNiNotification /*gnssNiNotification*/) {}
  250. inline virtual void onGnssNiResponseCb(LocationError /*error*/) {}
  251. inline virtual void onLocationSystemInfoCb(LocationSystemInfo /*locationSystemInfo*/) {}
  252. protected:
  253. virtual ~LocationAPIClientBase();
  254. private:
  255. // private inner classes
  256. typedef struct {
  257. uint32_t id;
  258. uint32_t trackingSession;
  259. uint32_t batchingSession;
  260. uint32_t sessionMode;
  261. } SessionEntity;
  262. template<typename T>
  263. class BiDict {
  264. public:
  265. BiDict() {
  266. pthread_mutex_init(&mBiDictMutex, nullptr);
  267. }
  268. virtual ~BiDict() {
  269. pthread_mutex_destroy(&mBiDictMutex);
  270. }
  271. bool hasId(uint32_t id) {
  272. pthread_mutex_lock(&mBiDictMutex);
  273. bool ret = (mForwardMap.find(id) != mForwardMap.end());
  274. pthread_mutex_unlock(&mBiDictMutex);
  275. return ret;
  276. }
  277. bool hasSession(uint32_t session) {
  278. pthread_mutex_lock(&mBiDictMutex);
  279. bool ret = (mBackwardMap.find(session) != mBackwardMap.end());
  280. pthread_mutex_unlock(&mBiDictMutex);
  281. return ret;
  282. }
  283. void set(uint32_t id, uint32_t session, T& ext) {
  284. pthread_mutex_lock(&mBiDictMutex);
  285. mForwardMap[id] = session;
  286. mBackwardMap[session] = id;
  287. mExtMap[session] = ext;
  288. pthread_mutex_unlock(&mBiDictMutex);
  289. }
  290. void clear() {
  291. pthread_mutex_lock(&mBiDictMutex);
  292. mForwardMap.clear();
  293. mBackwardMap.clear();
  294. mExtMap.clear();
  295. pthread_mutex_unlock(&mBiDictMutex);
  296. }
  297. void rmById(uint32_t id) {
  298. pthread_mutex_lock(&mBiDictMutex);
  299. mBackwardMap.erase(mForwardMap[id]);
  300. mExtMap.erase(mForwardMap[id]);
  301. mForwardMap.erase(id);
  302. pthread_mutex_unlock(&mBiDictMutex);
  303. }
  304. void rmBySession(uint32_t session) {
  305. pthread_mutex_lock(&mBiDictMutex);
  306. mForwardMap.erase(mBackwardMap[session]);
  307. mBackwardMap.erase(session);
  308. mExtMap.erase(session);
  309. pthread_mutex_unlock(&mBiDictMutex);
  310. }
  311. uint32_t getId(uint32_t session) {
  312. pthread_mutex_lock(&mBiDictMutex);
  313. uint32_t ret = 0;
  314. auto it = mBackwardMap.find(session);
  315. if (it != mBackwardMap.end()) {
  316. ret = it->second;
  317. }
  318. pthread_mutex_unlock(&mBiDictMutex);
  319. return ret;
  320. }
  321. uint32_t getSession(uint32_t id) {
  322. pthread_mutex_lock(&mBiDictMutex);
  323. uint32_t ret = 0;
  324. auto it = mForwardMap.find(id);
  325. if (it != mForwardMap.end()) {
  326. ret = it->second;
  327. }
  328. pthread_mutex_unlock(&mBiDictMutex);
  329. return ret;
  330. }
  331. T getExtById(uint32_t id) {
  332. pthread_mutex_lock(&mBiDictMutex);
  333. T ret;
  334. memset(&ret, 0, sizeof(T));
  335. uint32_t session = mForwardMap[id];
  336. if (session > 0) {
  337. auto it = mExtMap.find(session);
  338. if (it != mExtMap.end()) {
  339. ret = it->second;
  340. }
  341. }
  342. pthread_mutex_unlock(&mBiDictMutex);
  343. return ret;
  344. }
  345. T getExtBySession(uint32_t session) {
  346. pthread_mutex_lock(&mBiDictMutex);
  347. T ret;
  348. memset(&ret, 0, sizeof(T));
  349. auto it = mExtMap.find(session);
  350. if (it != mExtMap.end()) {
  351. ret = it->second;
  352. }
  353. pthread_mutex_unlock(&mBiDictMutex);
  354. return ret;
  355. }
  356. std::vector<uint32_t> getAllIds() {
  357. std::vector<uint32_t> ret;
  358. pthread_mutex_lock(&mBiDictMutex);
  359. for (auto idToSessionPair : mForwardMap) {
  360. ret.push_back(idToSessionPair.first);
  361. }
  362. pthread_mutex_unlock(&mBiDictMutex);
  363. return ret;
  364. }
  365. private:
  366. pthread_mutex_t mBiDictMutex;
  367. // mForwarMap mapping id->session
  368. std::map<uint32_t, uint32_t> mForwardMap;
  369. // mBackwardMap mapping session->id
  370. std::map<uint32_t, uint32_t> mBackwardMap;
  371. // mExtMap mapping session->ext
  372. std::map<uint32_t, T> mExtMap;
  373. };
  374. class StartTrackingRequest : public LocationAPIRequest {
  375. public:
  376. StartTrackingRequest(LocationAPIClientBase& API) : mAPI(API) {}
  377. inline void onResponse(LocationError error, uint32_t id) {
  378. if (error != LOCATION_ERROR_SUCCESS) {
  379. mAPI.removeSession(id);
  380. }
  381. mAPI.onStartTrackingCb(error);
  382. }
  383. LocationAPIClientBase& mAPI;
  384. };
  385. class StopTrackingRequest : public LocationAPIRequest {
  386. public:
  387. StopTrackingRequest(LocationAPIClientBase& API) : mAPI(API) {}
  388. inline void onResponse(LocationError error, uint32_t id) {
  389. mAPI.onStopTrackingCb(error);
  390. if (error == LOCATION_ERROR_SUCCESS) {
  391. mAPI.removeSession(id);
  392. }
  393. }
  394. LocationAPIClientBase& mAPI;
  395. };
  396. class UpdateTrackingOptionsRequest : public LocationAPIRequest {
  397. public:
  398. UpdateTrackingOptionsRequest(LocationAPIClientBase& API) : mAPI(API) {}
  399. inline void onResponse(LocationError error, uint32_t /*id*/) {
  400. mAPI.onUpdateTrackingOptionsCb(error);
  401. }
  402. LocationAPIClientBase& mAPI;
  403. };
  404. class StartBatchingRequest : public LocationAPIRequest {
  405. public:
  406. StartBatchingRequest(LocationAPIClientBase& API) : mAPI(API) {}
  407. inline void onResponse(LocationError error, uint32_t id) {
  408. if (error != LOCATION_ERROR_SUCCESS) {
  409. mAPI.removeSession(id);
  410. }
  411. mAPI.onStartBatchingCb(error);
  412. }
  413. LocationAPIClientBase& mAPI;
  414. };
  415. class StopBatchingRequest : public LocationAPIRequest {
  416. public:
  417. StopBatchingRequest(LocationAPIClientBase& API) : mAPI(API) {}
  418. inline void onResponse(LocationError error, uint32_t id) {
  419. mAPI.onStopBatchingCb(error);
  420. if (error == LOCATION_ERROR_SUCCESS) {
  421. mAPI.removeSession(id);
  422. }
  423. }
  424. LocationAPIClientBase& mAPI;
  425. };
  426. class UpdateBatchingOptionsRequest : public LocationAPIRequest {
  427. public:
  428. UpdateBatchingOptionsRequest(LocationAPIClientBase& API) : mAPI(API) {}
  429. inline void onResponse(LocationError error, uint32_t /*id*/) {
  430. mAPI.onUpdateBatchingOptionsCb(error);
  431. }
  432. LocationAPIClientBase& mAPI;
  433. };
  434. class GetBatchedLocationsRequest : public LocationAPIRequest {
  435. public:
  436. GetBatchedLocationsRequest(LocationAPIClientBase& API) : mAPI(API) {}
  437. inline void onResponse(LocationError error, uint32_t /*id*/) {
  438. mAPI.onGetBatchedLocationsCb(error);
  439. }
  440. LocationAPIClientBase& mAPI;
  441. };
  442. class AddGeofencesRequest : public LocationAPIRequest {
  443. public:
  444. AddGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
  445. inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
  446. uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
  447. for (size_t i = 0; i < count; i++) {
  448. ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
  449. }
  450. LOC_LOGD("%s:]Returned geofence-id: %d in add geofence", __FUNCTION__, *ids);
  451. mAPI.onAddGeofencesCb(count, errors, ids);
  452. free(ids);
  453. }
  454. LocationAPIClientBase& mAPI;
  455. };
  456. class RemoveGeofencesRequest : public LocationAPIRequest {
  457. public:
  458. RemoveGeofencesRequest(LocationAPIClientBase& API,
  459. BiDict<GeofenceBreachTypeMask>* removedGeofenceBiDict) :
  460. mAPI(API), mRemovedGeofenceBiDict(removedGeofenceBiDict) {}
  461. inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
  462. if (nullptr != mRemovedGeofenceBiDict) {
  463. uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
  464. for (size_t i = 0; i < count; i++) {
  465. ids[i] = mRemovedGeofenceBiDict->getId(sessions[i]);
  466. }
  467. LOC_LOGD("%s:]Returned geofence-id: %d in remove geofence", __FUNCTION__, *ids);
  468. mAPI.onRemoveGeofencesCb(count, errors, ids);
  469. free(ids);
  470. delete(mRemovedGeofenceBiDict);
  471. } else {
  472. LOC_LOGE("%s:%d] Unable to access removed geofences data.", __FUNCTION__, __LINE__);
  473. }
  474. }
  475. LocationAPIClientBase& mAPI;
  476. BiDict<GeofenceBreachTypeMask>* mRemovedGeofenceBiDict;
  477. };
  478. class ModifyGeofencesRequest : public LocationAPIRequest {
  479. public:
  480. ModifyGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
  481. inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
  482. uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
  483. for (size_t i = 0; i < count; i++) {
  484. ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
  485. }
  486. mAPI.onModifyGeofencesCb(count, errors, ids);
  487. free(ids);
  488. }
  489. LocationAPIClientBase& mAPI;
  490. };
  491. class PauseGeofencesRequest : public LocationAPIRequest {
  492. public:
  493. PauseGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
  494. inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
  495. uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
  496. for (size_t i = 0; i < count; i++) {
  497. ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
  498. }
  499. mAPI.onPauseGeofencesCb(count, errors, ids);
  500. free(ids);
  501. }
  502. LocationAPIClientBase& mAPI;
  503. };
  504. class ResumeGeofencesRequest : public LocationAPIRequest {
  505. public:
  506. ResumeGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
  507. inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
  508. uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
  509. for (size_t i = 0; i < count; i++) {
  510. ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
  511. }
  512. mAPI.onResumeGeofencesCb(count, errors, ids);
  513. free(ids);
  514. }
  515. LocationAPIClientBase& mAPI;
  516. };
  517. class GnssNiResponseRequest : public LocationAPIRequest {
  518. public:
  519. GnssNiResponseRequest(LocationAPIClientBase& API) : mAPI(API) {}
  520. inline void onResponse(LocationError error, uint32_t /*id*/) {
  521. mAPI.onGnssNiResponseCb(error);
  522. }
  523. LocationAPIClientBase& mAPI;
  524. };
  525. private:
  526. pthread_mutex_t mMutex;
  527. geofenceBreachCallback mGeofenceBreachCallback;
  528. batchingStatusCallback mBatchingStatusCallback;
  529. LocationAPI* mLocationAPI;
  530. RequestQueue mRequestQueues[REQUEST_MAX];
  531. BiDict<GeofenceBreachTypeMask> mGeofenceBiDict;
  532. BiDict<SessionEntity> mSessionBiDict;
  533. int32_t mBatchSize;
  534. bool mTracking;
  535. };
  536. #endif /* LOCATION_API_CLINET_BASE_H */