summaryrefslogtreecommitdiff
path: root/gps/location
diff options
context:
space:
mode:
Diffstat (limited to 'gps/location')
-rw-r--r--gps/location/Android.mk41
-rw-r--r--gps/location/LocationAPI.cpp645
-rw-r--r--gps/location/LocationAPI.h974
-rw-r--r--gps/location/LocationAPIClientBase.cpp914
-rw-r--r--gps/location/LocationAPIClientBase.h560
-rw-r--r--gps/location/Makefile.am38
-rw-r--r--gps/location/configure.ac82
-rw-r--r--gps/location/location-api.pc.in10
-rw-r--r--gps/location/location_interface.h97
9 files changed, 0 insertions, 3361 deletions
diff --git a/gps/location/Android.mk b/gps/location/Android.mk
deleted file mode 100644
index bbd6fbd..0000000
--- a/gps/location/Android.mk
+++ /dev/null
@@ -1,41 +0,0 @@
-ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
-ifneq ($(BUILD_TINY_ANDROID),true)
-
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := liblocation_api
-LOCAL_VENDOR_MODULE := true
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SHARED_LIBRARIES := \
- libutils \
- libcutils \
- libgps.utils \
- libdl \
- liblog
-
-LOCAL_SRC_FILES += \
- LocationAPI.cpp \
- LocationAPIClientBase.cpp
-
-LOCAL_CFLAGS += \
- -fno-short-enums
-
-LOCAL_HEADER_LIBRARIES := \
- libloc_pla_headers \
- libgps.utils_headers
-
-LOCAL_PRELINK_MODULE := false
-
-LOCAL_CFLAGS += $(GNSS_CFLAGS)
-include $(BUILD_SHARED_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := liblocation_api_headers
-LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
-include $(BUILD_HEADER_LIBRARY)
-
-endif # not BUILD_TINY_ANDROID
-endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
diff --git a/gps/location/LocationAPI.cpp b/gps/location/LocationAPI.cpp
deleted file mode 100644
index 0111a9c..0000000
--- a/gps/location/LocationAPI.cpp
+++ /dev/null
@@ -1,645 +0,0 @@
-/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#define LOG_TAG "LocSvc_LocationAPI"
-
-#include <location_interface.h>
-#include <dlfcn.h>
-#include <loc_pla.h>
-#include <log_util.h>
-#include <pthread.h>
-#include <map>
-
-typedef void* (getLocationInterface)();
-typedef std::map<LocationAPI*, LocationCallbacks> LocationClientMap;
-typedef struct {
- LocationClientMap clientData;
- LocationControlAPI* controlAPI;
- LocationControlCallbacks controlCallbacks;
- GnssInterface* gnssInterface;
- GeofenceInterface* geofenceInterface;
- FlpInterface* flpInterface;
-} LocationAPIData;
-static LocationAPIData gData = {};
-static pthread_mutex_t gDataMutex = PTHREAD_MUTEX_INITIALIZER;
-static bool gGnssLoadFailed = false;
-static bool gFlpLoadFailed = false;
-static bool gGeofenceLoadFailed = false;
-
-static bool needsGnssTrackingInfo(LocationCallbacks& locationCallbacks)
-{
- return (locationCallbacks.gnssLocationInfoCb != nullptr ||
- locationCallbacks.gnssSvCb != nullptr ||
- locationCallbacks.gnssNmeaCb != nullptr ||
- locationCallbacks.gnssMeasurementsCb != nullptr);
-}
-
-static bool isGnssClient(LocationCallbacks& locationCallbacks)
-{
- return (locationCallbacks.gnssNiCb != nullptr ||
- locationCallbacks.trackingCb != nullptr ||
- locationCallbacks.gnssMeasurementsCb != nullptr);
-}
-
-static bool isFlpClient(LocationCallbacks& locationCallbacks)
-{
- return (locationCallbacks.trackingCb != nullptr ||
- locationCallbacks.batchingCb != nullptr);
-}
-
-static bool isGeofenceClient(LocationCallbacks& locationCallbacks)
-{
- return (locationCallbacks.geofenceBreachCb != nullptr ||
- locationCallbacks.geofenceStatusCb != nullptr);
-}
-
-static void* loadLocationInterface(const char* library, const char* name) {
- LOC_LOGD("%s]: loading %s::%s ...", __func__, library, name);
- if (NULL == library || NULL == name) {
- return NULL;
- }
- getLocationInterface* getter = NULL;
- const char *error = NULL;
- dlerror();
- void *handle = dlopen(library, RTLD_NOW);
- if (NULL == handle || (error = dlerror()) != NULL) {
- LOC_LOGW("dlopen for %s failed, error = %s", library, error);
- } else {
- getter = (getLocationInterface*)dlsym(handle, name);
- if ((error = dlerror()) != NULL) {
- LOC_LOGW("dlsym for %s::%s failed, error = %s", library, name, error);
- getter = NULL;
- }
- }
-
- if (NULL == getter) {
- return (void*)getter;
- } else {
- return (*getter)();
- }
-}
-
-LocationAPI*
-LocationAPI::createInstance(LocationCallbacks& locationCallbacks)
-{
- if (nullptr == locationCallbacks.capabilitiesCb ||
- nullptr == locationCallbacks.responseCb ||
- nullptr == locationCallbacks.collectiveResponseCb) {
- return NULL;
- }
-
- LocationAPI* newLocationAPI = new LocationAPI();
- bool requestedCapabilities = false;
-
- pthread_mutex_lock(&gDataMutex);
-
- if (isGnssClient(locationCallbacks)) {
- if (NULL == gData.gnssInterface && !gGnssLoadFailed) {
- gData.gnssInterface =
- (GnssInterface*)loadLocationInterface("libgnss.so", "getGnssInterface");
- if (NULL == gData.gnssInterface) {
- gGnssLoadFailed = true;
- LOC_LOGW("%s:%d]: No gnss interface available", __func__, __LINE__);
- } else {
- gData.gnssInterface->initialize();
- }
- }
- if (NULL != gData.gnssInterface) {
- gData.gnssInterface->addClient(newLocationAPI, locationCallbacks);
- if (!requestedCapabilities) {
- gData.gnssInterface->requestCapabilities(newLocationAPI);
- requestedCapabilities = true;
- }
- }
- }
-
- if (isFlpClient(locationCallbacks)) {
- if (NULL == gData.flpInterface && !gFlpLoadFailed) {
- gData.flpInterface =
- (FlpInterface*)loadLocationInterface("libflp.so", "getFlpInterface");
- if (NULL == gData.flpInterface) {
- gFlpLoadFailed = true;
- LOC_LOGW("%s:%d]: No flp interface available", __func__, __LINE__);
- } else {
- gData.flpInterface->initialize();
- }
- }
- if (NULL != gData.flpInterface) {
- gData.flpInterface->addClient(newLocationAPI, locationCallbacks);
- if (!requestedCapabilities) {
- gData.flpInterface->requestCapabilities(newLocationAPI);
- requestedCapabilities = true;
- }
- }
- }
-
- if (isGeofenceClient(locationCallbacks)) {
- if (NULL == gData.geofenceInterface && !gGeofenceLoadFailed) {
- gData.geofenceInterface =
- (GeofenceInterface*)loadLocationInterface("libgeofence.so", "getGeofenceInterface");
- if (NULL == gData.geofenceInterface) {
- gGeofenceLoadFailed = true;
- LOC_LOGW("%s:%d]: No geofence interface available", __func__, __LINE__);
- } else {
- gData.geofenceInterface->initialize();
- }
- }
- if (NULL != gData.geofenceInterface) {
- gData.geofenceInterface->addClient(newLocationAPI, locationCallbacks);
- if (!requestedCapabilities) {
- gData.geofenceInterface->requestCapabilities(newLocationAPI);
- requestedCapabilities = true;
- }
- }
- }
-
- gData.clientData[newLocationAPI] = locationCallbacks;
-
- pthread_mutex_unlock(&gDataMutex);
-
- return newLocationAPI;
-}
-
-void
-LocationAPI::destroy()
-{
- delete this;
-}
-
-LocationAPI::LocationAPI()
-{
- LOC_LOGD("LOCATION API CONSTRUCTOR");
-}
-
-LocationAPI::~LocationAPI()
-{
- LOC_LOGD("LOCATION API DESTRUCTOR");
- pthread_mutex_lock(&gDataMutex);
-
- auto it = gData.clientData.find(this);
- if (it != gData.clientData.end()) {
- if (isGnssClient(it->second) && NULL != gData.gnssInterface) {
- gData.gnssInterface->removeClient(it->first);
- }
- if (isFlpClient(it->second) && NULL != gData.flpInterface) {
- gData.flpInterface->removeClient(it->first);
- }
- if (isGeofenceClient(it->second) && NULL != gData.geofenceInterface) {
- gData.geofenceInterface->removeClient(it->first);
- }
- gData.clientData.erase(it);
- } else {
- LOC_LOGE("%s:%d]: Location API client %p not found in client data",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-void
-LocationAPI::updateCallbacks(LocationCallbacks& locationCallbacks)
-{
- if (nullptr == locationCallbacks.capabilitiesCb ||
- nullptr == locationCallbacks.responseCb ||
- nullptr == locationCallbacks.collectiveResponseCb) {
- return;
- }
-
- pthread_mutex_lock(&gDataMutex);
-
- if (isGnssClient(locationCallbacks)) {
- if (NULL == gData.gnssInterface && !gGnssLoadFailed) {
- gData.gnssInterface =
- (GnssInterface*)loadLocationInterface("libgnss.so", "getGnssInterface");
- if (NULL == gData.gnssInterface) {
- gGnssLoadFailed = true;
- LOC_LOGW("%s:%d]: No gnss interface available", __func__, __LINE__);
- } else {
- gData.gnssInterface->initialize();
- }
- }
- if (NULL != gData.gnssInterface) {
- // either adds new Client or updates existing Client
- gData.gnssInterface->addClient(this, locationCallbacks);
- }
- }
-
- if (isFlpClient(locationCallbacks)) {
- if (NULL == gData.flpInterface && !gFlpLoadFailed) {
- gData.flpInterface =
- (FlpInterface*)loadLocationInterface("libflp.so", "getFlpInterface");
- if (NULL == gData.flpInterface) {
- gFlpLoadFailed = true;
- LOC_LOGW("%s:%d]: No flp interface available", __func__, __LINE__);
- } else {
- gData.flpInterface->initialize();
- }
- }
- if (NULL != gData.flpInterface) {
- // either adds new Client or updates existing Client
- gData.flpInterface->addClient(this, locationCallbacks);
- }
- }
-
- if (isGeofenceClient(locationCallbacks)) {
- if (NULL == gData.geofenceInterface && !gGeofenceLoadFailed) {
- gData.geofenceInterface =
- (GeofenceInterface*)loadLocationInterface("libgeofence.so", "getGeofenceInterface");
- if (NULL == gData.geofenceInterface) {
- gGeofenceLoadFailed = true;
- LOC_LOGW("%s:%d]: No geofence interface available", __func__, __LINE__);
- } else {
- gData.geofenceInterface->initialize();
- }
- }
- if (NULL != gData.geofenceInterface) {
- // either adds new Client or updates existing Client
- gData.geofenceInterface->addClient(this, locationCallbacks);
- }
- }
-
- gData.clientData[this] = locationCallbacks;
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-uint32_t
-LocationAPI::startTracking(LocationOptions& locationOptions)
-{
- uint32_t id = 0;
- pthread_mutex_lock(&gDataMutex);
-
- auto it = gData.clientData.find(this);
- if (it != gData.clientData.end()) {
- if (gData.flpInterface != NULL && locationOptions.minDistance > 0) {
- id = gData.flpInterface->startTracking(this, locationOptions);
- } else if (gData.gnssInterface != NULL && needsGnssTrackingInfo(it->second)) {
- id = gData.gnssInterface->startTracking(this, locationOptions);
- } else if (gData.flpInterface != NULL) {
- id = gData.flpInterface->startTracking(this, locationOptions);
- } else if (gData.gnssInterface != NULL) {
- id = gData.gnssInterface->startTracking(this, locationOptions);
- } else {
- LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
- } else {
- LOC_LOGE("%s:%d]: Location API client %p not found in client data",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
- return id;
-}
-
-void
-LocationAPI::stopTracking(uint32_t id)
-{
- pthread_mutex_lock(&gDataMutex);
-
- auto it = gData.clientData.find(this);
- if (it != gData.clientData.end()) {
- // we don't know if tracking was started on flp or gnss, so we call stop on both, where
- // stopTracking call to the incorrect interface will fail without response back to client
- if (gData.gnssInterface != NULL) {
- gData.gnssInterface->stopTracking(this, id);
- }
- if (gData.flpInterface != NULL) {
- gData.flpInterface->stopTracking(this, id);
- }
- if (gData.flpInterface == NULL && gData.gnssInterface == NULL) {
- LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
- } else {
- LOC_LOGE("%s:%d]: Location API client %p not found in client data",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-void
-LocationAPI::updateTrackingOptions(uint32_t id, LocationOptions& locationOptions)
-{
- pthread_mutex_lock(&gDataMutex);
-
- auto it = gData.clientData.find(this);
- if (it != gData.clientData.end()) {
- // we don't know if tracking was started on flp or gnss, so we call update on both, where
- // updateTracking call to the incorrect interface will fail without response back to client
- if (gData.gnssInterface != NULL) {
- gData.gnssInterface->updateTrackingOptions(this, id, locationOptions);
- }
- if (gData.flpInterface != NULL) {
- gData.flpInterface->updateTrackingOptions(this, id, locationOptions);
- }
- if (gData.flpInterface == NULL && gData.gnssInterface == NULL) {
- LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
- } else {
- LOC_LOGE("%s:%d]: Location API client %p not found in client data",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-uint32_t
-LocationAPI::startBatching(LocationOptions& locationOptions, BatchingOptions &batchingOptions)
-{
- uint32_t id = 0;
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.flpInterface != NULL) {
- id = gData.flpInterface->startBatching(this, locationOptions, batchingOptions);
- } else {
- LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
- return id;
-}
-
-void
-LocationAPI::stopBatching(uint32_t id)
-{
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.flpInterface != NULL) {
- gData.flpInterface->stopBatching(this, id);
- } else {
- LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-void
-LocationAPI::updateBatchingOptions(uint32_t id,
- LocationOptions& locationOptions, BatchingOptions& batchOptions)
-{
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.flpInterface != NULL) {
- gData.flpInterface->updateBatchingOptions(this,
- id,
- locationOptions,
- batchOptions);
- } else {
- LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-void
-LocationAPI::getBatchedLocations(uint32_t id, size_t count)
-{
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.flpInterface != NULL) {
- gData.flpInterface->getBatchedLocations(this, id, count);
- } else {
- LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-uint32_t*
-LocationAPI::addGeofences(size_t count, GeofenceOption* options, GeofenceInfo* info)
-{
- uint32_t* ids = NULL;
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.geofenceInterface != NULL) {
- ids = gData.geofenceInterface->addGeofences(this, count, options, info);
- } else {
- LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
- return ids;
-}
-
-void
-LocationAPI::removeGeofences(size_t count, uint32_t* ids)
-{
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.geofenceInterface != NULL) {
- gData.geofenceInterface->removeGeofences(this, count, ids);
- } else {
- LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-void
-LocationAPI::modifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options)
-{
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.geofenceInterface != NULL) {
- gData.geofenceInterface->modifyGeofences(this, count, ids, options);
- } else {
- LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-void
-LocationAPI::pauseGeofences(size_t count, uint32_t* ids)
-{
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.geofenceInterface != NULL) {
- gData.geofenceInterface->pauseGeofences(this, count, ids);
- } else {
- LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-void
-LocationAPI::resumeGeofences(size_t count, uint32_t* ids)
-{
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.geofenceInterface != NULL) {
- gData.geofenceInterface->resumeGeofences(this, count, ids);
- } else {
- LOC_LOGE("%s:%d]: No geofence interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-void
-LocationAPI::gnssNiResponse(uint32_t id, GnssNiResponse response)
-{
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.gnssInterface != NULL) {
- gData.gnssInterface->gnssNiResponse(this, id, response);
- } else {
- LOC_LOGE("%s:%d]: No gnss interface available for Location API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-LocationControlAPI*
-LocationControlAPI::createInstance(LocationControlCallbacks& locationControlCallbacks)
-{
- LocationControlAPI* controlAPI = NULL;
- pthread_mutex_lock(&gDataMutex);
-
- if (nullptr != locationControlCallbacks.responseCb && NULL == gData.controlAPI) {
- if (NULL == gData.gnssInterface && !gGnssLoadFailed) {
- gData.gnssInterface =
- (GnssInterface*)loadLocationInterface("libgnss.so", "getGnssInterface");
- if (NULL == gData.gnssInterface) {
- gGnssLoadFailed = true;
- LOC_LOGW("%s:%d]: No gnss interface available", __func__, __LINE__);
- } else {
- gData.gnssInterface->initialize();
- }
- }
- if (NULL != gData.gnssInterface) {
- gData.controlAPI = new LocationControlAPI();
- gData.controlCallbacks = locationControlCallbacks;
- gData.gnssInterface->setControlCallbacks(locationControlCallbacks);
- controlAPI = gData.controlAPI;
- }
- }
-
- pthread_mutex_unlock(&gDataMutex);
- return controlAPI;
-}
-
-void
-LocationControlAPI::destroy()
-{
- delete this;
-}
-
-LocationControlAPI::LocationControlAPI()
-{
- LOC_LOGD("LOCATION CONTROL API CONSTRUCTOR");
-}
-
-LocationControlAPI::~LocationControlAPI()
-{
- LOC_LOGD("LOCATION CONTROL API DESTRUCTOR");
- pthread_mutex_lock(&gDataMutex);
-
- gData.controlAPI = NULL;
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-uint32_t
-LocationControlAPI::enable(LocationTechnologyType techType)
-{
- uint32_t id = 0;
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.gnssInterface != NULL) {
- id = gData.gnssInterface->enable(techType);
- } else {
- LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
- return id;
-}
-
-void
-LocationControlAPI::disable(uint32_t id)
-{
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.gnssInterface != NULL) {
- gData.gnssInterface->disable(id);
- } else {
- LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
-}
-
-uint32_t*
-LocationControlAPI::gnssUpdateConfig(GnssConfig config)
-{
- uint32_t* ids = NULL;
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.gnssInterface != NULL) {
- ids = gData.gnssInterface->gnssUpdateConfig(config);
- } else {
- LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
- return ids;
-}
-
-uint32_t
-LocationControlAPI::gnssDeleteAidingData(GnssAidingData& data)
-{
- uint32_t id = 0;
- pthread_mutex_lock(&gDataMutex);
-
- if (gData.gnssInterface != NULL) {
- id = gData.gnssInterface->gnssDeleteAidingData(data);
- } else {
- LOC_LOGE("%s:%d]: No gnss interface available for Location Control API client %p ",
- __func__, __LINE__, this);
- }
-
- pthread_mutex_unlock(&gDataMutex);
- return id;
-}
diff --git a/gps/location/LocationAPI.h b/gps/location/LocationAPI.h
deleted file mode 100644
index 530b1b0..0000000
--- a/gps/location/LocationAPI.h
+++ /dev/null
@@ -1,974 +0,0 @@
-/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef LOCATION_H
-#define LOCATION_H
-
-#include <vector>
-#include <stdint.h>
-#include <functional>
-#include <list>
-
-#define GNSS_NI_REQUESTOR_MAX 256
-#define GNSS_NI_MESSAGE_ID_MAX 2048
-#define GNSS_SV_MAX 64
-#define GNSS_MEASUREMENTS_MAX 64
-#define GNSS_UTC_TIME_OFFSET (3657)
-
-#define GNSS_BUGREPORT_GPS_MIN (1)
-#define GNSS_BUGREPORT_SBAS_MIN (120)
-#define GNSS_BUGREPORT_GLO_MIN (1)
-#define GNSS_BUGREPORT_QZSS_MIN (193)
-#define GNSS_BUGREPORT_BDS_MIN (1)
-#define GNSS_BUGREPORT_GAL_MIN (1)
-
-typedef enum {
- LOCATION_ERROR_SUCCESS = 0,
- LOCATION_ERROR_GENERAL_FAILURE,
- LOCATION_ERROR_CALLBACK_MISSING,
- LOCATION_ERROR_INVALID_PARAMETER,
- LOCATION_ERROR_ID_EXISTS,
- LOCATION_ERROR_ID_UNKNOWN,
- LOCATION_ERROR_ALREADY_STARTED,
- LOCATION_ERROR_GEOFENCES_AT_MAX,
- LOCATION_ERROR_NOT_SUPPORTED
-} LocationError;
-
-// Flags to indicate which values are valid in a Location
-typedef uint16_t LocationFlagsMask;
-typedef enum {
- LOCATION_HAS_LAT_LONG_BIT = (1<<0), // location has valid latitude and longitude
- LOCATION_HAS_ALTITUDE_BIT = (1<<1), // location has valid altitude
- LOCATION_HAS_SPEED_BIT = (1<<2), // location has valid speed
- LOCATION_HAS_BEARING_BIT = (1<<3), // location has valid bearing
- LOCATION_HAS_ACCURACY_BIT = (1<<4), // location has valid accuracy
- LOCATION_HAS_VERTICAL_ACCURACY_BIT = (1<<5), // location has valid vertical accuracy
- LOCATION_HAS_SPEED_ACCURACY_BIT = (1<<6), // location has valid speed accuracy
- LOCATION_HAS_BEARING_ACCURACY_BIT = (1<<7), // location has valid bearing accuracy
-} LocationFlagsBits;
-
-typedef uint16_t LocationTechnologyMask;
-typedef enum {
- LOCATION_TECHNOLOGY_GNSS_BIT = (1<<0), // location was calculated using GNSS
- LOCATION_TECHNOLOGY_CELL_BIT = (1<<1), // location was calculated using Cell
- LOCATION_TECHNOLOGY_WIFI_BIT = (1<<2), // location was calculated using WiFi
- LOCATION_TECHNOLOGY_SENSORS_BIT = (1<<3), // location was calculated using Sensors
-} LocationTechnologyBits;
-
-typedef enum {
- LOCATION_RELIABILITY_NOT_SET = 0,
- LOCATION_RELIABILITY_VERY_LOW,
- LOCATION_RELIABILITY_LOW,
- LOCATION_RELIABILITY_MEDIUM,
- LOCATION_RELIABILITY_HIGH,
-} LocationReliability;
-
-typedef uint32_t GnssLocationInfoFlagMask;
-typedef enum {
- GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT = (1<<0), // valid altitude mean sea level
- GNSS_LOCATION_INFO_DOP_BIT = (1<<1), // valid pdop, hdop, and vdop
- GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT = (1<<2), // valid magnetic deviation
- GNSS_LOCATION_INFO_HOR_RELIABILITY_BIT = (1<<3), // valid horizontal reliability
- GNSS_LOCATION_INFO_VER_RELIABILITY_BIT = (1<<4), // valid vertical reliability
- GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MAJOR_BIT = (1<<5), // valid elipsode semi major
- GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MINOR_BIT = (1<<6), // valid elipsode semi minor
- GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT = (1<<7),// valid accuracy elipsode azimuth
-} GnssLocationInfoFlagBits;
-
-typedef enum {
- GEOFENCE_BREACH_ENTER = 0,
- GEOFENCE_BREACH_EXIT,
- GEOFENCE_BREACH_DWELL_IN,
- GEOFENCE_BREACH_DWELL_OUT,
- GEOFENCE_BREACH_UNKNOWN,
-} GeofenceBreachType;
-
-typedef uint16_t GeofenceBreachTypeMask;
-typedef enum {
- GEOFENCE_BREACH_ENTER_BIT = (1<<0),
- GEOFENCE_BREACH_EXIT_BIT = (1<<1),
- GEOFENCE_BREACH_DWELL_IN_BIT = (1<<2),
- GEOFENCE_BREACH_DWELL_OUT_BIT = (1<<3),
-} GeofenceBreachTypeBits;
-
-typedef enum {
- GEOFENCE_STATUS_AVAILABILE_NO = 0,
- GEOFENCE_STATUS_AVAILABILE_YES,
-} GeofenceStatusAvailable;
-
-typedef uint32_t LocationCapabilitiesMask;
-typedef enum {
- // supports startTracking API with minInterval param
- LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT = (1<<0),
- // supports startBatching API with minInterval param
- LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT = (1<<1),
- // supports startTracking API with minDistance param
- LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT = (1<<2),
- // supports startBatching API with minDistance param
- LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT = (1<<3),
- // supports addGeofences API
- LOCATION_CAPABILITIES_GEOFENCE_BIT = (1<<4),
- // supports GnssMeasurementsCallback
- LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT = (1<<5),
- // supports startTracking/startBatching API with LocationOptions.mode of MSB (Ms Based)
- LOCATION_CAPABILITIES_GNSS_MSB_BIT = (1<<6),
- // supports startTracking/startBatching API with LocationOptions.mode of MSA (MS Assisted)
- LOCATION_CAPABILITIES_GNSS_MSA_BIT = (1<<7),
- // supports debug nmea sentences in the debugNmeaCallback
- LOCATION_CAPABILITIES_DEBUG_NMEA_BIT = (1<<8),
- // support outdoor trip batching
- LOCATION_CAPABILITIES_OUTDOOR_TRIP_BATCHING_BIT = (1<<9)
-} LocationCapabilitiesBits;
-
-typedef enum {
- LOCATION_TECHNOLOGY_TYPE_GNSS = 0,
-} LocationTechnologyType;
-
-// Configures how GPS is locked when GPS is disabled (through GnssDisable)
-typedef enum {
- GNSS_CONFIG_GPS_LOCK_NONE = 0, // gps is not locked when GPS is disabled (GnssDisable)
- GNSS_CONFIG_GPS_LOCK_MO, // gps mobile originated (MO) is locked when GPS is disabled
- GNSS_CONFIG_GPS_LOCK_NI, // gps network initiated (NI) is locked when GPS is disabled
- GNSS_CONFIG_GPS_LOCK_MO_AND_NI,// gps MO and NI is locked when GPS is disabled
-} GnssConfigGpsLock;
-
-// SUPL version
-typedef enum {
- GNSS_CONFIG_SUPL_VERSION_1_0_0 = 1,
- GNSS_CONFIG_SUPL_VERSION_2_0_0,
- GNSS_CONFIG_SUPL_VERSION_2_0_2,
-} GnssConfigSuplVersion;
-
-// LTE Positioning Profile
-typedef enum {
- GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE = 0, // RRLP on LTE (Default)
- GNSS_CONFIG_LPP_PROFILE_USER_PLANE, // LPP User Plane (UP) on LTE
- GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE, // LPP_Control_Plane (CP)
- GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE, // Both LPP UP and CP
-} GnssConfigLppProfile;
-
-// Technology for LPPe Control Plane
-typedef uint16_t GnssConfigLppeControlPlaneMask;
-typedef enum {
- GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT = (1<<0), // DBH
- GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT = (1<<1), // WLAN_AP_MEASUREMENTS
- GNSS_CONFIG_LPPE_CONTROL_PLANE_SRN_AP_MEASUREMENTS_BIT = (1<<2), // SRN_AP_MEASUREMENTS
- GNSS_CONFIG_LPPE_CONTROL_PLANE_SENSOR_BARO_MEASUREMENTS_BIT = (1<<3),
- // SENSOR_BARO_MEASUREMENTS
-} GnssConfigLppeControlPlaneBits;
-
-// Technology for LPPe User Plane
-typedef uint16_t GnssConfigLppeUserPlaneMask;
-typedef enum {
- GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT = (1<<0), // DBH
- GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT = (1<<1), // WLAN_AP_MEASUREMENTS
- GNSS_CONFIG_LPPE_USER_PLANE_SRN_AP_MEASUREMENTS_BIT = (1<<2), // SRN_AP_MEASUREMENTS
- GNSS_CONFIG_LPPE_USER_PLANE_SENSOR_BARO_MEASUREMENTS_BIT = (1<<3),
- // SENSOR_BARO_MEASUREMENTS
-} GnssConfigLppeUserPlaneBits;
-
-// Positioning Protocol on A-GLONASS system
-typedef uint16_t GnssConfigAGlonassPositionProtocolMask;
-typedef enum {
- GNSS_CONFIG_RRC_CONTROL_PLANE_BIT = (1<<0), // RRC Control Plane
- GNSS_CONFIG_RRLP_USER_PLANE_BIT = (1<<1), // RRLP User Plane
- GNSS_CONFIG_LLP_USER_PLANE_BIT = (1<<2), // LPP User Plane
- GNSS_CONFIG_LLP_CONTROL_PLANE_BIT = (1<<3), // LPP Control Plane
-} GnssConfigAGlonassPositionProtocolBits;
-
-typedef enum {
- GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO = 0,
- GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES,
-} GnssConfigEmergencyPdnForEmergencySupl;
-
-typedef enum {
- GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO = 0,
- GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES,
-} GnssConfigSuplEmergencyServices;
-
-typedef uint16_t GnssConfigSuplModeMask;
-typedef enum {
- GNSS_CONFIG_SUPL_MODE_MSB_BIT = (1<<0),
- GNSS_CONFIG_SUPL_MODE_MSA_BIT = (1<<1),
-} GnssConfigSuplModeBits;
-
-typedef uint32_t GnssConfigFlagsMask;
-typedef enum {
- GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT = (1<<0),
- GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT = (1<<1),
- GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT = (1<<2),
- GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT = (1<<3),
- GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT = (1<<4),
- GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT = (1<<5),
- GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT = (1<<6),
- GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT = (1<<7),
- GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT = (1<<8),
- GNSS_CONFIG_FLAGS_SUPL_MODE_BIT = (1<<9),
-} GnssConfigFlagsBits;
-
-typedef enum {
- GNSS_NI_ENCODING_TYPE_NONE = 0,
- GNSS_NI_ENCODING_TYPE_GSM_DEFAULT,
- GNSS_NI_ENCODING_TYPE_UTF8,
- GNSS_NI_ENCODING_TYPE_UCS2,
-} GnssNiEncodingType;
-
-typedef enum {
- GNSS_NI_TYPE_VOICE = 0,
- GNSS_NI_TYPE_SUPL,
- GNSS_NI_TYPE_CONTROL_PLANE,
- GNSS_NI_TYPE_EMERGENCY_SUPL
-} GnssNiType;
-
-typedef uint16_t GnssNiOptionsMask;
-typedef enum {
- GNSS_NI_OPTIONS_NOTIFICATION_BIT = (1<<0),
- GNSS_NI_OPTIONS_VERIFICATION_BIT = (1<<1),
- GNSS_NI_OPTIONS_PRIVACY_OVERRIDE_BIT = (1<<2),
-} GnssNiOptionsBits;
-
-typedef enum {
- GNSS_NI_RESPONSE_ACCEPT = 1,
- GNSS_NI_RESPONSE_DENY,
- GNSS_NI_RESPONSE_NO_RESPONSE,
- GNSS_NI_RESPONSE_IGNORE,
-} GnssNiResponse;
-
-typedef enum {
- GNSS_SV_TYPE_UNKNOWN = 0,
- GNSS_SV_TYPE_GPS,
- GNSS_SV_TYPE_SBAS,
- GNSS_SV_TYPE_GLONASS,
- GNSS_SV_TYPE_QZSS,
- GNSS_SV_TYPE_BEIDOU,
- GNSS_SV_TYPE_GALILEO,
-} GnssSvType;
-
-typedef enum {
- GNSS_EPH_TYPE_UNKNOWN = 0,
- GNSS_EPH_TYPE_EPHEMERIS,
- GNSS_EPH_TYPE_ALMANAC,
-} GnssEphemerisType;
-
-typedef enum {
- GNSS_EPH_SOURCE_UNKNOWN = 0,
- GNSS_EPH_SOURCE_DEMODULATED,
- GNSS_EPH_SOURCE_SUPL_PROVIDED,
- GNSS_EPH_SOURCE_OTHER_SERVER_PROVIDED,
- GNSS_EPH_SOURCE_LOCAL,
-} GnssEphemerisSource;
-
-typedef enum {
- GNSS_EPH_HEALTH_UNKNOWN = 0,
- GNSS_EPH_HEALTH_GOOD,
- GNSS_EPH_HEALTH_BAD,
-} GnssEphemerisHealth;
-
-typedef uint16_t GnssSvOptionsMask;
-typedef enum {
- GNSS_SV_OPTIONS_HAS_EPHEMER_BIT = (1<<0),
- GNSS_SV_OPTIONS_HAS_ALMANAC_BIT = (1<<1),
- GNSS_SV_OPTIONS_USED_IN_FIX_BIT = (1<<2),
-} GnssSvOptionsBits;
-
-typedef enum {
- GNSS_ASSISTANCE_TYPE_SUPL = 0,
- GNSS_ASSISTANCE_TYPE_C2K,
-} GnssAssistanceType;
-
-typedef enum {
- GNSS_SUPL_MODE_STANDALONE = 0,
- GNSS_SUPL_MODE_MSB,
- GNSS_SUPL_MODE_MSA,
-} GnssSuplMode;
-
-typedef enum {
- BATCHING_MODE_ROUTINE = 0, // positions are reported when batched positions memory is full
- BATCHING_MODE_TRIP, // positions are reported when a certain distance is covered
- BATCHING_MODE_NO_AUTO_REPORT // no report of positions automatically, instead queried on demand
-} BatchingMode;
-
-typedef enum {
- BATCHING_STATUS_TRIP_COMPLETED = 0,
- BATCHING_STATUS_POSITION_AVAILABE,
- BATCHING_STATUS_POSITION_UNAVAILABLE
-} BatchingStatus;
-
-typedef uint16_t GnssMeasurementsAdrStateMask;
-typedef enum {
- GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_UNKNOWN = 0,
- GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT = (1<<0),
- GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT = (1<<1),
- GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT = (1<<2),
-} GnssMeasurementsAdrStateBits;
-
-typedef uint32_t GnssMeasurementsDataFlagsMask;
-typedef enum {
- GNSS_MEASUREMENTS_DATA_SV_ID_BIT = (1<<0),
- GNSS_MEASUREMENTS_DATA_SV_TYPE_BIT = (1<<1),
- GNSS_MEASUREMENTS_DATA_STATE_BIT = (1<<2),
- GNSS_MEASUREMENTS_DATA_RECEIVED_SV_TIME_BIT = (1<<3),
- GNSS_MEASUREMENTS_DATA_RECEIVED_SV_TIME_UNCERTAINTY_BIT = (1<<4),
- GNSS_MEASUREMENTS_DATA_CARRIER_TO_NOISE_BIT = (1<<5),
- GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_BIT = (1<<6),
- GNSS_MEASUREMENTS_DATA_PSEUDORANGE_RATE_UNCERTAINTY_BIT = (1<<7),
- GNSS_MEASUREMENTS_DATA_ADR_STATE_BIT = (1<<8),
- GNSS_MEASUREMENTS_DATA_ADR_BIT = (1<<9),
- GNSS_MEASUREMENTS_DATA_ADR_UNCERTAINTY_BIT = (1<<10),
- GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT = (1<<11),
- GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT = (1<<12),
- GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT = (1<<13),
- GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT = (1<<14),
- GNSS_MEASUREMENTS_DATA_MULTIPATH_INDICATOR_BIT = (1<<15),
- GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT = (1<<16),
- GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT = (1<<17),
-} GnssMeasurementsDataFlagsBits;
-
-typedef uint32_t GnssMeasurementsStateMask;
-typedef enum {
- GNSS_MEASUREMENTS_STATE_UNKNOWN_BIT = 0,
- GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT = (1<<0),
- GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT = (1<<1),
- GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT = (1<<2),
- GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT = (1<<3),
- GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT = (1<<4),
- GNSS_MEASUREMENTS_STATE_SYMBOL_SYNC_BIT = (1<<5),
- GNSS_MEASUREMENTS_STATE_GLO_STRING_SYNC_BIT = (1<<6),
- GNSS_MEASUREMENTS_STATE_GLO_TOD_DECODED_BIT = (1<<7),
- GNSS_MEASUREMENTS_STATE_BDS_D2_BIT_SYNC_BIT = (1<<8),
- GNSS_MEASUREMENTS_STATE_BDS_D2_SUBFRAME_SYNC_BIT = (1<<9),
- GNSS_MEASUREMENTS_STATE_GAL_E1BC_CODE_LOCK_BIT = (1<<10),
- GNSS_MEASUREMENTS_STATE_GAL_E1C_2ND_CODE_LOCK_BIT = (1<<11),
- GNSS_MEASUREMENTS_STATE_GAL_E1B_PAGE_SYNC_BIT = (1<<12),
- GNSS_MEASUREMENTS_STATE_SBAS_SYNC_BIT = (1<<13),
-} GnssMeasurementsStateBits;
-
-typedef enum {
- GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_UNKNOWN = 0,
- GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT,
- GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT,
-} GnssMeasurementsMultipathIndicator;
-
-typedef uint32_t GnssMeasurementsClockFlagsMask;
-typedef enum {
- GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT = (1<<0),
- GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_BIT = (1<<1),
- GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT = (1<<2),
- GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT = (1<<3),
- GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT = (1<<4),
- GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_UNCERTAINTY_BIT = (1<<5),
- GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_BIT = (1<<6),
- GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_UNCERTAINTY_BIT = (1<<7),
- GNSS_MEASUREMENTS_CLOCK_FLAGS_HW_CLOCK_DISCONTINUITY_COUNT_BIT = (1<<8),
-} GnssMeasurementsClockFlagsBits;
-
-typedef uint32_t GnssAidingDataSvMask;
-typedef enum {
- GNSS_AIDING_DATA_SV_EPHEMERIS_BIT = (1<<0), // ephemeris
- GNSS_AIDING_DATA_SV_ALMANAC_BIT = (1<<1), // almanac
- GNSS_AIDING_DATA_SV_HEALTH_BIT = (1<<2), // health
- GNSS_AIDING_DATA_SV_DIRECTION_BIT = (1<<3), // direction
- GNSS_AIDING_DATA_SV_STEER_BIT = (1<<4), // steer
- GNSS_AIDING_DATA_SV_ALMANAC_CORR_BIT = (1<<5), // almanac correction
- GNSS_AIDING_DATA_SV_BLACKLIST_BIT = (1<<6), // blacklist SVs
- GNSS_AIDING_DATA_SV_SA_DATA_BIT = (1<<7), // sensitivity assistance data
- GNSS_AIDING_DATA_SV_NO_EXIST_BIT = (1<<8), // SV does not exist
- GNSS_AIDING_DATA_SV_IONOSPHERE_BIT = (1<<9), // ionosphere correction
- GNSS_AIDING_DATA_SV_TIME_BIT = (1<<10),// reset satellite time
-} GnssAidingDataSvBits;
-
-typedef uint32_t GnssAidingDataSvTypeMask;
-typedef enum {
- GNSS_AIDING_DATA_SV_TYPE_GPS_BIT = (1<<0),
- GNSS_AIDING_DATA_SV_TYPE_GLONASS_BIT = (1<<1),
- GNSS_AIDING_DATA_SV_TYPE_QZSS_BIT = (1<<2),
- GNSS_AIDING_DATA_SV_TYPE_BEIDOU_BIT = (1<<3),
- GNSS_AIDING_DATA_SV_TYPE_GALILEO_BIT = (1<<4),
-} GnssAidingDataSvTypeBits;
-
-typedef struct {
- GnssAidingDataSvMask svMask; // bitwise OR of GnssAidingDataSvBits
- GnssAidingDataSvTypeMask svTypeMask; // bitwise OR of GnssAidingDataSvTypeBits
-} GnssAidingDataSv;
-
-typedef uint32_t GnssAidingDataCommonMask;
-typedef enum {
- GNSS_AIDING_DATA_COMMON_POSITION_BIT = (1<<0), // position estimate
- GNSS_AIDING_DATA_COMMON_TIME_BIT = (1<<1), // reset all clock values
- GNSS_AIDING_DATA_COMMON_UTC_BIT = (1<<2), // UTC estimate
- GNSS_AIDING_DATA_COMMON_RTI_BIT = (1<<3), // RTI
- GNSS_AIDING_DATA_COMMON_FREQ_BIAS_EST_BIT = (1<<4), // frequency bias estimate
- GNSS_AIDING_DATA_COMMON_CELLDB_BIT = (1<<5), // all celldb info
-} GnssAidingDataCommonBits;
-
-typedef struct {
- GnssAidingDataCommonMask mask; // bitwise OR of GnssAidingDataCommonBits
-} GnssAidingDataCommon;
-
-typedef struct {
- bool deleteAll; // if true, delete all aiding data and ignore other params
- GnssAidingDataSv sv; // SV specific aiding data
- GnssAidingDataCommon common; // common aiding data
-} GnssAidingData;
-
-typedef struct {
- size_t size; // set to sizeof(Location)
- LocationFlagsMask flags; // bitwise OR of LocationFlagsBits to mark which params are valid
- uint64_t timestamp; // UTC timestamp for location fix, milliseconds since January 1, 1970
- double latitude; // in degrees
- double longitude; // in degrees
- double altitude; // in meters above the WGS 84 reference ellipsoid
- float speed; // in meters per second
- float bearing; // in degrees; range [0, 360)
- float accuracy; // in meters
- float verticalAccuracy; // in meters
- float speedAccuracy; // in meters/second
- float bearingAccuracy; // in degrees (0 to 359.999)
- LocationTechnologyMask techMask;
-} Location;
-
-typedef struct {
- size_t size; // set to sizeof(LocationOptions)
- uint32_t minInterval; // in milliseconds
- uint32_t minDistance; // in meters. if minDistance > 0, gnssSvCallback/gnssNmeaCallback/
- // gnssMeasurementsCallback may not be called
- GnssSuplMode mode; // Standalone/MS-Based/MS-Assisted
-} LocationOptions;
-
-typedef struct {
- size_t size;
- BatchingMode batchingMode;
-} BatchingOptions;
-
-typedef struct {
- size_t size;
- BatchingStatus batchingStatus;
-} BatchingStatusInfo;
-
-typedef struct {
- size_t size; // set to sizeof(GeofenceOption)
- GeofenceBreachTypeMask breachTypeMask; // bitwise OR of GeofenceBreachTypeBits
- uint32_t responsiveness; // in milliseconds
- uint32_t dwellTime; // in seconds
-} GeofenceOption;
-
-typedef struct {
- size_t size; // set to sizeof(GeofenceInfo)
- double latitude; // in degrees
- double longitude; // in degrees
- double radius; // in meters
-} GeofenceInfo;
-
-typedef struct {
- size_t size; // set to sizeof(GeofenceBreachNotification)
- size_t count; // number of ids in array
- uint32_t* ids; // array of ids that have breached
- Location location; // location associated with breach
- GeofenceBreachType type; // type of breach
- uint64_t timestamp; // timestamp of breach
-} GeofenceBreachNotification;
-
-typedef struct {
- size_t size; // set to sizeof(GeofenceBreachNotification)
- GeofenceStatusAvailable available; // GEOFENCE_STATUS_AVAILABILE_NO/_YES
- LocationTechnologyType techType; // GNSS
-} GeofenceStatusNotification;
-
-typedef struct {
- size_t size; // set to sizeof(GnssLocationInfo)
- GnssLocationInfoFlagMask flags; // bitwise OR of GnssLocationInfoBits for param validity
- float altitudeMeanSeaLevel; // altitude wrt mean sea level
- float pdop; // position dilusion of precision
- float hdop; // horizontal dilusion of precision
- float vdop; // vertical dilusion of precision
- float magneticDeviation; // magnetic deviation
- LocationReliability horReliability; // horizontal reliability
- LocationReliability verReliability; // vertical reliability
- float horUncEllipseSemiMajor; // horizontal elliptical accuracy semi-major axis
- float horUncEllipseSemiMinor; // horizontal elliptical accuracy semi-minor axis
- float horUncEllipseOrientAzimuth; // horizontal elliptical accuracy azimuth
-} GnssLocationInfoNotification;
-
-typedef struct {
- size_t size; // set to sizeof(GnssNiNotification)
- GnssNiType type; // type of NI (Voice, SUPL, Control Plane)
- GnssNiOptionsMask options; // bitwise OR of GnssNiOptionsBits
- uint32_t timeout; // time (seconds) to wait for user input
- GnssNiResponse timeoutResponse; // the response that should be sent when timeout expires
- char requestor[GNSS_NI_REQUESTOR_MAX]; // the requestor that is making the request
- GnssNiEncodingType requestorEncoding; // the encoding type for requestor
- char message[GNSS_NI_MESSAGE_ID_MAX]; // the message to show user
- GnssNiEncodingType messageEncoding; // the encoding type for message
- char extras[GNSS_NI_MESSAGE_ID_MAX];
-} GnssNiNotification;
-
-typedef struct {
- size_t size; // set to sizeof(GnssSv)
- uint16_t svId; // Unique Identifier
- GnssSvType type; // type of SV (GPS, SBAS, GLONASS, QZSS, BEIDOU, GALILEO)
- float cN0Dbhz; // signal strength
- float elevation; // elevation of SV (in degrees)
- float azimuth; // azimuth of SV (in degrees)
- GnssSvOptionsMask gnssSvOptionsMask; // Bitwise OR of GnssSvOptionsBits
-} GnssSv;
-
-typedef struct {
- size_t size; // set to sizeof(GnssConfigSetAssistanceServer)
- GnssAssistanceType type; // SUPL or C2K
- const char* hostName; // null terminated string
- uint32_t port; // port of server
-} GnssConfigSetAssistanceServer;
-
-typedef struct {
- size_t size; // set to sizeof(GnssMeasurementsData)
- GnssMeasurementsDataFlagsMask flags; // bitwise OR of GnssMeasurementsDataFlagsBits
- int16_t svId;
- GnssSvType svType;
- double timeOffsetNs;
- GnssMeasurementsStateMask stateMask; // bitwise OR of GnssMeasurementsStateBits
- int64_t receivedSvTimeNs;
- int64_t receivedSvTimeUncertaintyNs;
- double carrierToNoiseDbHz;
- double pseudorangeRateMps;
- double pseudorangeRateUncertaintyMps;
- GnssMeasurementsAdrStateMask adrStateMask; // bitwise OR of GnssMeasurementsAdrStateBits
- double adrMeters;
- double adrUncertaintyMeters;
- float carrierFrequencyHz;
- int64_t carrierCycles;
- double carrierPhase;
- double carrierPhaseUncertainty;
- GnssMeasurementsMultipathIndicator multipathIndicator;
- double signalToNoiseRatioDb;
- double agcLevelDb;
-} GnssMeasurementsData;
-
-typedef struct {
- size_t size; // set to sizeof(GnssMeasurementsClock)
- GnssMeasurementsClockFlagsMask flags; // bitwise OR of GnssMeasurementsClockFlagsBits
- int16_t leapSecond;
- int64_t timeNs;
- double timeUncertaintyNs;
- int64_t fullBiasNs;
- double biasNs;
- double biasUncertaintyNs;
- double driftNsps;
- double driftUncertaintyNsps;
- uint32_t hwClockDiscontinuityCount;
-} GnssMeasurementsClock;
-
-typedef struct {
- size_t size; // set to sizeof(GnssSvNotification)
- size_t count; // number of SVs in the GnssSv array
- GnssSv gnssSvs[GNSS_SV_MAX]; // information on a number of SVs
-} GnssSvNotification;
-
-typedef struct {
- size_t size; // set to sizeof(GnssNmeaNotification)
- uint64_t timestamp; // timestamp
- const char* nmea; // nmea text
- size_t length; // length of the nmea text
-} GnssNmeaNotification;
-
-typedef struct {
- size_t size; // set to sizeof(GnssMeasurementsNotification)
- size_t count; // number of items in GnssMeasurements array
- GnssMeasurementsData measurements[GNSS_MEASUREMENTS_MAX];
- GnssMeasurementsClock clock; // clock
-} GnssMeasurementsNotification;
-
-typedef struct {
- size_t size; // set to sizeof(GnssConfig)
- GnssConfigFlagsMask flags; // bitwise OR of GnssConfigFlagsBits to mark which params are valid
- GnssConfigGpsLock gpsLock;
- GnssConfigSuplVersion suplVersion;
- GnssConfigSetAssistanceServer assistanceServer;
- GnssConfigLppProfile lppProfile;
- GnssConfigLppeControlPlaneMask lppeControlPlaneMask;
- GnssConfigLppeUserPlaneMask lppeUserPlaneMask;
- GnssConfigAGlonassPositionProtocolMask aGlonassPositionProtocolMask;
- GnssConfigEmergencyPdnForEmergencySupl emergencyPdnForEmergencySupl;
- GnssConfigSuplEmergencyServices suplEmergencyServices;
- GnssConfigSuplModeMask suplModeMask; //bitwise OR of GnssConfigSuplModeBits
-} GnssConfig;
-
-typedef struct {
- size_t size; // set to sizeof
- bool mValid;
- Location mLocation;
- double verticalAccuracyMeters;
- double speedAccuracyMetersPerSecond;
- double bearingAccuracyDegrees;
- timespec mUtcReported;
-} GnssDebugLocation;
-
-typedef struct {
- size_t size; // set to sizeof
- bool mValid;
- int64_t timeEstimate;
- float timeUncertaintyNs;
- float frequencyUncertaintyNsPerSec;
-} GnssDebugTime;
-
-typedef struct {
- size_t size; // set to sizeof
- uint32_t svid;
- GnssSvType constellation;
- GnssEphemerisType mEphemerisType;
- GnssEphemerisSource mEphemerisSource;
- GnssEphemerisHealth mEphemerisHealth;
- float ephemerisAgeSeconds;
- bool serverPredictionIsAvailable;
- float serverPredictionAgeSeconds;
-} GnssDebugSatelliteInfo;
-
-typedef struct {
- size_t size; // set to sizeof
- GnssDebugLocation mLocation;
- GnssDebugTime mTime;
- std::vector<GnssDebugSatelliteInfo> mSatelliteInfo;
-} GnssDebugReport;
-
-/* Provides the capabilities of the system
- capabilities callback is called once soon after createInstance is called */
-typedef std::function<void(
- LocationCapabilitiesMask capabilitiesMask // bitwise OR of LocationCapabilitiesBits
-)> capabilitiesCallback;
-
-/* Used by tracking, batching, and miscellanous APIs
- responseCallback is called for every Tracking, Batching API, and Miscellanous API */
-typedef std::function<void(
- LocationError err, // if not SUCCESS, then id is not valid
- uint32_t id // id to be associated to the request
-)> responseCallback;
-
-/* Used by APIs that gets more than one LocationError in it's response
- collectiveResponseCallback is called for every geofence API call.
- ids array and LocationError array are only valid until collectiveResponseCallback returns. */
-typedef std::function<void(
- size_t count, // number of locations in arrays
- LocationError* errs, // array of LocationError associated to the request
- uint32_t* ids // array of ids to be associated to the request
-)> collectiveResponseCallback;
-
-/* Used for startTracking API, optional can be NULL
- trackingCallback is called when delivering a location in a tracking session
- broadcasted to all clients, no matter if a session has started by client */
-typedef std::function<void(
- Location location
-)> trackingCallback;
-
-/* Used for startBatching API, optional can be NULL
- batchingCallback is called when delivering locations in a batching session.
- broadcasted to all clients, no matter if a session has started by client */
-typedef std::function<void(
- size_t count, // number of locations in array
- Location* location, // array of locations
- BatchingOptions batchingOptions // Batching options
-)> batchingCallback;
-
-typedef std::function<void(
- BatchingStatusInfo batchingStatus, // batch status
- std::list<uint32_t> & listOfCompletedTrips
-)> batchingStatusCallback;
-
-/* Gives GNSS Location information, optional can be NULL
- gnssLocationInfoCallback is called only during a tracking session
- broadcasted to all clients, no matter if a session has started by client */
-typedef std::function<void(
- GnssLocationInfoNotification gnssLocationInfoNotification
-)> gnssLocationInfoCallback;
-
-/* Used for addGeofences API, optional can be NULL
- geofenceBreachCallback is called when any number of geofences have a state change */
-typedef std::function<void(
- GeofenceBreachNotification geofenceBreachNotification
-)> geofenceBreachCallback;
-
-/* Used for addGeofences API, optional can be NULL
- geofenceStatusCallback is called when any number of geofences have a status change */
-typedef std::function<void(
- GeofenceStatusNotification geofenceStatusNotification
-)> geofenceStatusCallback;
-
-/* Network Initiated request, optional can be NULL
- This callback should be responded to by calling gnssNiResponse */
-typedef std::function<void(
- uint32_t id, // id that should be used to respond by calling gnssNiResponse
- GnssNiNotification gnssNiNotification
-)> gnssNiCallback;
-
-/* Gives GNSS SV information, optional can be NULL
- gnssSvCallback is called only during a tracking session
- broadcasted to all clients, no matter if a session has started by client */
-typedef std::function<void(
- GnssSvNotification gnssSvNotification
-)> gnssSvCallback;
-
-/* Gives GNSS NMEA data, optional can be NULL
- gnssNmeaCallback is called only during a tracking session
- broadcasted to all clients, no matter if a session has started by client */
-typedef std::function<void(
- GnssNmeaNotification gnssNmeaNotification
-)> gnssNmeaCallback;
-
-/* Gives GNSS Measurements information, optional can be NULL
- gnssMeasurementsCallback is called only during a tracking session
- broadcasted to all clients, no matter if a session has started by client */
-typedef std::function<void(
- GnssMeasurementsNotification gnssMeasurementsNotification
-)> gnssMeasurementsCallback;
-
-typedef struct {
- size_t size; // set to sizeof(LocationCallbacks)
- capabilitiesCallback capabilitiesCb; // mandatory
- responseCallback responseCb; // mandatory
- collectiveResponseCallback collectiveResponseCb; // mandatory
- trackingCallback trackingCb; // optional
- batchingCallback batchingCb; // optional
- geofenceBreachCallback geofenceBreachCb; // optional
- geofenceStatusCallback geofenceStatusCb; // optional
- gnssLocationInfoCallback gnssLocationInfoCb; // optional
- gnssNiCallback gnssNiCb; // optional
- gnssSvCallback gnssSvCb; // optional
- gnssNmeaCallback gnssNmeaCb; // optional
- gnssMeasurementsCallback gnssMeasurementsCb; // optional
- batchingStatusCallback batchingStatusCb; // optional
-} LocationCallbacks;
-
-class LocationAPI
-{
-private:
- LocationAPI();
- ~LocationAPI();
-
-public:
- /* creates an instance to LocationAPI object.
- Will return NULL if mandatory parameters are invalid or if the maximum number
- of instances have been reached */
- static LocationAPI* createInstance(LocationCallbacks&);
-
- /* destroy/cleans up the instance, which should be called when LocationAPI object is
- no longer needed. LocationAPI* returned from createInstance will no longer valid
- after destroy is called */
- void destroy();
-
- /* updates/changes the callbacks that will be called.
- mandatory callbacks must be present for callbacks to be successfully updated
- no return value */
- void updateCallbacks(LocationCallbacks&);
-
- /* ================================== TRACKING ================================== */
-
- /* startTracking starts a tracking session, which returns a session id that will be
- used by the other tracking APIs and also in the responseCallback to match command
- with response. locations are reported on the trackingCallback passed in createInstance
- periodically according to LocationOptions.
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if session was successfully started
- LOCATION_ERROR_ALREADY_STARTED if a startTracking session is already in progress
- LOCATION_ERROR_CALLBACK_MISSING if no trackingCallback was passed in createInstance
- LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameter is invalid */
- uint32_t startTracking(LocationOptions&); // returns session id
-
- /* stopTracking stops a tracking session associated with id parameter.
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */
- void stopTracking(uint32_t id);
-
- /* updateTrackingOptions changes the LocationOptions of a tracking session associated with id
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid
- LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */
- void updateTrackingOptions(uint32_t id, LocationOptions&);
-
- /* ================================== BATCHING ================================== */
-
- /* startBatching starts a batching session, which returns a session id that will be
- used by the other batching APIs and also in the responseCallback to match command
- with response. locations are reported on the batchingCallback passed in createInstance
- periodically according to LocationOptions. A batching session starts tracking on
- the low power processor and delivers them in batches by the batchingCallback when
- the batch is full or when getBatchedLocations is called. This allows for the processor
- that calls this API to sleep when the low power processor can batch locations in the
- backgroup and wake up the processor calling the API only when the batch is full, thus
- saving power
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if session was successful
- LOCATION_ERROR_ALREADY_STARTED if a startBatching session is already in progress
- LOCATION_ERROR_CALLBACK_MISSING if no batchingCallback was passed in createInstance
- LOCATION_ERROR_INVALID_PARAMETER if a parameter is invalid
- LOCATION_ERROR_NOT_SUPPORTED if batching is not supported */
- uint32_t startBatching(LocationOptions&, BatchingOptions&); // returns session id
-
- /* stopBatching stops a batching session associated with id parameter.
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_ID_UNKNOWN if id is not associated with batching session */
- void stopBatching(uint32_t id);
-
- /* updateBatchingOptions changes the LocationOptions of a batching session associated with id
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid
- LOCATION_ERROR_ID_UNKNOWN if id is not associated with a batching session */
- void updateBatchingOptions(uint32_t id, LocationOptions&, BatchingOptions&);
-
- /* getBatchedLocations gets a number of locations that are currently stored/batched
- on the low power processor, delivered by the batchingCallback passed in createInstance.
- Location are then deleted from the batch stored on the low power processor.
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if successful, will be followed by batchingCallback call
- LOCATION_ERROR_CALLBACK_MISSING if no batchingCallback was passed in createInstance
- LOCATION_ERROR_ID_UNKNOWN if id is not associated with a batching session */
- void getBatchedLocations(uint32_t id, size_t count);
-
- /* ================================== GEOFENCE ================================== */
-
- /* addGeofences adds any number of geofences and returns an array of geofence ids that
- will be used by the other geofence APIs and also in the collectiveResponseCallback to
- match command with response. The geofenceBreachCallback will deliver the status of each
- geofence according to the GeofenceOption for each. The geofence id array returned will
- be valid until the collectiveResponseCallback is called and has returned.
- collectiveResponseCallback returns:
- LOCATION_ERROR_SUCCESS if session was successful
- LOCATION_ERROR_CALLBACK_MISSING if no geofenceBreachCallback
- LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid
- LOCATION_ERROR_NOT_SUPPORTED if geofence is not supported */
- uint32_t* addGeofences(size_t count, GeofenceOption*, GeofenceInfo*); // returns id array
-
- /* removeGeofences removes any number of geofences. Caller should delete ids array after
- removeGeofences returneds.
- collectiveResponseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */
- void removeGeofences(size_t count, uint32_t* ids);
-
- /* modifyGeofences modifies any number of geofences. Caller should delete ids array after
- modifyGeofences returns.
- collectiveResponseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session
- LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid */
- void modifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options);
-
- /* pauseGeofences pauses any number of geofences, which is similar to removeGeofences,
- only that they can be resumed at any time. Caller should delete ids array after
- pauseGeofences returns.
- collectiveResponseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */
- void pauseGeofences(size_t count, uint32_t* ids);
-
- /* resumeGeofences resumes any number of geofences that are currently paused. Caller should
- delete ids array after resumeGeofences returns.
- collectiveResponseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_ID_UNKNOWN if id is not associated with a geofence session */
- void resumeGeofences(size_t count, uint32_t* ids);
-
- /* ================================== GNSS ====================================== */
-
- /* gnssNiResponse is called in response to a gnssNiCallback.
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if session was successful
- LOCATION_ERROR_INVALID_PARAMETER if any parameters in GnssNiResponse are invalid
- LOCATION_ERROR_ID_UNKNOWN if id does not match a gnssNiCallback */
- void gnssNiResponse(uint32_t id, GnssNiResponse response);
-};
-
-typedef struct {
- size_t size; // set to sizeof(LocationControlCallbacks)
- responseCallback responseCb; // mandatory
- collectiveResponseCallback collectiveResponseCb; // mandatory
-} LocationControlCallbacks;
-
-class LocationControlAPI
-{
-private:
- LocationControlAPI();
- ~LocationControlAPI();
-
-public:
- /* creates an instance to LocationControlAPI object.
- Will return NULL if mandatory parameters are invalid or if the maximum number
- of instances have been reached. Only once instance allowed */
- static LocationControlAPI* createInstance(LocationControlCallbacks&);
-
- /* destroy/cleans up the instance, which should be called when LocationControlAPI object is
- no longer needed. LocationControlAPI* returned from createInstance will no longer valid
- after destroy is called */
- void destroy();
-
- /* enable will enable specific location technology to be used for calculation locations and
- will effectively start a control session if call is successful, which returns a session id
- that will be returned in responseCallback to match command with response. The session id is
- also needed to call the disable command.
- This effect is global for all clients of LocationAPI
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_ALREADY_STARTED if an enable was already called for this techType
- LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid
- LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */
- uint32_t enable(LocationTechnologyType techType);
-
- /* disable will disable specific location technology to be used for calculation locations and
- effectively ends the control session if call is successful.
- id parameter is the session id that was returned in enable responseCallback for techType.
- The session id is no longer valid after disable's responseCallback returns success.
- This effect is global for all clients of LocationAPI
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_ID_UNKNOWN if id was not returned from responseCallback from enable
- LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */
- void disable(uint32_t id);
-
- /* gnssUpdateConfig updates the gnss specific configuration, which returns a session id array
- with an id for each of the bits set in GnssConfig.flags, order from low bits to high bits.
- The response for each config that is set will be returned in collectiveResponseCallback.
- The session id array returned will be valid until the collectiveResponseCallback is called
- and has returned. This effect is global for all clients of LocationAPI
- collectiveResponseCallback returns:
- LOCATION_ERROR_SUCCESS if session was successful
- LOCATION_ERROR_INVALID_PARAMETER if any other parameters are invalid
- LOCATION_ERROR_GENERAL_FAILURE if failure for any other reason */
- uint32_t* gnssUpdateConfig(GnssConfig config);
-
- /* delete specific gnss aiding data for testing, which returns a session id
- that will be returned in responseCallback to match command with response.
- Only allowed in userdebug builds. This effect is global for all clients of LocationAPI
- responseCallback returns:
- LOCATION_ERROR_SUCCESS if successful
- LOCATION_ERROR_INVALID_PARAMETER if any parameters are invalid
- LOCATION_ERROR_NOT_SUPPORTED if build is not userdebug */
- uint32_t gnssDeleteAidingData(GnssAidingData& data);
-};
-
-#endif /* LOCATION_H */
diff --git a/gps/location/LocationAPIClientBase.cpp b/gps/location/LocationAPIClientBase.cpp
deleted file mode 100644
index 626968c..0000000
--- a/gps/location/LocationAPIClientBase.cpp
+++ /dev/null
@@ -1,914 +0,0 @@
-/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#define LOG_NDDEBUG 0
-#define LOG_TAG "LocSvc_APIClientBase"
-
-#include <loc_pla.h>
-#include <log_util.h>
-#include <inttypes.h>
-#include <loc_cfg.h>
-#include "LocationAPIClientBase.h"
-
-#define GEOFENCE_SESSION_ID 0xFFFFFFFF
-#define CONFIG_SESSION_ID 0xFFFFFFFF
-
-// LocationAPIControlClient
-LocationAPIControlClient::LocationAPIControlClient() :
- mEnabled(false)
-{
- pthread_mutex_init(&mMutex, nullptr);
-
- for (int i = 0; i < CTRL_REQUEST_MAX; i++) {
- mRequestQueues[i].reset(0);
- }
-
- memset(&mConfig, 0, sizeof(GnssConfig));
-
- LocationControlCallbacks locationControlCallbacks;
- locationControlCallbacks.size = sizeof(LocationControlCallbacks);
-
- locationControlCallbacks.responseCb =
- [this](LocationError error, uint32_t id) {
- onCtrlResponseCb(error, id);
- };
- locationControlCallbacks.collectiveResponseCb =
- [this](size_t count, LocationError* errors, uint32_t* ids) {
- onCtrlCollectiveResponseCb(count, errors, ids);
- };
-
- mLocationControlAPI = LocationControlAPI::createInstance(locationControlCallbacks);
-}
-
-LocationAPIControlClient::~LocationAPIControlClient()
-{
- pthread_mutex_lock(&mMutex);
-
- if (mLocationControlAPI) {
- mLocationControlAPI->destroy();
- mLocationControlAPI = nullptr;
- }
-
- for (int i = 0; i < CTRL_REQUEST_MAX; i++) {
- mRequestQueues[i].reset(0);
- }
-
- pthread_mutex_unlock(&mMutex);
-
- pthread_mutex_destroy(&mMutex);
-}
-
-uint32_t LocationAPIControlClient::locAPIGnssDeleteAidingData(GnssAidingData& data)
-{
- uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
- pthread_mutex_lock(&mMutex);
- if (mLocationControlAPI) {
- uint32_t session = mLocationControlAPI->gnssDeleteAidingData(data);
- LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
- mRequestQueues[CTRL_REQUEST_DELETEAIDINGDATA].reset(session);
- mRequestQueues[CTRL_REQUEST_DELETEAIDINGDATA].push(new GnssDeleteAidingDataRequest(*this));
-
- retVal = LOCATION_ERROR_SUCCESS;
- }
- pthread_mutex_unlock(&mMutex);
-
- return retVal;
-}
-
-uint32_t LocationAPIControlClient::locAPIEnable(LocationTechnologyType techType)
-{
- uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
- pthread_mutex_lock(&mMutex);
- if (mEnabled) {
- // just return success if already enabled
- retVal = LOCATION_ERROR_SUCCESS;
- } else if (mLocationControlAPI) {
- uint32_t session = mLocationControlAPI->enable(techType);
- LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
- mRequestQueues[CTRL_REQUEST_CONTROL].reset(session);
- mRequestQueues[CTRL_REQUEST_CONTROL].push(new EnableRequest(*this));
- retVal = LOCATION_ERROR_SUCCESS;
- mEnabled = true;
- } else {
- LOC_LOGE("%s:%d] failed.", __FUNCTION__, __LINE__);
- }
- pthread_mutex_unlock(&mMutex);
-
- return retVal;
-}
-
-void LocationAPIControlClient::locAPIDisable()
-{
- pthread_mutex_lock(&mMutex);
- if (mEnabled && mLocationControlAPI) {
- uint32_t session = 0;
- session = mRequestQueues[CTRL_REQUEST_CONTROL].getSession();
- if (session > 0) {
- mRequestQueues[CTRL_REQUEST_CONTROL].push(new DisableRequest(*this));
- mLocationControlAPI->disable(session);
- mEnabled = false;
- } else {
- LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, session);
- }
- }
- pthread_mutex_unlock(&mMutex);
-}
-
-uint32_t LocationAPIControlClient::locAPIGnssUpdateConfig(GnssConfig config)
-{
- uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
- if (memcmp(&mConfig, &config, sizeof(GnssConfig)) == 0) {
- LOC_LOGV("%s:%d] GnssConfig is identical to previous call", __FUNCTION__, __LINE__);
- retVal = LOCATION_ERROR_SUCCESS;
- return retVal;
- }
-
- pthread_mutex_lock(&mMutex);
- if (mLocationControlAPI) {
-
- memcpy(&mConfig, &config, sizeof(GnssConfig));
-
- uint32_t* idArray = mLocationControlAPI->gnssUpdateConfig(config);
- LOC_LOGV("%s:%d] gnssUpdateConfig return array: %p", __FUNCTION__, __LINE__, idArray);
- if (idArray != nullptr) {
- if (mRequestQueues[CTRL_REQUEST_CONFIG].getSession() != CONFIG_SESSION_ID) {
- mRequestQueues[CTRL_REQUEST_CONFIG].reset(CONFIG_SESSION_ID);
- }
- mRequestQueues[CTRL_REQUEST_CONFIG].push(new GnssUpdateConfigRequest(*this));
- retVal = LOCATION_ERROR_SUCCESS;
- }
- }
- pthread_mutex_unlock(&mMutex);
- return retVal;
-}
-
-void LocationAPIControlClient::onCtrlResponseCb(LocationError error, uint32_t id)
-{
- if (error != LOCATION_ERROR_SUCCESS) {
- LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id);
- } else {
- LOC_LOGV("%s:%d] SUCCESS: %d id: %d", __FUNCTION__, __LINE__, error, id);
- }
- LocationAPIRequest* request = getRequestBySession(id);
- if (request) {
- request->onResponse(error, id);
- delete request;
- }
-}
-
-void LocationAPIControlClient::onCtrlCollectiveResponseCb(
- size_t count, LocationError* errors, uint32_t* ids)
-{
- for (size_t i = 0; i < count; i++) {
- if (errors[i] != LOCATION_ERROR_SUCCESS) {
- LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
- } else {
- LOC_LOGV("%s:%d] SUCCESS: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
- }
- }
- LocationAPIRequest* request = nullptr;
- pthread_mutex_lock(&mMutex);
- if (mRequestQueues[CTRL_REQUEST_CONFIG].getSession() == CONFIG_SESSION_ID) {
- request = mRequestQueues[CTRL_REQUEST_CONFIG].pop();
- }
- pthread_mutex_unlock(&mMutex);
- if (request) {
- request->onCollectiveResponse(count, errors, ids);
- delete request;
- }
-}
-
-LocationAPIRequest* LocationAPIControlClient::getRequestBySession(uint32_t session)
-{
- pthread_mutex_lock(&mMutex);
- LocationAPIRequest* request = nullptr;
- for (int i = 0; i < CTRL_REQUEST_MAX; i++) {
- if (i != CTRL_REQUEST_CONFIG &&
- mRequestQueues[i].getSession() == session) {
- request = mRequestQueues[i].pop();
- break;
- }
- }
- pthread_mutex_unlock(&mMutex);
- return request;
-}
-
-// LocationAPIClientBase
-LocationAPIClientBase::LocationAPIClientBase() :
- mGeofenceBreachCallback(nullptr),
- mBatchingStatusCallback(nullptr),
- mLocationAPI(nullptr),
- mBatchSize(-1),
- mTracking(false)
-{
-
- // use recursive mutex, in case callback come from the same thread
- pthread_mutexattr_t attr;
- pthread_mutexattr_init(&attr);
- pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
- pthread_mutex_init(&mMutex, &attr);
-
- for (int i = 0; i < REQUEST_MAX; i++) {
- mRequestQueues[i].reset(0);
- }
-}
-
-void LocationAPIClientBase::locAPISetCallbacks(LocationCallbacks& locationCallbacks)
-{
- pthread_mutex_lock(&mMutex);
-
- if (locationCallbacks.geofenceBreachCb != nullptr) {
- mGeofenceBreachCallback = locationCallbacks.geofenceBreachCb;
- locationCallbacks.geofenceBreachCb =
- [this](GeofenceBreachNotification geofenceBreachNotification) {
- beforeGeofenceBreachCb(geofenceBreachNotification);
- };
- }
-
- locationCallbacks.capabilitiesCb =
- [this](LocationCapabilitiesMask capabilitiesMask) {
- onCapabilitiesCb(capabilitiesMask);
- };
- locationCallbacks.responseCb = [this](LocationError error, uint32_t id) {
- onResponseCb(error, id);
- };
- locationCallbacks.collectiveResponseCb =
- [this](size_t count, LocationError* errors, uint32_t* ids) {
- onCollectiveResponseCb(count, errors, ids);
- };
-
- if (locationCallbacks.batchingStatusCb != nullptr) {
- mBatchingStatusCallback = locationCallbacks.batchingStatusCb;
- locationCallbacks.batchingStatusCb =
- [this](BatchingStatusInfo batchStatus, std::list<uint32_t> & tripCompletedList) {
- beforeBatchingStatusCb(batchStatus, tripCompletedList);
- };
- }
-
- if (mLocationAPI == nullptr ) {
- mLocationAPI = LocationAPI::createInstance(locationCallbacks);
- } else {
- mLocationAPI->updateCallbacks(locationCallbacks);
- }
-
- pthread_mutex_unlock(&mMutex);
-}
-
-LocationAPIClientBase::~LocationAPIClientBase()
-{
- pthread_mutex_lock(&mMutex);
-
- mGeofenceBreachCallback = nullptr;
-
- if (mLocationAPI) {
- mLocationAPI->destroy();
- mLocationAPI = nullptr;
- }
-
- for (int i = 0; i < REQUEST_MAX; i++) {
- mRequestQueues[i].reset(0);
- }
-
- pthread_mutex_unlock(&mMutex);
-
- pthread_mutex_destroy(&mMutex);
-}
-
-uint32_t LocationAPIClientBase::locAPIStartTracking(LocationOptions& options)
-{
- uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- if (mTracking) {
- LOC_LOGW("%s:%d] Existing tracking session present", __FUNCTION__, __LINE__);
- } else {
- uint32_t session = mLocationAPI->startTracking(options);
- LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
- // onResponseCb might be called from other thread immediately after
- // startTracking returns, so we are not going to unlock mutex
- // until StartTrackingRequest is pushed into mRequestQueues[REQUEST_TRACKING]
- mRequestQueues[REQUEST_TRACKING].reset(session);
- mRequestQueues[REQUEST_TRACKING].push(new StartTrackingRequest(*this));
- mTracking = true;
- }
-
- retVal = LOCATION_ERROR_SUCCESS;
- }
- pthread_mutex_unlock(&mMutex);
-
- return retVal;
-}
-
-void LocationAPIClientBase::locAPIStopTracking()
-{
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- uint32_t session = 0;
- session = mRequestQueues[REQUEST_TRACKING].getSession();
- if (session > 0) {
- mRequestQueues[REQUEST_TRACKING].push(new StopTrackingRequest(*this));
- mLocationAPI->stopTracking(session);
- mTracking = false;
- } else {
- LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, session);
- }
- }
- pthread_mutex_unlock(&mMutex);
-}
-
-void LocationAPIClientBase::locAPIUpdateTrackingOptions(LocationOptions& options)
-{
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- uint32_t session = 0;
- session = mRequestQueues[REQUEST_TRACKING].getSession();
- if (session > 0) {
- mRequestQueues[REQUEST_TRACKING].push(new UpdateTrackingOptionsRequest(*this));
- mLocationAPI->updateTrackingOptions(session, options);
- } else {
- LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, session);
- }
- }
- pthread_mutex_unlock(&mMutex);
-}
-
-int32_t LocationAPIClientBase::locAPIGetBatchSize()
-{
- if (mBatchSize == -1) {
- const loc_param_s_type flp_conf_param_table[] =
- {
- {"BATCH_SIZE", &mBatchSize, nullptr, 'n'},
- };
- UTIL_READ_CONF(LOC_PATH_FLP_CONF, flp_conf_param_table);
- if (mBatchSize < 0) {
- // set mBatchSize to 0 if we got an illegal value from config file
- mBatchSize = 0;
- }
- }
- return mBatchSize;
-}
-
-
-uint32_t LocationAPIClientBase::locAPIStartSession(uint32_t id, uint32_t sessionMode,
- LocationOptions& locationOptions)
-{
- uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
-
- if (mSessionBiDict.hasId(id)) {
- LOC_LOGE("%s:%d] session %d has already started.", __FUNCTION__, __LINE__, id);
- retVal = LOCATION_ERROR_ALREADY_STARTED;
- } else {
- uint32_t trackingSession = 0;
- uint32_t batchingSession = 0;
-
- if (sessionMode == SESSION_MODE_ON_FIX) {
- trackingSession = mLocationAPI->startTracking(locationOptions);
- LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, trackingSession);
- mRequestQueues[REQUEST_SESSION].push(new StartTrackingRequest(*this));
- } else {
- // Fill in the batch mode
- BatchingOptions batchOptions = {};
- batchOptions.size = sizeof(BatchingOptions);
- switch (sessionMode) {
- case SESSION_MODE_ON_FULL:
- batchOptions.batchingMode = BATCHING_MODE_ROUTINE;
- break;
- case SESSION_MODE_ON_TRIP_COMPLETED:
- batchOptions.batchingMode = BATCHING_MODE_TRIP;
- break;
- default:
- batchOptions.batchingMode = BATCHING_MODE_NO_AUTO_REPORT;
- break;
- }
-
- batchingSession = mLocationAPI->startBatching(locationOptions, batchOptions);
- LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, batchingSession);
- mRequestQueues[REQUEST_SESSION].setSession(batchingSession);
- mRequestQueues[REQUEST_SESSION].push(new StartBatchingRequest(*this));
- }
-
- uint32_t session = ((sessionMode != SESSION_MODE_ON_FIX) ?
- batchingSession : trackingSession);
-
- SessionEntity entity;
- entity.id = id;
- entity.trackingSession = trackingSession;
- entity.batchingSession = batchingSession;
- entity.sessionMode = sessionMode;
- mSessionBiDict.set(id, session, entity);
-
- retVal = LOCATION_ERROR_SUCCESS;
- }
-
- }
- pthread_mutex_unlock(&mMutex);
-
- return retVal;
-}
-
-uint32_t LocationAPIClientBase::locAPIStopSession(uint32_t id)
-{
- uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
-
- if (mSessionBiDict.hasId(id)) {
- SessionEntity entity = mSessionBiDict.getExtById(id);
-
- uint32_t trackingSession = entity.trackingSession;
- uint32_t batchingSession = entity.batchingSession;
- uint32_t sMode = entity.sessionMode;
-
- if (sMode == SESSION_MODE_ON_FIX) {
- mRequestQueues[REQUEST_SESSION].push(new StopTrackingRequest(*this));
- mLocationAPI->stopTracking(trackingSession);
- } else {
- mRequestQueues[REQUEST_SESSION].push(new StopBatchingRequest(*this));
- mLocationAPI->stopBatching(batchingSession);
- }
-
- retVal = LOCATION_ERROR_SUCCESS;
- } else {
- retVal = LOCATION_ERROR_ID_UNKNOWN;
- LOC_LOGE("%s:%d] session %d is not exist.", __FUNCTION__, __LINE__, id);
- }
-
- }
- pthread_mutex_unlock(&mMutex);
- return retVal;
-}
-
-uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(uint32_t id, uint32_t sessionMode,
- LocationOptions& options)
-{
- uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
-
- if (mSessionBiDict.hasId(id)) {
- SessionEntity entity = mSessionBiDict.getExtById(id);
-
- uint32_t trackingSession = entity.trackingSession;
- uint32_t batchingSession = entity.batchingSession;
- uint32_t sMode = entity.sessionMode;
-
- if (sessionMode == SESSION_MODE_ON_FIX) {
- // we only add an UpdateTrackingOptionsRequest to mRequestQueues[REQUEST_SESSION],
- // even if this update request will stop batching and then start tracking.
- mRequestQueues[REQUEST_SESSION].push(new UpdateTrackingOptionsRequest(*this));
- if (sMode == SESSION_MODE_ON_FIX) {
- mLocationAPI->updateTrackingOptions(trackingSession, options);
- } else {
- // stop batching
- // batchingSession will be removed from mSessionBiDict soon,
- // so we don't need to add a new request to mRequestQueues[REQUEST_SESSION].
- mLocationAPI->stopBatching(batchingSession);
- batchingSession = 0;
- mRequestQueues[REQUEST_SESSION].setSession(batchingSession);
-
- // start tracking
- trackingSession = mLocationAPI->startTracking(options);
- LOC_LOGI("%s:%d] start new session: %d",
- __FUNCTION__, __LINE__, trackingSession);
- }
- } else {
- // we only add an UpdateBatchingOptionsRequest to mRequestQueues[REQUEST_SESSION],
- // even if this update request will stop tracking and then start batching.
- mRequestQueues[REQUEST_SESSION].push(new UpdateBatchingOptionsRequest(*this));
- BatchingOptions batchOptions = {};
- batchOptions.size = sizeof(BatchingOptions);
- switch (sessionMode) {
- case SESSION_MODE_ON_FULL:
- batchOptions.batchingMode = BATCHING_MODE_ROUTINE;
- break;
- case SESSION_MODE_ON_TRIP_COMPLETED:
- batchOptions.batchingMode = BATCHING_MODE_TRIP;
- break;
- default:
- batchOptions.batchingMode = BATCHING_MODE_NO_AUTO_REPORT;
- break;
- }
-
- if (sMode == SESSION_MODE_ON_FIX) {
- // stop tracking
- // trackingSession will be removed from mSessionBiDict soon,
- // so we don't need to add a new request to mRequestQueues[REQUEST_SESSION].
- mLocationAPI->stopTracking(trackingSession);
- trackingSession = 0;
-
- // start batching
- batchingSession = mLocationAPI->startBatching(options, batchOptions);
- LOC_LOGI("%s:%d] start new session: %d",
- __FUNCTION__, __LINE__, batchingSession);
- mRequestQueues[REQUEST_SESSION].setSession(batchingSession);
- } else {
- mLocationAPI->updateBatchingOptions(batchingSession, options, batchOptions);
- }
-
- }
-
- uint32_t session = ((sessionMode != SESSION_MODE_ON_FIX) ?
- batchingSession : trackingSession);
-
- entity.trackingSession = trackingSession;
- entity.batchingSession = batchingSession;
- entity.sessionMode = sessionMode;
- // remove the old values from mSessionBiDict before we add a new one.
- mSessionBiDict.rmById(id);
- mSessionBiDict.set(id, session, entity);
-
- retVal = LOCATION_ERROR_SUCCESS;
- } else {
- retVal = LOCATION_ERROR_ID_UNKNOWN;
- LOC_LOGE("%s:%d] session %d is not exist.", __FUNCTION__, __LINE__, id);
- }
- }
- pthread_mutex_unlock(&mMutex);
- return retVal;
-}
-
-uint32_t LocationAPIClientBase::locAPIGetBatchedLocations(uint32_t id, size_t count)
-{
- uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- if (mSessionBiDict.hasId(id)) {
- SessionEntity entity = mSessionBiDict.getExtById(id);
- if (entity.sessionMode != SESSION_MODE_ON_FIX) {
- uint32_t batchingSession = entity.batchingSession;
- mRequestQueues[REQUEST_SESSION].push(new GetBatchedLocationsRequest(*this));
- mLocationAPI->getBatchedLocations(batchingSession, count);
- retVal = LOCATION_ERROR_SUCCESS;
- } else {
- LOC_LOGE("%s:%d] Unsupported for session id: %d, mode is SESSION_MODE_ON_FIX",
- __FUNCTION__, __LINE__, id);
- retVal = LOCATION_ERROR_NOT_SUPPORTED;
- }
- } else {
- retVal = LOCATION_ERROR_ID_UNKNOWN;
- LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, id);
- }
- }
- pthread_mutex_unlock(&mMutex);
-
- return retVal;
-}
-
-uint32_t LocationAPIClientBase::locAPIAddGeofences(
- size_t count, uint32_t* ids, GeofenceOption* options, GeofenceInfo* data)
-{
- uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- if (mRequestQueues[REQUEST_GEOFENCE].getSession() != GEOFENCE_SESSION_ID) {
- mRequestQueues[REQUEST_GEOFENCE].reset(GEOFENCE_SESSION_ID);
- }
- uint32_t* sessions = mLocationAPI->addGeofences(count, options, data);
- if (sessions) {
- LOC_LOGI("%s:%d] start new sessions: %p", __FUNCTION__, __LINE__, sessions);
- mRequestQueues[REQUEST_GEOFENCE].push(new AddGeofencesRequest(*this));
-
- for (size_t i = 0; i < count; i++) {
- mGeofenceBiDict.set(ids[i], sessions[i], options[i].breachTypeMask);
- }
- retVal = LOCATION_ERROR_SUCCESS;
- }
- }
- pthread_mutex_unlock(&mMutex);
-
- return retVal;
-}
-
-void LocationAPIClientBase::locAPIRemoveGeofences(size_t count, uint32_t* ids)
-{
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
- if (sessions == NULL) {
- LOC_LOGE("%s:%d] Failed to allocate %zu bytes !",
- __FUNCTION__, __LINE__, sizeof(uint32_t) * count);
- pthread_mutex_unlock(&mMutex);
- return;
- }
-
- if (mRequestQueues[REQUEST_GEOFENCE].getSession() == GEOFENCE_SESSION_ID) {
- BiDict<GeofenceBreachTypeMask>* removedGeofenceBiDict =
- new BiDict<GeofenceBreachTypeMask>();
- size_t j = 0;
- for (size_t i = 0; i < count; i++) {
- sessions[j] = mGeofenceBiDict.getSession(ids[i]);
- if (sessions[j] > 0) {
- GeofenceBreachTypeMask type = mGeofenceBiDict.getExtBySession(sessions[j]);
- mGeofenceBiDict.rmBySession(sessions[j]);
- removedGeofenceBiDict->set(ids[i], sessions[j], type);
- j++;
- }
- }
- if (j > 0) {
- mRequestQueues[REQUEST_GEOFENCE].push(new RemoveGeofencesRequest(*this,
- removedGeofenceBiDict));
- mLocationAPI->removeGeofences(j, sessions);
- } else {
- delete(removedGeofenceBiDict);
- }
- } else {
- LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__,
- mRequestQueues[REQUEST_GEOFENCE].getSession());
- }
-
- free(sessions);
- }
- pthread_mutex_unlock(&mMutex);
-}
-
-void LocationAPIClientBase::locAPIModifyGeofences(
- size_t count, uint32_t* ids, GeofenceOption* options)
-{
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
- if (sessions == NULL) {
- LOC_LOGE("%s:%d] Failed to allocate %zu bytes !",
- __FUNCTION__, __LINE__, sizeof(uint32_t) * count);
- pthread_mutex_unlock(&mMutex);
- return;
- }
-
- if (mRequestQueues[REQUEST_GEOFENCE].getSession() == GEOFENCE_SESSION_ID) {
- size_t j = 0;
- for (size_t i = 0; i < count; i++) {
- sessions[j] = mGeofenceBiDict.getSession(ids[i]);
- if (sessions[j] > 0) {
- mGeofenceBiDict.set(ids[i], sessions[j], options[i].breachTypeMask);
- j++;
- }
- }
- if (j > 0) {
- mRequestQueues[REQUEST_GEOFENCE].push(new ModifyGeofencesRequest(*this));
- mLocationAPI->modifyGeofences(j, sessions, options);
- }
- } else {
- LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__,
- mRequestQueues[REQUEST_GEOFENCE].getSession());
- }
-
- free(sessions);
- }
- pthread_mutex_unlock(&mMutex);
-}
-
-void LocationAPIClientBase::locAPIPauseGeofences(size_t count, uint32_t* ids)
-{
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
- if (sessions == NULL) {
- LOC_LOGE("%s:%d] Failed to allocate %zu bytes !",
- __FUNCTION__, __LINE__, sizeof(uint32_t) * count);
- pthread_mutex_unlock(&mMutex);
- return;
- }
-
- if (mRequestQueues[REQUEST_GEOFENCE].getSession() == GEOFENCE_SESSION_ID) {
- size_t j = 0;
- for (size_t i = 0; i < count; i++) {
- sessions[j] = mGeofenceBiDict.getSession(ids[i]);
- if (sessions[j] > 0) {
- j++;
- }
- }
- if (j > 0) {
- mRequestQueues[REQUEST_GEOFENCE].push(new PauseGeofencesRequest(*this));
- mLocationAPI->pauseGeofences(j, sessions);
- }
- } else {
- LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__,
- mRequestQueues[REQUEST_GEOFENCE].getSession());
- }
-
- free(sessions);
- }
- pthread_mutex_unlock(&mMutex);
-}
-
-void LocationAPIClientBase::locAPIResumeGeofences(
- size_t count, uint32_t* ids, GeofenceBreachTypeMask* mask)
-{
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- uint32_t* sessions = (uint32_t*)malloc(sizeof(uint32_t) * count);
- if (sessions == NULL) {
- LOC_LOGE("%s:%d] Failed to allocate %zu bytes !",
- __FUNCTION__, __LINE__, sizeof(uint32_t) * count);
- pthread_mutex_unlock(&mMutex);
- return;
- }
-
- if (mRequestQueues[REQUEST_GEOFENCE].getSession() == GEOFENCE_SESSION_ID) {
- size_t j = 0;
- for (size_t i = 0; i < count; i++) {
- sessions[j] = mGeofenceBiDict.getSession(ids[i]);
- if (sessions[j] > 0) {
- if (mask) {
- mGeofenceBiDict.set(ids[i], sessions[j], mask[i]);
- }
- j++;
- }
- }
- if (j > 0) {
- mRequestQueues[REQUEST_GEOFENCE].push(new ResumeGeofencesRequest(*this));
- mLocationAPI->resumeGeofences(j, sessions);
- }
- } else {
- LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__,
- mRequestQueues[REQUEST_GEOFENCE].getSession());
- }
-
- free(sessions);
- }
- pthread_mutex_unlock(&mMutex);
-}
-
-void LocationAPIClientBase::locAPIRemoveAllGeofences()
-{
- std::vector<uint32_t> sessionsVec = mGeofenceBiDict.getAllSessions();
- locAPIRemoveGeofences(sessionsVec.size(), &sessionsVec[0]);
-}
-
-void LocationAPIClientBase::locAPIGnssNiResponse(uint32_t id, GnssNiResponse response)
-{
- pthread_mutex_lock(&mMutex);
- if (mLocationAPI) {
- uint32_t session = id;
- mLocationAPI->gnssNiResponse(id, response);
- LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, session);
- mRequestQueues[REQUEST_NIRESPONSE].reset(session);
- mRequestQueues[REQUEST_NIRESPONSE].push(new GnssNiResponseRequest(*this));
- }
- pthread_mutex_unlock(&mMutex);
-}
-
-void LocationAPIClientBase::beforeGeofenceBreachCb(
- GeofenceBreachNotification geofenceBreachNotification)
-{
- uint32_t* ids = (uint32_t*)malloc(sizeof(uint32_t) * geofenceBreachNotification.count);
- uint32_t* backup = geofenceBreachNotification.ids;
- size_t n = geofenceBreachNotification.count;
- geofenceBreachCallback genfenceCallback = nullptr;
-
- if (ids == NULL) {
- LOC_LOGE("%s:%d] Failed to alloc %zu bytes",
- __FUNCTION__, __LINE__,
- sizeof(uint32_t) * geofenceBreachNotification.count);
- return;
- }
-
- pthread_mutex_lock(&mMutex);
- if (mGeofenceBreachCallback != nullptr) {
- size_t count = 0;
- for (size_t i = 0; i < n; i++) {
- uint32_t id = mGeofenceBiDict.getId(geofenceBreachNotification.ids[i]);
- GeofenceBreachTypeMask type =
- mGeofenceBiDict.getExtBySession(geofenceBreachNotification.ids[i]);
- // if type == 0, we will not head into the fllowing block anyway.
- // so we don't need to check id and type
- if ((geofenceBreachNotification.type == GEOFENCE_BREACH_ENTER &&
- (type & GEOFENCE_BREACH_ENTER_BIT)) ||
- (geofenceBreachNotification.type == GEOFENCE_BREACH_EXIT &&
- (type & GEOFENCE_BREACH_EXIT_BIT))
- ) {
- ids[count] = id;
- count++;
- }
- }
- geofenceBreachNotification.count = count;
- geofenceBreachNotification.ids = ids;
-
- genfenceCallback = mGeofenceBreachCallback;
- }
- pthread_mutex_unlock(&mMutex);
-
- if (genfenceCallback != nullptr) {
- genfenceCallback(geofenceBreachNotification);
- }
-
- // restore ids
- geofenceBreachNotification.ids = backup;
- geofenceBreachNotification.count = n;
- free(ids);
-}
-
-void LocationAPIClientBase::beforeBatchingStatusCb(BatchingStatusInfo batchStatus,
- std::list<uint32_t> & tripCompletedList) {
-
- // map the trip ids to the client ids
- std::list<uint32_t> tripCompletedClientIdList;
- tripCompletedClientIdList.clear();
-
- if (batchStatus.batchingStatus == BATCHING_STATUS_TRIP_COMPLETED) {
- for (auto itt = tripCompletedList.begin(); itt != tripCompletedList.end(); itt++) {
- if (mSessionBiDict.hasSession(*itt)) {
- SessionEntity sessEntity = mSessionBiDict.getExtBySession(*itt);
-
- if (sessEntity.sessionMode == SESSION_MODE_ON_TRIP_COMPLETED) {
- tripCompletedClientIdList.push_back(sessEntity.id);
- mSessionBiDict.rmBySession(*itt);
- }
- }
- }
- }
-
- mBatchingStatusCallback(batchStatus, tripCompletedClientIdList);
-}
-
-void LocationAPIClientBase::onResponseCb(LocationError error, uint32_t id)
-{
- if (error != LOCATION_ERROR_SUCCESS) {
- LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, error, id);
- } else {
- LOC_LOGV("%s:%d] SUCCESS: %d id: %d", __FUNCTION__, __LINE__, error, id);
- }
- LocationAPIRequest* request = getRequestBySession(id);
- if (request) {
- request->onResponse(error, id);
- delete request;
- }
-}
-
-void LocationAPIClientBase::onCollectiveResponseCb(
- size_t count, LocationError* errors, uint32_t* ids)
-{
- for (size_t i = 0; i < count; i++) {
- if (errors[i] != LOCATION_ERROR_SUCCESS) {
- LOC_LOGE("%s:%d] ERROR: %d ID: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
- } else {
- LOC_LOGV("%s:%d] SUCCESS: %d id: %d", __FUNCTION__, __LINE__, errors[i], ids[i]);
- }
- }
- LocationAPIRequest* request = nullptr;
- pthread_mutex_lock(&mMutex);
- if (mRequestQueues[REQUEST_GEOFENCE].getSession() == GEOFENCE_SESSION_ID) {
- request = mRequestQueues[REQUEST_GEOFENCE].pop();
- }
- pthread_mutex_unlock(&mMutex);
- if (request) {
- request->onCollectiveResponse(count, errors, ids);
- delete request;
- }
-}
-
-void LocationAPIClientBase::removeSession(uint32_t session) {
- if (mSessionBiDict.hasSession(session)) {
- mSessionBiDict.rmBySession(session);
- }
-}
-
-LocationAPIRequest* LocationAPIClientBase::getRequestBySession(uint32_t session)
-{
- pthread_mutex_lock(&mMutex);
- LocationAPIRequest* request = nullptr;
- for (int i = 0; i < REQUEST_MAX; i++) {
- if (i != REQUEST_GEOFENCE &&
- i != REQUEST_SESSION &&
- mRequestQueues[i].getSession() == session) {
- request = mRequestQueues[i].pop();
- break;
- }
- }
- if (request == nullptr) {
- // Can't find a request with correct session,
- // try to find it from mSessionBiDict
- if (mSessionBiDict.hasSession(session)) {
- request = mRequestQueues[REQUEST_SESSION].pop();
- }
- }
- pthread_mutex_unlock(&mMutex);
- return request;
-}
diff --git a/gps/location/LocationAPIClientBase.h b/gps/location/LocationAPIClientBase.h
deleted file mode 100644
index 4bd1466..0000000
--- a/gps/location/LocationAPIClientBase.h
+++ /dev/null
@@ -1,560 +0,0 @@
-/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef LOCATION_API_CLINET_BASE_H
-#define LOCATION_API_CLINET_BASE_H
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <pthread.h>
-#include <queue>
-#include <map>
-
-#include "LocationAPI.h"
-#include <loc_pla.h>
-#include <log_util.h>
-
-enum SESSION_MODE {
- SESSION_MODE_NONE = 0,
- SESSION_MODE_ON_FULL,
- SESSION_MODE_ON_FIX,
- SESSION_MODE_ON_TRIP_COMPLETED
-};
-
-enum REQUEST_TYPE {
- REQUEST_TRACKING = 0,
- REQUEST_SESSION,
- REQUEST_GEOFENCE,
- REQUEST_NIRESPONSE,
- REQUEST_MAX,
-};
-
-enum CTRL_REQUEST_TYPE {
- CTRL_REQUEST_DELETEAIDINGDATA = 0,
- CTRL_REQUEST_CONTROL,
- CTRL_REQUEST_CONFIG,
- CTRL_REQUEST_MAX,
-};
-
-class LocationAPIClientBase;
-
-class LocationAPIRequest {
-public:
- LocationAPIRequest() {}
- virtual ~LocationAPIRequest() {}
- virtual void onResponse(LocationError /*error*/, uint32_t /*id*/) {}
- virtual void onCollectiveResponse(
- size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
-};
-
-class RequestQueue {
-public:
- RequestQueue(): mSession(0) {
- }
- virtual ~RequestQueue() {
- reset(0);
- }
- void inline setSession(uint32_t session) { mSession = session; }
- void reset(uint32_t session) {
- LocationAPIRequest* request = nullptr;
- while (!mQueue.empty()) {
- request = mQueue.front();
- mQueue.pop();
- delete request;
- }
- mSession = session;
- }
- void push(LocationAPIRequest* request) {
- mQueue.push(request);
- }
- LocationAPIRequest* pop() {
- LocationAPIRequest* request = nullptr;
- if (!mQueue.empty()) {
- request = mQueue.front();
- mQueue.pop();
- }
- return request;
- }
- uint32_t getSession() { return mSession; }
-private:
- uint32_t mSession;
- std::queue<LocationAPIRequest*> mQueue;
-};
-
-class LocationAPIControlClient {
-public:
- LocationAPIControlClient();
- virtual ~LocationAPIControlClient();
- LocationAPIControlClient(const LocationAPIControlClient&) = delete;
- LocationAPIControlClient& operator=(const LocationAPIControlClient&) = delete;
-
- LocationAPIRequest* getRequestBySession(uint32_t session);
-
- // LocationControlAPI
- uint32_t locAPIGnssDeleteAidingData(GnssAidingData& data);
- uint32_t locAPIEnable(LocationTechnologyType techType);
- void locAPIDisable();
- uint32_t locAPIGnssUpdateConfig(GnssConfig config);
-
- // callbacks
- void onCtrlResponseCb(LocationError error, uint32_t id);
- void onCtrlCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids);
-
- inline virtual void onGnssDeleteAidingDataCb(LocationError /*error*/) {}
- inline virtual void onEnableCb(LocationError /*error*/) {}
- inline virtual void onDisableCb(LocationError /*error*/) {}
- inline virtual void onGnssUpdateConfigCb(
- size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
-
- class GnssDeleteAidingDataRequest : public LocationAPIRequest {
- public:
- GnssDeleteAidingDataRequest(LocationAPIControlClient& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t /*id*/) {
- mAPI.onGnssDeleteAidingDataCb(error);
- }
- LocationAPIControlClient& mAPI;
- };
-
- class EnableRequest : public LocationAPIRequest {
- public:
- EnableRequest(LocationAPIControlClient& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t /*id*/) {
- mAPI.onEnableCb(error);
- }
- LocationAPIControlClient& mAPI;
- };
-
- class DisableRequest : public LocationAPIRequest {
- public:
- DisableRequest(LocationAPIControlClient& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t /*id*/) {
- mAPI.onDisableCb(error);
- }
- LocationAPIControlClient& mAPI;
- };
-
- class GnssUpdateConfigRequest : public LocationAPIRequest {
- public:
- GnssUpdateConfigRequest(LocationAPIControlClient& API) : mAPI(API) {}
- inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* ids) {
- mAPI.onGnssUpdateConfigCb(count, errors, ids);
- }
- LocationAPIControlClient& mAPI;
- };
-
-private:
- pthread_mutex_t mMutex;
- LocationControlAPI* mLocationControlAPI;
- RequestQueue mRequestQueues[CTRL_REQUEST_MAX];
- bool mEnabled;
- GnssConfig mConfig;
-};
-
-class LocationAPIClientBase {
-public:
- LocationAPIClientBase();
- virtual ~LocationAPIClientBase();
- LocationAPIClientBase(const LocationAPIClientBase&) = delete;
- LocationAPIClientBase& operator=(const LocationAPIClientBase&) = delete;
-
- void locAPISetCallbacks(LocationCallbacks& locationCallbacks);
- void removeSession(uint32_t session);
- LocationAPIRequest* getRequestBySession(uint32_t session);
-
- // LocationAPI
- uint32_t locAPIStartTracking(LocationOptions& options);
- void locAPIStopTracking();
- void locAPIUpdateTrackingOptions(LocationOptions& options);
-
- int32_t locAPIGetBatchSize();
- uint32_t locAPIStartSession(uint32_t id, uint32_t sessionMode,
- LocationOptions& options);
- uint32_t locAPIStopSession(uint32_t id);
- uint32_t locAPIUpdateSessionOptions(uint32_t id, uint32_t sessionMode,
- LocationOptions& options);
- uint32_t locAPIGetBatchedLocations(uint32_t id, size_t count);
-
- uint32_t locAPIAddGeofences(size_t count, uint32_t* ids,
- GeofenceOption* options, GeofenceInfo* data);
- void locAPIRemoveGeofences(size_t count, uint32_t* ids);
- void locAPIModifyGeofences(size_t count, uint32_t* ids, GeofenceOption* options);
- void locAPIPauseGeofences(size_t count, uint32_t* ids);
- void locAPIResumeGeofences(size_t count, uint32_t* ids, GeofenceBreachTypeMask* mask);
- void locAPIRemoveAllGeofences();
-
- void locAPIGnssNiResponse(uint32_t id, GnssNiResponse response);
-
- // callbacks
- void onResponseCb(LocationError error, uint32_t id);
- void onCollectiveResponseCb(size_t count, LocationError* errors, uint32_t* ids);
-
- void beforeGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification);
-
- inline virtual void onCapabilitiesCb(LocationCapabilitiesMask /*capabilitiesMask*/) {}
- inline virtual void onGnssNmeaCb(GnssNmeaNotification /*gnssNmeaNotification*/) {}
- inline virtual void onGnssMeasurementsCb(
- GnssMeasurementsNotification /*gnssMeasurementsNotification*/) {}
-
- inline virtual void onTrackingCb(Location /*location*/) {}
- inline virtual void onGnssSvCb(GnssSvNotification /*gnssSvNotification*/) {}
- inline virtual void onStartTrackingCb(LocationError /*error*/) {}
- inline virtual void onStopTrackingCb(LocationError /*error*/) {}
- inline virtual void onUpdateTrackingOptionsCb(LocationError /*error*/) {}
-
- inline virtual void onGnssLocationInfoCb(
- GnssLocationInfoNotification /*gnssLocationInfoNotification*/) {}
-
- inline virtual void onBatchingCb(size_t /*count*/, Location* /*location*/,
- BatchingOptions /*batchingOptions*/) {}
- inline virtual void onBatchingStatusCb(BatchingStatusInfo /*batchingStatus*/,
- std::list<uint32_t> &/*listOfCompletedTrips*/) {}
- void beforeBatchingStatusCb(BatchingStatusInfo batchStatus,
- std::list<uint32_t> & tripCompletedList);
- inline virtual void onStartBatchingCb(LocationError /*error*/) {}
- inline virtual void onStopBatchingCb(LocationError /*error*/) {}
- inline virtual void onUpdateBatchingOptionsCb(LocationError /*error*/) {}
- inline virtual void onGetBatchedLocationsCb(LocationError /*error*/) {}
-
- inline virtual void onGeofenceBreachCb(
- GeofenceBreachNotification /*geofenceBreachNotification*/) {}
- inline virtual void onGeofenceStatusCb(
- GeofenceStatusNotification /*geofenceStatusNotification*/) {}
- inline virtual void onAddGeofencesCb(
- size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
- inline virtual void onRemoveGeofencesCb(
- size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
- inline virtual void onModifyGeofencesCb(
- size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
- inline virtual void onPauseGeofencesCb(
- size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
- inline virtual void onResumeGeofencesCb(
- size_t /*count*/, LocationError* /*errors*/, uint32_t* /*ids*/) {}
-
- inline virtual void onGnssNiCb(uint32_t /*id*/, GnssNiNotification /*gnssNiNotification*/) {}
- inline virtual void onGnssNiResponseCb(LocationError /*error*/) {}
-
-private:
- // private inner classes
- typedef struct {
- uint32_t id;
- uint32_t trackingSession;
- uint32_t batchingSession;
- uint32_t sessionMode;
- } SessionEntity;
-
- template<typename T>
- class BiDict {
- public:
- BiDict() {
- pthread_mutex_init(&mBiDictMutex, nullptr);
- }
- virtual ~BiDict() {
- pthread_mutex_destroy(&mBiDictMutex);
- }
- bool hasId(uint32_t id) {
- pthread_mutex_lock(&mBiDictMutex);
- bool ret = (mForwardMap.find(id) != mForwardMap.end());
- pthread_mutex_unlock(&mBiDictMutex);
- return ret;
- }
- bool hasSession(uint32_t session) {
- pthread_mutex_lock(&mBiDictMutex);
- bool ret = (mBackwardMap.find(session) != mBackwardMap.end());
- pthread_mutex_unlock(&mBiDictMutex);
- return ret;
- }
- void set(uint32_t id, uint32_t session, T& ext) {
- pthread_mutex_lock(&mBiDictMutex);
- mForwardMap[id] = session;
- mBackwardMap[session] = id;
- mExtMap[session] = ext;
- pthread_mutex_unlock(&mBiDictMutex);
- }
- void clear() {
- pthread_mutex_lock(&mBiDictMutex);
- mForwardMap.clear();
- mBackwardMap.clear();
- mExtMap.clear();
- pthread_mutex_unlock(&mBiDictMutex);
- }
- void rmById(uint32_t id) {
- pthread_mutex_lock(&mBiDictMutex);
- mBackwardMap.erase(mForwardMap[id]);
- mExtMap.erase(mForwardMap[id]);
- mForwardMap.erase(id);
- pthread_mutex_unlock(&mBiDictMutex);
- }
- void rmBySession(uint32_t session) {
- pthread_mutex_lock(&mBiDictMutex);
- mForwardMap.erase(mBackwardMap[session]);
- mBackwardMap.erase(session);
- mExtMap.erase(session);
- pthread_mutex_unlock(&mBiDictMutex);
- }
- uint32_t getId(uint32_t session) {
- pthread_mutex_lock(&mBiDictMutex);
- uint32_t ret = 0;
- auto it = mBackwardMap.find(session);
- if (it != mBackwardMap.end()) {
- ret = it->second;
- }
- pthread_mutex_unlock(&mBiDictMutex);
- return ret;
- }
- uint32_t getSession(uint32_t id) {
- pthread_mutex_lock(&mBiDictMutex);
- uint32_t ret = 0;
- auto it = mForwardMap.find(id);
- if (it != mForwardMap.end()) {
- ret = it->second;
- }
- pthread_mutex_unlock(&mBiDictMutex);
- return ret;
- }
- T getExtById(uint32_t id) {
- pthread_mutex_lock(&mBiDictMutex);
- T ret;
- memset(&ret, 0, sizeof(T));
- uint32_t session = mForwardMap[id];
- if (session > 0) {
- auto it = mExtMap.find(session);
- if (it != mExtMap.end()) {
- ret = it->second;
- }
- }
- pthread_mutex_unlock(&mBiDictMutex);
- return ret;
- }
- T getExtBySession(uint32_t session) {
- pthread_mutex_lock(&mBiDictMutex);
- T ret;
- memset(&ret, 0, sizeof(T));
- auto it = mExtMap.find(session);
- if (it != mExtMap.end()) {
- ret = it->second;
- }
- pthread_mutex_unlock(&mBiDictMutex);
- return ret;
- }
- std::vector<uint32_t> getAllSessions() {
- std::vector<uint32_t> ret;
- pthread_mutex_lock(&mBiDictMutex);
- for (auto it = mBackwardMap.begin(); it != mBackwardMap.end(); it++) {
- ret.push_back(it->first);
- }
- pthread_mutex_unlock(&mBiDictMutex);
- return ret;
- }
- private:
- pthread_mutex_t mBiDictMutex;
- // mForwarMap mapping id->session
- std::map<uint32_t, uint32_t> mForwardMap;
- // mBackwardMap mapping session->id
- std::map<uint32_t, uint32_t> mBackwardMap;
- // mExtMap mapping session->ext
- std::map<uint32_t, T> mExtMap;
- };
-
- class StartTrackingRequest : public LocationAPIRequest {
- public:
- StartTrackingRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t id) {
- if (error != LOCATION_ERROR_SUCCESS) {
- mAPI.removeSession(id);
- }
- mAPI.onStartTrackingCb(error);
- }
- LocationAPIClientBase& mAPI;
- };
-
- class StopTrackingRequest : public LocationAPIRequest {
- public:
- StopTrackingRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t id) {
- mAPI.onStopTrackingCb(error);
- if (error == LOCATION_ERROR_SUCCESS) {
- mAPI.removeSession(id);
- }
- }
- LocationAPIClientBase& mAPI;
- };
-
- class UpdateTrackingOptionsRequest : public LocationAPIRequest {
- public:
- UpdateTrackingOptionsRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t /*id*/) {
- mAPI.onUpdateTrackingOptionsCb(error);
- }
- LocationAPIClientBase& mAPI;
- };
-
- class StartBatchingRequest : public LocationAPIRequest {
- public:
- StartBatchingRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t id) {
- if (error != LOCATION_ERROR_SUCCESS) {
- mAPI.removeSession(id);
- }
- mAPI.onStartBatchingCb(error);
- }
- LocationAPIClientBase& mAPI;
- };
-
- class StopBatchingRequest : public LocationAPIRequest {
- public:
- StopBatchingRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t id) {
- mAPI.onStopBatchingCb(error);
- if (error == LOCATION_ERROR_SUCCESS) {
- mAPI.removeSession(id);
- }
- }
- LocationAPIClientBase& mAPI;
- };
-
- class UpdateBatchingOptionsRequest : public LocationAPIRequest {
- public:
- UpdateBatchingOptionsRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t /*id*/) {
- mAPI.onUpdateBatchingOptionsCb(error);
- }
- LocationAPIClientBase& mAPI;
- };
-
- class GetBatchedLocationsRequest : public LocationAPIRequest {
- public:
- GetBatchedLocationsRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t /*id*/) {
- mAPI.onGetBatchedLocationsCb(error);
- }
- LocationAPIClientBase& mAPI;
- };
-
- class AddGeofencesRequest : public LocationAPIRequest {
- public:
- AddGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
- uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
- for (size_t i = 0; i < count; i++) {
- ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
- }
- mAPI.onAddGeofencesCb(count, errors, ids);
- free(ids);
- }
- LocationAPIClientBase& mAPI;
- };
-
- class RemoveGeofencesRequest : public LocationAPIRequest {
- public:
- RemoveGeofencesRequest(LocationAPIClientBase& API,
- BiDict<GeofenceBreachTypeMask>* removedGeofenceBiDict) :
- mAPI(API), mRemovedGeofenceBiDict(removedGeofenceBiDict) {}
- inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
- if (nullptr != mRemovedGeofenceBiDict) {
- uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
- for (size_t i = 0; i < count; i++) {
- ids[i] = mRemovedGeofenceBiDict->getId(sessions[i]);
- }
- mAPI.onRemoveGeofencesCb(count, errors, ids);
- free(ids);
- delete(mRemovedGeofenceBiDict);
- } else {
- LOC_LOGE("%s:%d] Unable to access removed geofences data.", __FUNCTION__, __LINE__);
- }
- }
- LocationAPIClientBase& mAPI;
- BiDict<GeofenceBreachTypeMask>* mRemovedGeofenceBiDict;
- };
-
- class ModifyGeofencesRequest : public LocationAPIRequest {
- public:
- ModifyGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
- uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
- for (size_t i = 0; i < count; i++) {
- ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
- }
- mAPI.onModifyGeofencesCb(count, errors, ids);
- free(ids);
- }
- LocationAPIClientBase& mAPI;
- };
-
- class PauseGeofencesRequest : public LocationAPIRequest {
- public:
- PauseGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
- uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
- for (size_t i = 0; i < count; i++) {
- ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
- }
- mAPI.onPauseGeofencesCb(count, errors, ids);
- free(ids);
- }
- LocationAPIClientBase& mAPI;
- };
-
- class ResumeGeofencesRequest : public LocationAPIRequest {
- public:
- ResumeGeofencesRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onCollectiveResponse(size_t count, LocationError* errors, uint32_t* sessions) {
- uint32_t *ids = (uint32_t*)malloc(sizeof(uint32_t) * count);
- for (size_t i = 0; i < count; i++) {
- ids[i] = mAPI.mGeofenceBiDict.getId(sessions[i]);
- }
- mAPI.onResumeGeofencesCb(count, errors, ids);
- free(ids);
- }
- LocationAPIClientBase& mAPI;
- };
-
- class GnssNiResponseRequest : public LocationAPIRequest {
- public:
- GnssNiResponseRequest(LocationAPIClientBase& API) : mAPI(API) {}
- inline void onResponse(LocationError error, uint32_t /*id*/) {
- mAPI.onGnssNiResponseCb(error);
- }
- LocationAPIClientBase& mAPI;
- };
-
-private:
- pthread_mutex_t mMutex;
-
- geofenceBreachCallback mGeofenceBreachCallback;
- batchingStatusCallback mBatchingStatusCallback;
-
- LocationAPI* mLocationAPI;
-
- RequestQueue mRequestQueues[REQUEST_MAX];
- BiDict<GeofenceBreachTypeMask> mGeofenceBiDict;
- BiDict<SessionEntity> mSessionBiDict;
- int32_t mBatchSize;
- bool mTracking;
-};
-
-#endif /* LOCATION_API_CLINET_BASE_H */
diff --git a/gps/location/Makefile.am b/gps/location/Makefile.am
deleted file mode 100644
index 3688cc8..0000000
--- a/gps/location/Makefile.am
+++ /dev/null
@@ -1,38 +0,0 @@
-ACLOCAL_AMFLAGS = -I m4
-
-AM_CFLAGS = \
- -I./ \
- -I../utils \
- $(LOCPLA_CFLAGS) \
- $(GPSUTILS_CFLAGS) \
- -std=c++11
-
-liblocation_api_la_SOURCES = \
- LocationAPI.cpp \
- LocationAPIClientBase.cpp
-
-if USE_GLIB
-liblocation_api_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
-liblocation_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
-liblocation_api_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
-else
-liblocation_api_la_CFLAGS = $(AM_CFLAGS)
-liblocation_api_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0
-liblocation_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
-endif
-
-liblocation_api_la_LIBADD = -lstdc++ -ldl $(GPSUTILS_LIBS)
-
-library_include_HEADERS = \
- LocationAPI.h \
- LocationAPIClientBase.h \
- location_interface.h
-
-#Create and Install libraries
-lib_LTLIBRARIES = liblocation_api.la
-
-library_includedir = $(pkgincludedir)
-
-pkgconfigdir = $(libdir)/pkgconfig
-pkgconfig_DATA = location-api.pc
-EXTRA_DIST = $(pkgconfig_DATA)
diff --git a/gps/location/configure.ac b/gps/location/configure.ac
deleted file mode 100644
index 6391d65..0000000
--- a/gps/location/configure.ac
+++ /dev/null
@@ -1,82 +0,0 @@
-# configure.ac -- Autoconf script for gps location-api-iface
-#
-# Process this file with autoconf to produce a configure script
-
-# Requires autoconf tool later than 2.61
-AC_PREREQ(2.61)
-# Initialize the gps location-api-iface package version 1.0.0
-AC_INIT([location-api-iface],1.0.0)
-# Does not strictly follow GNU Coding standards
-AM_INIT_AUTOMAKE([foreign])
-# Disables auto rebuilding of configure, Makefile.ins
-AM_MAINTAINER_MODE
-# Verifies the --srcdir is correct by checking for the path
-AC_CONFIG_SRCDIR([location-api.pc.in])
-# defines some macros variable to be included by source
-AC_CONFIG_HEADERS([config.h])
-AC_CONFIG_MACRO_DIR([m4])
-
-# Checks for programs.
-AC_PROG_LIBTOOL
-AC_PROG_CXX
-AC_PROG_CC
-AM_PROG_CC_C_O
-AC_PROG_AWK
-AC_PROG_CPP
-AC_PROG_INSTALL
-AC_PROG_LN_S
-AC_PROG_MAKE_SET
-PKG_PROG_PKG_CONFIG
-
-# Checks for libraries.
-PKG_CHECK_MODULES([GPSUTILS], [gps-utils])
-AC_SUBST([GPSUTILS_CFLAGS])
-AC_SUBST([GPSUTILS_LIBS])
-
-AC_ARG_WITH([core_includes],
- AC_HELP_STRING([--with-core-includes=@<:@dir@:>@],
- [Specify the location of the core headers]),
- [core_incdir=$withval],
- with_core_includes=no)
-
-if test "x$with_core_includes" != "xno"; then
- CPPFLAGS="${CPPFLAGS} -I${core_incdir}"
-fi
-
-AC_ARG_WITH([locpla_includes],
- AC_HELP_STRING([--with-locpla-includes=@<:@dir@:>@],
- [Specify the path to locpla-includes in loc-pla_git.bb]),
- [locpla_incdir=$withval],
- with_locpla_includes=no)
-
-if test "x${with_locpla_includes}" != "xno"; then
- AC_SUBST(LOCPLA_CFLAGS, "-I${locpla_incdir}")
-fi
-
-AC_SUBST([CPPFLAGS])
-
-AC_ARG_WITH([glib],
- AC_HELP_STRING([--with-glib],
- [enable glib, building HLOS systems which use glib]))
-
-if (test "x${with_glib}" = "xyes"); then
- AC_DEFINE(ENABLE_USEGLIB, 1, [Define if HLOS systems uses glib])
- PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= 2.16, dummy=yes,
- AC_MSG_ERROR(GThread >= 2.16 is required))
- PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, dummy=yes,
- AC_MSG_ERROR(GLib >= 2.16 is required))
- GLIB_CFLAGS="$GLIB_CFLAGS $GTHREAD_CFLAGS"
- GLIB_LIBS="$GLIB_LIBS $GTHREAD_LIBS"
-
- AC_SUBST(GLIB_CFLAGS)
- AC_SUBST(GLIB_LIBS)
-fi
-
-AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
-
-AC_CONFIG_FILES([ \
- Makefile \
- location-api.pc \
- ])
-
-AC_OUTPUT
diff --git a/gps/location/location-api.pc.in b/gps/location/location-api.pc.in
deleted file mode 100644
index c7b146a..0000000
--- a/gps/location/location-api.pc.in
+++ /dev/null
@@ -1,10 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-Name: location-api
-Description: Location API
-Version: @VERSION
-Libs: -L${libdir} -llocation_api
-Cflags: -I${includedir}/location-api
diff --git a/gps/location/location_interface.h b/gps/location/location_interface.h
deleted file mode 100644
index 9229052..0000000
--- a/gps/location/location_interface.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/* Copyright (c) 2017 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following
- * disclaimer in the documentation and/or other materials provided
- * with the distribution.
- * * Neither the name of The Linux Foundation nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef LOCATION_INTERFACE_H
-#define LOCATION_INTERFACE_H
-
-#include <LocationAPI.h>
-#include <gps_extended_c.h>
-
-struct GnssInterface {
- size_t size;
- void (*initialize)(void);
- void (*deinitialize)(void);
- void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks);
- void (*removeClient)(LocationAPI* client);
- void (*requestCapabilities)(LocationAPI* client);
- uint32_t (*startTracking)(LocationAPI* client, LocationOptions& options);
- void (*updateTrackingOptions)(LocationAPI* client, uint32_t id, LocationOptions& options);
- void (*stopTracking)(LocationAPI* client, uint32_t id);
- void (*gnssNiResponse)(LocationAPI* client, uint32_t id, GnssNiResponse response);
- void (*setControlCallbacks)(LocationControlCallbacks& controlCallbacks);
- uint32_t (*enable)(LocationTechnologyType techType);
- void (*disable)(uint32_t id);
- uint32_t* (*gnssUpdateConfig)(GnssConfig config);
- uint32_t (*gnssDeleteAidingData)(GnssAidingData& data);
- void (*gnssUpdateXtraThrottle)(const bool enabled);
- void (*injectLocation)(double latitude, double longitude, float accuracy);
- void (*injectTime)(int64_t time, int64_t timeReference, int32_t uncertainty);
- void (*agpsInit)(const AgpsCbInfo& cbInfo);
- void (*agpsDataConnOpen)(AGpsExtType agpsType, const char* apnName, int apnLen, int ipType);
- void (*agpsDataConnClosed)(AGpsExtType agpsType);
- void (*agpsDataConnFailed)(AGpsExtType agpsType);
- void (*getDebugReport)(GnssDebugReport& report);
- void (*updateConnectionStatus)(bool connected, int8_t type);
- void (*odcpiInit)(const OdcpiRequestCallback& callback);
- void (*odcpiInject)(const Location& location);
-};
-
-struct FlpInterface {
- size_t size;
- void (*initialize)(void);
- void (*deinitialize)(void);
- void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks);
- void (*removeClient)(LocationAPI* client);
- void (*requestCapabilities)(LocationAPI* client);
- uint32_t (*startTracking)(LocationAPI* client, LocationOptions& options);
- void (*updateTrackingOptions)(LocationAPI* client, uint32_t id, LocationOptions& options);
- void (*stopTracking)(LocationAPI* client, uint32_t id);
- uint32_t (*startBatching)(LocationAPI* client, LocationOptions&, BatchingOptions&);
- void (*stopBatching)(LocationAPI* client, uint32_t id);
- void (*updateBatchingOptions)(LocationAPI* client, uint32_t id, LocationOptions&,
- BatchingOptions&);
- void (*getBatchedLocations)(LocationAPI* client, uint32_t id, size_t count);
- void (*getPowerStateChanges)(void* powerStateCb);
-};
-
-struct GeofenceInterface {
- size_t size;
- void (*initialize)(void);
- void (*deinitialize)(void);
- void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks);
- void (*removeClient)(LocationAPI* client);
- void (*requestCapabilities)(LocationAPI* client);
- uint32_t* (*addGeofences)(LocationAPI* client, size_t count, GeofenceOption*, GeofenceInfo*);
- void (*removeGeofences)(LocationAPI* client, size_t count, uint32_t* ids);
- void (*modifyGeofences)(LocationAPI* client, size_t count, uint32_t* ids,
- GeofenceOption* options);
- void (*pauseGeofences)(LocationAPI* client, size_t count, uint32_t* ids);
- void (*resumeGeofences)(LocationAPI* client, size_t count, uint32_t* ids);
-};
-
-#endif /* LOCATION_INTERFACE_H */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 20:06:33 +0000