From 1f8198a460dec7c374033161a036ca951ed33533 Mon Sep 17 00:00:00 2001 From: Vachounet Date: Wed, 22 Nov 2017 20:38:49 +0100 Subject: [PATCH] sanders: gps: switch to LA.UM.6.6.r1-04300-89xx.0 branch --- BoardConfig.mk | 5 + device.mk | 21 +- gps/Android.mk | 20 +- gps/Makefile.am | 10 + gps/android/AGnss.cpp | 185 + gps/android/AGnss.h | 77 + gps/android/AGnssRil.cpp | 63 + gps/android/AGnssRil.h | 83 + gps/android/Android.mk | 92 + gps/android/Gnss.cpp | 338 ++ gps/android/Gnss.h | 149 + gps/android/GnssBatching.cpp | 130 + gps/android/GnssBatching.h | 80 + gps/android/GnssConfiguration.cpp | 227 ++ gps/android/GnssConfiguration.h | 71 + gps/android/GnssDebug.cpp | 143 + gps/android/GnssDebug.h | 59 + gps/android/GnssGeofencing.cpp | 141 + gps/android/GnssGeofencing.h | 91 + gps/android/GnssMeasurement.cpp | 99 + gps/android/GnssMeasurement.h | 76 + gps/android/GnssNi.cpp | 85 + gps/android/GnssNi.h | 75 + .../android.hardware.gnss@1.0-service-qti.rc | 4 + .../location_api/BatchingAPIClient.cpp | 191 + gps/android/location_api/BatchingAPIClient.h | 75 + .../location_api/GeofenceAPIClient.cpp | 273 ++ gps/android/location_api/GeofenceAPIClient.h | 76 + gps/android/location_api/GnssAPIClient.cpp | 498 +++ gps/android/location_api/GnssAPIClient.h | 107 + gps/android/location_api/LocationUtil.cpp | 153 + .../location_api/LocationUtil.h} | 43 +- .../location_api/MeasurementAPIClient.cpp | 257 ++ .../location_api/MeasurementAPIClient.h | 75 + gps/android/service.cpp | 31 + gps/configure.ac | 91 + gps/core/Android.mk | 48 +- gps/core/ContextBase.cpp | 158 +- gps/core/ContextBase.h | 6 +- gps/core/LocAdapterBase.cpp | 67 +- gps/core/LocAdapterBase.h | 83 +- gps/core/LocAdapterProxyBase.h | 15 +- gps/core/LocApiBase.cpp | 289 +- gps/core/LocApiBase.h | 76 +- gps/core/LocDualContext.cpp | 7 +- gps/core/LocDualContext.h | 2 +- gps/core/Makefile.am | 61 + gps/core/SystemStatus.cpp | 1788 ++++++++++ gps/core/SystemStatus.h | 644 ++++ gps/core/SystemStatusOsObserver.cpp | 593 ++++ gps/core/SystemStatusOsObserver.h | 135 + gps/core/UlpProxyBase.h | 56 +- gps/core/data-items/DataItemId.h | 73 + gps/core/data-items/DataItemsFactoryProxy.cpp | 99 + .../data-items/DataItemsFactoryProxy.h} | 30 +- .../data-items/IDataItemCore.h} | 69 +- gps/core/data-items/common/ClientIndex.cpp | 171 + .../data-items/common/ClientIndex.h} | 57 +- gps/core/data-items/common/DataItemIndex.cpp | 202 ++ gps/core/data-items/common/DataItemIndex.h | 70 + gps/core/data-items/common/IClientIndex.h | 83 + gps/core/data-items/common/IDataItemIndex.h | 94 + .../data-items/common/IndexFactory.cpp} | 67 +- .../data-items/common/IndexFactory.h} | 26 +- gps/core/loc_core_log.cpp | 104 +- gps/core/loc_core_log.h | 26 +- gps/core/observer/IDataItemObserver.h | 76 + gps/core/observer/IDataItemSubscription.h | 129 + gps/core/observer/IFrameworkActionReq.h | 83 + gps/core/observer/IOsObserver.h | 103 + gps/gnss/Agps.cpp | 912 +++++ gps/gnss/Agps.h | 383 ++ gps/gnss/Android.mk | 47 + gps/gnss/GnssAdapter.cpp | 3131 +++++++++++++++++ gps/gnss/GnssAdapter.h | 287 ++ gps/gnss/Makefile.am | 99 + gps/gnss/XtraSystemStatusObserver.cpp | 234 ++ gps/gnss/XtraSystemStatusObserver.h | 71 + gps/gnss/location_gnss.cpp | 258 ++ gps/gnsspps/Android.mk | 32 - gps/gnsspps/gnsspps.c | 194 - gps/gnsspps/timepps.h | 106 - gps/loc-hal.pc.in | 10 + gps/loc_api/Android.mk | 3 - gps/loc_api/libloc_api_50001/Android.mk | 111 - .../libloc_api_50001/LocEngAdapter.cpp | 598 ---- gps/loc_api/libloc_api_50001/LocEngAdapter.h | 355 -- gps/loc_api/libloc_api_50001/gps.c | 73 - gps/loc_api/libloc_api_50001/loc.cpp | 1120 ------ gps/loc_api/libloc_api_50001/loc_eng.cpp | 3033 ---------------- gps/loc_api/libloc_api_50001/loc_eng.h | 210 -- gps/loc_api/libloc_api_50001/loc_eng_agps.cpp | 969 ----- gps/loc_api/libloc_api_50001/loc_eng_agps.h | 435 --- .../libloc_api_50001/loc_eng_dmn_conn.cpp | 269 -- .../loc_eng_dmn_conn_glue_msg.c | 222 -- .../loc_eng_dmn_conn_glue_pipe.c | 215 -- .../loc_eng_dmn_conn_glue_pipe.h | 50 - .../loc_eng_dmn_conn_handler.cpp | 236 -- .../loc_eng_dmn_conn_handler.h | 106 - .../loc_eng_dmn_conn_thread_helper.c | 398 --- .../loc_eng_dmn_conn_thread_helper.h | 74 - gps/loc_api/libloc_api_50001/loc_eng_msg.h | 306 -- gps/loc_api/libloc_api_50001/loc_eng_ni.cpp | 413 --- gps/loc_api/libloc_api_50001/loc_eng_ni.h | 59 - gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp | 924 ----- gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp | 219 -- gps/loc_api/libloc_api_50001/loc_eng_xtra.h | 47 - gps/location/Android.mk | 42 + gps/location/LocationAPI.cpp | 644 ++++ gps/location/LocationAPI.h | 973 +++++ gps/location/LocationAPIClientBase.cpp | 929 +++++ gps/location/LocationAPIClientBase.h | 545 +++ gps/location/Makefile.am | 40 + gps/location/location_interface.h | 94 + gps/utils/Android.mk | 36 +- gps/utils/LocThread.cpp | 4 +- gps/utils/LocTimer.cpp | 23 +- gps/utils/Makefile.am | 64 + gps/utils/MsgTask.cpp | 15 +- gps/utils/configure.ac | 59 + gps/utils/gps-utils.pc.in | 10 + gps/{core => utils}/gps_extended.h | 20 +- gps/{core => utils}/gps_extended_c.h | 345 +- gps/utils/linked_list.c | 5 +- gps/utils/loc_cfg.cpp | 2 +- gps/utils/loc_cfg.h | 4 +- gps/utils/loc_gps.h | 2209 ++++++++++++ gps/utils/loc_log.cpp | 3 +- gps/utils/loc_misc_utils.cpp | 4 +- gps/utils/loc_nmea.cpp | 1106 ++++++ .../loc_eng_nmea.h => utils/loc_nmea.h} | 25 +- gps/utils/loc_target.cpp | 116 +- gps/utils/loc_target.h | 2 - gps/utils/log_util.h | 68 +- gps/utils/msg_q.c | 10 +- .../elapsed_millis_since_boot.cpp | 2 +- .../loc_pla/Makefile.am | 10 + .../loc_pla/configure.ac | 61 + .../include/platform_lib_android_runtime.h | 45 - .../loc_pla/include/platform_lib_gettid.h | 4 + .../loc_pla/include/platform_lib_includes.h | 1 - .../loc_pla/include/platform_lib_log_util.h | 68 +- .../loc_pla/include/platform_lib_macros.h | 12 + .../loc_pla/include/platform_lib_time.h | 1 + .../loc_pla/loc-pla.pc.in | 10 + .../loc_pla/src/Android.mk | 54 +- .../loc_pla/src/Makefile.am | 39 + .../src/platform_lib_android_runtime.cpp | 40 - .../loc_pla/src/platform_lib_gettid.cpp | 6 + .../loc_pla/src/platform_lib_log_util.cpp | 36 + .../src/platform_lib_property_service.cpp | 4 +- .../loc_pla/src/platform_lib_time.cpp | 16 +- .../loc_stub/Makefile.am | 9 + .../loc_stub/configure.ac | 67 + .../loc_stub/include/loc_stub_time.h | 1 + .../loc_stub/loc-stub.pc.in | 10 + .../loc_stub/src/Android.mk | 22 +- .../loc_stub/src/Makefile.am | 40 + .../loc_stub/src/loc_stub_android_runtime.cpp | 2 +- .../src/loc_stub_property_service.cpp | 2 +- .../loc_stub/src/loc_stub_sched_policy.cpp | 2 +- .../loc_stub/src/loc_stub_time.cpp | 15 +- 162 files changed, 22237 insertions(+), 11732 deletions(-) create mode 100644 gps/Makefile.am create mode 100644 gps/android/AGnss.cpp create mode 100644 gps/android/AGnss.h create mode 100644 gps/android/AGnssRil.cpp create mode 100644 gps/android/AGnssRil.h create mode 100644 gps/android/Android.mk create mode 100644 gps/android/Gnss.cpp create mode 100644 gps/android/Gnss.h create mode 100644 gps/android/GnssBatching.cpp create mode 100644 gps/android/GnssBatching.h create mode 100644 gps/android/GnssConfiguration.cpp create mode 100644 gps/android/GnssConfiguration.h create mode 100644 gps/android/GnssDebug.cpp create mode 100644 gps/android/GnssDebug.h create mode 100644 gps/android/GnssGeofencing.cpp create mode 100644 gps/android/GnssGeofencing.h create mode 100644 gps/android/GnssMeasurement.cpp create mode 100644 gps/android/GnssMeasurement.h create mode 100644 gps/android/GnssNi.cpp create mode 100644 gps/android/GnssNi.h create mode 100644 gps/android/android.hardware.gnss@1.0-service-qti.rc create mode 100644 gps/android/location_api/BatchingAPIClient.cpp create mode 100644 gps/android/location_api/BatchingAPIClient.h create mode 100644 gps/android/location_api/GeofenceAPIClient.cpp create mode 100644 gps/android/location_api/GeofenceAPIClient.h create mode 100644 gps/android/location_api/GnssAPIClient.cpp create mode 100644 gps/android/location_api/GnssAPIClient.h create mode 100644 gps/android/location_api/LocationUtil.cpp rename gps/{gnsspps/gnsspps.h => android/location_api/LocationUtil.h} (60%) create mode 100644 gps/android/location_api/MeasurementAPIClient.cpp create mode 100644 gps/android/location_api/MeasurementAPIClient.h create mode 100644 gps/android/service.cpp create mode 100644 gps/configure.ac create mode 100644 gps/core/Makefile.am create mode 100644 gps/core/SystemStatus.cpp create mode 100644 gps/core/SystemStatus.h create mode 100644 gps/core/SystemStatusOsObserver.cpp create mode 100644 gps/core/SystemStatusOsObserver.h create mode 100644 gps/core/data-items/DataItemId.h create mode 100644 gps/core/data-items/DataItemsFactoryProxy.cpp rename gps/{loc_api/libloc_api_50001/loc_eng_log.cpp => core/data-items/DataItemsFactoryProxy.h} (69%) rename gps/{loc_api/libloc_api_50001/loc_eng_dmn_conn.h => core/data-items/IDataItemCore.h} (56%) create mode 100644 gps/core/data-items/common/ClientIndex.cpp rename gps/{loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h => core/data-items/common/ClientIndex.h} (59%) create mode 100644 gps/core/data-items/common/DataItemIndex.cpp create mode 100644 gps/core/data-items/common/DataItemIndex.h create mode 100644 gps/core/data-items/common/IClientIndex.h create mode 100644 gps/core/data-items/common/IDataItemIndex.h rename gps/{loc_api/libloc_api_50001/loc.h => core/data-items/common/IndexFactory.cpp} (58%) rename gps/{loc_api/libloc_api_50001/loc_eng_log.h => core/data-items/common/IndexFactory.h} (77%) create mode 100644 gps/core/observer/IDataItemObserver.h create mode 100644 gps/core/observer/IDataItemSubscription.h create mode 100644 gps/core/observer/IFrameworkActionReq.h create mode 100644 gps/core/observer/IOsObserver.h create mode 100644 gps/gnss/Agps.cpp create mode 100644 gps/gnss/Agps.h create mode 100644 gps/gnss/Android.mk create mode 100644 gps/gnss/GnssAdapter.cpp create mode 100644 gps/gnss/GnssAdapter.h create mode 100644 gps/gnss/Makefile.am create mode 100644 gps/gnss/XtraSystemStatusObserver.cpp create mode 100644 gps/gnss/XtraSystemStatusObserver.h create mode 100644 gps/gnss/location_gnss.cpp delete mode 100644 gps/gnsspps/Android.mk delete mode 100644 gps/gnsspps/gnsspps.c delete mode 100644 gps/gnsspps/timepps.h create mode 100644 gps/loc-hal.pc.in delete mode 100644 gps/loc_api/Android.mk delete mode 100644 gps/loc_api/libloc_api_50001/Android.mk delete mode 100644 gps/loc_api/libloc_api_50001/LocEngAdapter.cpp delete mode 100644 gps/loc_api/libloc_api_50001/LocEngAdapter.h delete mode 100644 gps/loc_api/libloc_api_50001/gps.c delete mode 100644 gps/loc_api/libloc_api_50001/loc.cpp delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng.cpp delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng.h delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_agps.cpp delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_agps.h delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_msg.h delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_ni.cpp delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_ni.h delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp delete mode 100644 gps/loc_api/libloc_api_50001/loc_eng_xtra.h create mode 100644 gps/location/Android.mk create mode 100644 gps/location/LocationAPI.cpp create mode 100644 gps/location/LocationAPI.h create mode 100644 gps/location/LocationAPIClientBase.cpp create mode 100644 gps/location/LocationAPIClientBase.h create mode 100644 gps/location/Makefile.am create mode 100644 gps/location/location_interface.h create mode 100644 gps/utils/Makefile.am create mode 100644 gps/utils/configure.ac create mode 100644 gps/utils/gps-utils.pc.in rename gps/{core => utils}/gps_extended.h (93%) rename gps/{core => utils}/gps_extended_c.h (78%) create mode 100644 gps/utils/loc_gps.h create mode 100644 gps/utils/loc_nmea.cpp rename gps/{loc_api/libloc_api_50001/loc_eng_nmea.h => utils/loc_nmea.h} (66%) create mode 100644 gps/utils/platform_lib_abstractions/loc_pla/Makefile.am create mode 100644 gps/utils/platform_lib_abstractions/loc_pla/configure.ac delete mode 100644 gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_android_runtime.h create mode 100644 gps/utils/platform_lib_abstractions/loc_pla/loc-pla.pc.in create mode 100644 gps/utils/platform_lib_abstractions/loc_pla/src/Makefile.am delete mode 100644 gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_android_runtime.cpp create mode 100644 gps/utils/platform_lib_abstractions/loc_stub/Makefile.am create mode 100644 gps/utils/platform_lib_abstractions/loc_stub/configure.ac create mode 100644 gps/utils/platform_lib_abstractions/loc_stub/loc-stub.pc.in create mode 100644 gps/utils/platform_lib_abstractions/loc_stub/src/Makefile.am diff --git a/BoardConfig.mk b/BoardConfig.mk index c59e157..4e6f179 100644 --- a/BoardConfig.mk +++ b/BoardConfig.mk @@ -57,6 +57,11 @@ TARGET_USES_64_BIT_BINDER := true # Asserts TARGET_OTA_ASSERT_DEVICE := sanders,sanders_retail +# GPS +TARGET_NO_RPC := true +USE_DEVICE_SPECIFIC_GPS := true +BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE := $(TARGET_BOARD_PLATFORM) + # Init TARGET_INIT_VENDOR_LIB := libinit_sanders TARGET_RECOVERY_DEVICE_MODULES := libinit_sanders diff --git a/device.mk b/device.mk index 35589a6..98d43f8 100644 --- a/device.mk +++ b/device.mk @@ -118,12 +118,12 @@ PRODUCT_COPY_FILES += \ $(LOCAL_PATH)/configs/camera/vfwconfig.json:system/etc/camera/vfwconfig.json PRODUCT_COPY_FILES += \ - $(LOCAL_PATH)/gps/etc/flp.conf:system/etc/flp.conf \ - $(LOCAL_PATH)/gps/etc/gps.conf:system/etc/gps.conf \ - $(LOCAL_PATH)/gps/etc/izat.conf:system/etc/izat.conf \ - $(LOCAL_PATH)/gps/etc/lowi.conf:system/etc/lowi.conf \ - $(LOCAL_PATH)/gps/etc/sap.conf:system/etc/sap.conf \ - $(LOCAL_PATH)/gps/etc/xtwifi.conf:system/etc/xtwifi.conf + $(LOCAL_PATH)/gps/etc/flp.conf:system/vendor/etc/flp.conf \ + $(LOCAL_PATH)/gps/etc/gps.conf:system/vendor/etc/gps.conf \ + $(LOCAL_PATH)/gps/etc/izat.conf:system/vendor/etc/izat.conf \ + $(LOCAL_PATH)/gps/etc/lowi.conf:system/vendor/etc/lowi.conf \ + $(LOCAL_PATH)/gps/etc/sap.conf:system/vendor/etc/sap.conf \ + $(LOCAL_PATH)/gps/etc/xtwifi.conf:system/vendor/etc/xtwifi.conf # LineageActions PRODUCT_PACKAGES += \ @@ -177,9 +177,12 @@ PRODUCT_PACKAGES += \ # GPS PRODUCT_PACKAGES += \ - libgnsspps \ - gps.msm8953 \ - libshims_get_process_name + libgps.utils \ + gps.default \ + libgnss \ + liblocation_api \ + android.hardware.gnss@1.0-impl-qti \ + libloc_api-rpc-qc # HIDL PRODUCT_COPY_FILES += \ diff --git a/gps/Android.mk b/gps/Android.mk index cd83b9f..e2c5a56 100644 --- a/gps/Android.mk +++ b/gps/Android.mk @@ -1,19 +1,5 @@ -# -# Copyright (C) 2017 The LineageOS Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - +ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) LOCAL_PATH := $(call my-dir) -include $(call all-subdir-makefiles,$(LOCAL_PATH)) +include $(call all-makefiles-under,$(LOCAL_PATH)) +endif diff --git a/gps/Makefile.am b/gps/Makefile.am new file mode 100644 index 0000000..f64790e --- /dev/null +++ b/gps/Makefile.am @@ -0,0 +1,10 @@ +# Makefile.am - Automake script for gps loc_api +# + +ACLOCAL_AMFLAGS = -I m4 + +SUBDIRS = core location gnss + +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = loc-hal.pc +EXTRA_DIST = $(pkgconfig_DATA) diff --git a/gps/android/AGnss.cpp b/gps/android/AGnss.cpp new file mode 100644 index 0000000..e76671c --- /dev/null +++ b/gps/android/AGnss.cpp @@ -0,0 +1,185 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "LocSvc_AGnssInterface" + +#include +#include "Gnss.h" +#include "AGnss.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +sp AGnss::sAGnssCbIface = nullptr; + +AGnss::AGnss(Gnss* gnss) : mGnss(gnss) { +} + +void AGnss::agnssStatusIpV4Cb(AGnssExtStatusIpV4 status){ + IAGnssCallback::AGnssStatusIpV4 st = {}; + + switch (status.type) { + case LOC_AGPS_TYPE_SUPL: + st.type = IAGnssCallback::AGnssType::TYPE_SUPL; + break; + case LOC_AGPS_TYPE_C2K: + st.type = IAGnssCallback::AGnssType::TYPE_C2K; + break; + default: + LOC_LOGE("invalid type: %d", status.type); + return; + } + + switch (status.status) { + case LOC_GPS_REQUEST_AGPS_DATA_CONN: + st.status = IAGnssCallback::AGnssStatusValue::REQUEST_AGNSS_DATA_CONN; + break; + case LOC_GPS_RELEASE_AGPS_DATA_CONN: + st.status = IAGnssCallback::AGnssStatusValue::RELEASE_AGNSS_DATA_CONN; + break; + case LOC_GPS_AGPS_DATA_CONNECTED: + st.status = IAGnssCallback::AGnssStatusValue::AGNSS_DATA_CONNECTED; + break; + case LOC_GPS_AGPS_DATA_CONN_DONE: + st.status = IAGnssCallback::AGnssStatusValue::AGNSS_DATA_CONN_DONE; + break; + case LOC_GPS_AGPS_DATA_CONN_FAILED: + st.status = IAGnssCallback::AGnssStatusValue::AGNSS_DATA_CONN_FAILED; + break; + default: + LOC_LOGE("invalid status: %d", status.status); + return; + } + st.ipV4Addr = status.ipV4Addr; + + sAGnssCbIface->agnssStatusIpV4Cb(st); +} + +Return AGnss::setCallback(const sp& callback) { + + if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){ + LOC_LOGE("Null GNSS interface"); + return Void(); + } + + // Save the interface + sAGnssCbIface = callback; + + AgpsCbInfo cbInfo = {}; + cbInfo.statusV4Cb = (void*)agnssStatusIpV4Cb; + cbInfo.cbPriority = AGPS_CB_PRIORITY_LOW; + + mGnss->getGnssInterface()->agpsInit(cbInfo); + return Void(); +} + +Return AGnss::dataConnClosed() { + + if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){ + LOC_LOGE("Null GNSS interface"); + return false; + } + + mGnss->getGnssInterface()->agpsDataConnClosed(LOC_AGPS_TYPE_SUPL); + return true; +} + +Return AGnss::dataConnFailed() { + + if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){ + LOC_LOGE("Null GNSS interface"); + return false; + } + + mGnss->getGnssInterface()->agpsDataConnFailed(LOC_AGPS_TYPE_SUPL); + return true; +} + +Return AGnss::dataConnOpen(const hidl_string& apn, + IAGnss::ApnIpType apnIpType) { + + if(mGnss == nullptr || mGnss->getGnssInterface() == nullptr){ + LOC_LOGE("Null GNSS interface"); + return false; + } + + /* Validate */ + if(apn.empty()){ + LOC_LOGE("Invalid APN"); + return false; + } + + LOC_LOGD("dataConnOpen APN name = [%s]", apn.c_str()); + + AGpsBearerType bearerType; + switch (apnIpType) { + case IAGnss::ApnIpType::IPV4: + bearerType = AGPS_APN_BEARER_IPV4; + break; + case IAGnss::ApnIpType::IPV6: + bearerType = AGPS_APN_BEARER_IPV6; + break; + case IAGnss::ApnIpType::IPV4V6: + bearerType = AGPS_APN_BEARER_IPV4V6; + break; + default: + bearerType = AGPS_APN_BEARER_IPV4; + break; + } + + mGnss->getGnssInterface()->agpsDataConnOpen( + LOC_AGPS_TYPE_SUPL, apn.c_str(), apn.size(), (int)bearerType); + return true; +} + +Return AGnss::setServer(IAGnssCallback::AGnssType type, + const hidl_string& hostname, + int32_t port) { + if (mGnss == nullptr) { + LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); + return false; + } + + GnssConfig config; + memset(&config, 0, sizeof(GnssConfig)); + config.size = sizeof(GnssConfig); + config.flags = GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT; + config.assistanceServer.size = sizeof(GnssConfigSetAssistanceServer); + if (type == IAGnssCallback::AGnssType::TYPE_SUPL) { + config.assistanceServer.type = GNSS_ASSISTANCE_TYPE_SUPL; + } else if (type == IAGnssCallback::AGnssType::TYPE_C2K) { + config.assistanceServer.type = GNSS_ASSISTANCE_TYPE_C2K; + } else { + LOC_LOGE("%s]: invalid AGnssType: %d", __FUNCTION__, static_cast(type)); + return false; + } + config.assistanceServer.hostName = strdup(hostname.c_str()); + config.assistanceServer.port = port; + return mGnss->updateConfiguration(config); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/AGnss.h b/gps/android/AGnss.h new file mode 100644 index 0000000..a3f4a87 --- /dev/null +++ b/gps/android/AGnss.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_HARDWARE_GNSS_V1_1_AGNSS_H +#define ANDROID_HARDWARE_GNSS_V1_1_AGNSS_H + +#include +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::gnss::V1_0::IAGnss; +using ::android::hardware::gnss::V1_0::IAGnssCallback; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; + +struct Gnss; +struct AGnss : public IAGnss { + + AGnss(Gnss* gnss); + ~AGnss() = default; + /* + * Methods from ::android::hardware::gnss::V1_0::IAGnss interface follow. + * These declarations were generated from IAGnss.hal. + */ + Return setCallback(const sp& callback) override; + + Return dataConnClosed() override; + + Return dataConnFailed() override; + + Return dataConnOpen(const hidl_string& apn, + IAGnss::ApnIpType apnIpType) override; + + Return setServer(IAGnssCallback::AGnssType type, + const hidl_string& hostname, int32_t port) override; + + /* Data call setup callback passed down to GNSS HAL implementation */ + static void agnssStatusIpV4Cb(AGnssExtStatusIpV4 status); + + private: + Gnss* mGnss = nullptr; + static sp sAGnssCbIface; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V1_1_AGNSS_H diff --git a/gps/android/AGnssRil.cpp b/gps/android/AGnssRil.cpp new file mode 100644 index 0000000..bd4bb37 --- /dev/null +++ b/gps/android/AGnssRil.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "LocSvc__AGnssRilInterface" + +#include +#include +#include +#include +#include +#include +#include +#include "Gnss.h" +#include "AGnssRil.h" +typedef void* (getLocationInterface)(); + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + + +AGnssRil::AGnssRil(Gnss* gnss) : mGnss(gnss) { + ENTRY_LOG_CALLFLOW(); +} + +AGnssRil::~AGnssRil() { + ENTRY_LOG_CALLFLOW(); +} + +Return AGnssRil::updateNetworkState(bool connected, NetworkType type, bool /*roaming*/) { + ENTRY_LOG_CALLFLOW(); + + // for XTRA + if (nullptr != mGnss && ( nullptr != mGnss->getGnssInterface() )) { + mGnss->getGnssInterface()->updateConnectionStatus(connected, (uint8_t)type); + } + return true; +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/AGnssRil.h b/gps/android/AGnssRil.h new file mode 100644 index 0000000..61216d8 --- /dev/null +++ b/gps/android/AGnssRil.h @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_HARDWARE_GNSS_V1_0_AGNSSRIL_H_ +#define ANDROID_HARDWARE_GNSS_V1_0_AGNSSRIL_H_ + +#include +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::gnss::V1_0::IAGnssRil; +using ::android::hardware::gnss::V1_0::IAGnssRilCallback; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; + +struct Gnss; +/* + * Extended interface for AGNSS RIL support. An Assisted GNSS Radio Interface Layer interface + * allows the GNSS chipset to request radio interface layer information from Android platform. + * Examples of such information are reference location, unique subscriber ID, phone number string + * and network availability changes. Also contains wrapper methods to allow methods from + * IAGnssiRilCallback interface to be passed into the conventional implementation of the GNSS HAL. + */ +struct AGnssRil : public IAGnssRil { + AGnssRil(Gnss* gnss); + ~AGnssRil(); + + /* + * Methods from ::android::hardware::gnss::V1_0::IAGnssRil follow. + * These declarations were generated from IAGnssRil.hal. + */ + Return setCallback(const sp& /*callback*/) override { + return Void(); + } + Return setRefLocation(const IAGnssRil::AGnssRefLocation& /*agnssReflocation*/) override { + return Void(); + } + Return setSetId(IAGnssRil::SetIDType /*type*/, const hidl_string& /*setid*/) override { + return false; + } + Return updateNetworkAvailability(bool /*available*/, + const hidl_string& /*apn*/) override { + return false; + } + Return updateNetworkState(bool connected, NetworkType type, bool roaming) override; + + private: + Gnss* mGnss = nullptr; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V1_0_AGNSSRIL_H_ diff --git a/gps/android/Android.mk b/gps/android/Android.mk new file mode 100644 index 0000000..03ea1f3 --- /dev/null +++ b/gps/android/Android.mk @@ -0,0 +1,92 @@ +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) +LOCAL_MODULE := android.hardware.gnss@1.0-impl-qti +LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib +LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64 +LOCAL_MODULE_RELATIVE_PATH := hw +LOCAL_SRC_FILES := \ + AGnss.cpp \ + Gnss.cpp \ + GnssBatching.cpp \ + GnssGeofencing.cpp \ + GnssMeasurement.cpp \ + GnssNi.cpp \ + GnssConfiguration.cpp \ + GnssDebug.cpp \ + AGnssRil.cpp + +LOCAL_SRC_FILES += \ + location_api/LocationUtil.cpp \ + location_api/GnssAPIClient.cpp \ + location_api/GeofenceAPIClient.cpp \ + location_api/BatchingAPIClient.cpp \ + location_api/MeasurementAPIClient.cpp \ + +LOCAL_C_INCLUDES:= \ + $(LOCAL_PATH)/location_api +LOCAL_HEADER_LIBRARIES := \ + libgps.utils_headers \ + libloc_core_headers \ + libloc_pla_headers \ + liblocation_api_headers + +LOCAL_SHARED_LIBRARIES := \ + liblog \ + libhidlbase \ + libhidltransport \ + libhwbinder \ + libutils \ + android.hardware.gnss@1.0 \ + +LOCAL_SHARED_LIBRARIES += \ + libloc_core \ + libgps.utils \ + libdl \ + libloc_pla \ + liblocation_api \ + +LOCAL_CFLAGS += $(GNSS_CFLAGS) +include $(BUILD_SHARED_LIBRARY) + +BUILD_GNSS_HIDL_SERVICE := true +ifneq ($(BOARD_VENDOR_QCOM_LOC_PDK_FEATURE_SET), true) +ifneq ($(LW_FEATURE_SET),true) +BUILD_GNSS_HIDL_SERVICE := false +endif # LW_FEATURE_SET +endif # BOARD_VENDOR_QCOM_LOC_PDK_FEATURE_SET + +ifeq ($(BUILD_GNSS_HIDL_SERVICE), true) +include $(CLEAR_VARS) +LOCAL_MODULE := android.hardware.gnss@1.0-service-qti +LOCAL_MODULE_PATH := $(TARGET_OUT_VENDOR_EXECUTABLES) +LOCAL_MODULE_RELATIVE_PATH := hw +LOCAL_INIT_RC := android.hardware.gnss@1.0-service-qti.rc +LOCAL_SRC_FILES := \ + service.cpp \ + +LOCAL_C_INCLUDES:= \ + $(LOCAL_PATH)/location_api +LOCAL_HEADER_LIBRARIES := \ + libgps.utils_headers \ + libloc_core_headers \ + libloc_pla_headers \ + liblocation_api_headers + + +LOCAL_SHARED_LIBRARIES := \ + liblog \ + libcutils \ + libdl \ + libbase \ + libutils \ + +LOCAL_SHARED_LIBRARIES += \ + libhwbinder \ + libhidlbase \ + libhidltransport \ + android.hardware.gnss@1.0 \ + +LOCAL_CFLAGS += $(GNSS_CFLAGS) +include $(BUILD_EXECUTABLE) +endif # BUILD_GNSS_HIDL_SERVICE diff --git a/gps/android/Gnss.cpp b/gps/android/Gnss.cpp new file mode 100644 index 0000000..e3fd64e --- /dev/null +++ b/gps/android/Gnss.cpp @@ -0,0 +1,338 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "LocSvc_GnssInterface" + +#include +#include +#include "Gnss.h" +typedef void* (getLocationInterface)(); + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +void Gnss::GnssDeathRecipient::serviceDied(uint64_t cookie, const wp& who) { + LOC_LOGE("%s] service died. cookie: %llu, who: %p", + __FUNCTION__, static_cast(cookie), &who); + if (mGnss != nullptr) { + mGnss->stop(); + mGnss->cleanup(); + } +} + +Gnss::Gnss() { + ENTRY_LOG_CALLFLOW(); + // clear pending GnssConfig + memset(&mPendingConfig, 0, sizeof(GnssConfig)); + + mGnssDeathRecipient = new GnssDeathRecipient(this); +} + +Gnss::~Gnss() { + ENTRY_LOG_CALLFLOW(); + if (mApi != nullptr) { + delete mApi; + mApi = nullptr; + } +} + +GnssAPIClient* Gnss::getApi() { + if (mApi == nullptr && (mGnssCbIface != nullptr || mGnssNiCbIface != nullptr)) { + mApi = new GnssAPIClient(mGnssCbIface, mGnssNiCbIface); + if (mApi == nullptr) { + LOC_LOGE("%s] faild to create GnssAPIClient", __FUNCTION__); + return mApi; + } + + if (mPendingConfig.size == sizeof(GnssConfig)) { + // we have pending GnssConfig + mApi->gnssConfigurationUpdate(mPendingConfig); + // clear size to invalid mPendingConfig + mPendingConfig.size = 0; + if (mPendingConfig.assistanceServer.hostName != nullptr) { + free((void*)mPendingConfig.assistanceServer.hostName); + } + } + } + if (mApi == nullptr) { + LOC_LOGW("%s] GnssAPIClient is not ready", __FUNCTION__); + } + return mApi; +} + +GnssInterface* Gnss::getGnssInterface() { + static bool getGnssInterfaceFailed = false; + if (nullptr == mGnssInterface && !getGnssInterfaceFailed) { + LOC_LOGD("%s]: loading libgnss.so::getGnssInterface ...", __func__); + getLocationInterface* getter = NULL; + const char *error = NULL; + dlerror(); + void *handle = dlopen("libgnss.so", RTLD_NOW); + if (NULL == handle || (error = dlerror()) != NULL) { + LOC_LOGW("dlopen for libgnss.so failed, error = %s", error); + } else { + getter = (getLocationInterface*)dlsym(handle, "getGnssInterface"); + if ((error = dlerror()) != NULL) { + LOC_LOGW("dlsym for libgnss.so::getGnssInterface failed, error = %s", error); + getter = NULL; + } + } + + if (NULL == getter) { + getGnssInterfaceFailed = true; + } else { + mGnssInterface = (GnssInterface*)(*getter)(); + } + } + return mGnssInterface; +} + +Return Gnss::setCallback(const sp& callback) { + ENTRY_LOG_CALLFLOW(); + if (mGnssCbIface != nullptr) { + mGnssCbIface->unlinkToDeath(mGnssDeathRecipient); + } + mGnssCbIface = callback; + if (mGnssCbIface != nullptr) { + mGnssCbIface->linkToDeath(mGnssDeathRecipient, 0 /*cookie*/); + } + + GnssAPIClient* api = getApi(); + if (api != nullptr) { + api->gnssUpdateCallbacks(mGnssCbIface, mGnssNiCbIface); + api->gnssEnable(LOCATION_TECHNOLOGY_TYPE_GNSS); + api->requestCapabilities(); + } + return true; +} + +Return Gnss::setGnssNiCb(const sp& callback) { + ENTRY_LOG_CALLFLOW(); + mGnssNiCbIface = callback; + GnssAPIClient* api = getApi(); + if (api != nullptr) { + api->gnssUpdateCallbacks(mGnssCbIface, mGnssNiCbIface); + } + return true; +} + +Return Gnss::updateConfiguration(GnssConfig& gnssConfig) { + ENTRY_LOG_CALLFLOW(); + GnssAPIClient* api = getApi(); + if (api) { + api->gnssConfigurationUpdate(gnssConfig); + } else if (gnssConfig.flags != 0) { + // api is not ready yet, update mPendingConfig with gnssConfig + mPendingConfig.size = sizeof(GnssConfig); + + if (gnssConfig.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) { + mPendingConfig.flags |= GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT; + mPendingConfig.gpsLock = gnssConfig.gpsLock; + } + if (gnssConfig.flags & GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) { + mPendingConfig.flags |= GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT; + mPendingConfig.suplVersion = gnssConfig.suplVersion; + } + if (gnssConfig.flags & GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) { + mPendingConfig.flags |= GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT; + mPendingConfig.assistanceServer.size = sizeof(GnssConfigSetAssistanceServer); + mPendingConfig.assistanceServer.type = gnssConfig.assistanceServer.type; + if (mPendingConfig.assistanceServer.hostName != nullptr) { + free((void*)mPendingConfig.assistanceServer.hostName); + mPendingConfig.assistanceServer.hostName = + strdup(gnssConfig.assistanceServer.hostName); + } + mPendingConfig.assistanceServer.port = gnssConfig.assistanceServer.port; + } + if (gnssConfig.flags & GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) { + mPendingConfig.flags |= GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT; + mPendingConfig.lppProfile = gnssConfig.lppProfile; + } + if (gnssConfig.flags & GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) { + mPendingConfig.flags |= GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT; + mPendingConfig.lppeControlPlaneMask = gnssConfig.lppeControlPlaneMask; + } + if (gnssConfig.flags & GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) { + mPendingConfig.flags |= GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT; + mPendingConfig.lppeUserPlaneMask = gnssConfig.lppeUserPlaneMask; + } + if (gnssConfig.flags & GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) { + mPendingConfig.flags |= GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT; + mPendingConfig.aGlonassPositionProtocolMask = gnssConfig.aGlonassPositionProtocolMask; + } + if (gnssConfig.flags & GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT) { + mPendingConfig.flags |= GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT; + mPendingConfig.emergencyPdnForEmergencySupl = gnssConfig.emergencyPdnForEmergencySupl; + } + if (gnssConfig.flags & GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT) { + mPendingConfig.flags |= GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT; + mPendingConfig.suplEmergencyServices = gnssConfig.suplEmergencyServices; + } + if (gnssConfig.flags & GNSS_CONFIG_FLAGS_SUPL_MODE_BIT) { + mPendingConfig.flags |= GNSS_CONFIG_FLAGS_SUPL_MODE_BIT; + mPendingConfig.suplModeMask = gnssConfig.suplModeMask; + } + } + return true; +} + +Return Gnss::start() { + ENTRY_LOG_CALLFLOW(); + bool retVal = false; + GnssAPIClient* api = getApi(); + if (api) { + retVal = api->gnssStart(); + } + return retVal; +} + +Return Gnss::stop() { + ENTRY_LOG_CALLFLOW(); + bool retVal = false; + GnssAPIClient* api = getApi(); + if (api) { + retVal = api->gnssStop(); + } + return retVal; +} + +Return Gnss::cleanup() { + ENTRY_LOG_CALLFLOW(); + + if (mApi != nullptr) { + mApi->gnssDisable(); + } + + return Void(); +} + +Return Gnss::injectLocation(double latitudeDegrees, + double longitudeDegrees, + float accuracyMeters) { + ENTRY_LOG_CALLFLOW(); + GnssInterface* gnssInterface = getGnssInterface(); + if (nullptr != gnssInterface) { + gnssInterface->injectLocation(latitudeDegrees, longitudeDegrees, accuracyMeters); + return true; + } else { + return false; + } +} + +Return Gnss::injectTime(int64_t timeMs, int64_t timeReferenceMs, + int32_t uncertaintyMs) { + ENTRY_LOG_CALLFLOW(); + GnssInterface* gnssInterface = getGnssInterface(); + if (nullptr != gnssInterface) { + gnssInterface->injectTime(timeMs, timeReferenceMs, uncertaintyMs); + return true; + } else { + return false; + } +} + +Return Gnss::deleteAidingData(IGnss::GnssAidingData aidingDataFlags) { + ENTRY_LOG_CALLFLOW(); + GnssAPIClient* api = getApi(); + if (api) { + api->gnssDeleteAidingData(aidingDataFlags); + } + return Void(); +} + +Return Gnss::setPositionMode(IGnss::GnssPositionMode mode, + IGnss::GnssPositionRecurrence recurrence, + uint32_t minIntervalMs, + uint32_t preferredAccuracyMeters, + uint32_t preferredTimeMs) { + ENTRY_LOG_CALLFLOW(); + bool retVal = false; + GnssAPIClient* api = getApi(); + if (api) { + retVal = api->gnssSetPositionMode(mode, recurrence, minIntervalMs, + preferredAccuracyMeters, preferredTimeMs); + } + return retVal; +} + +Return> Gnss::getExtensionAGnss() { + ENTRY_LOG_CALLFLOW(); + mAGnssIface = new AGnss(this); + return mAGnssIface; +} + +Return> Gnss::getExtensionGnssNi() { + ENTRY_LOG_CALLFLOW(); + mGnssNi = new GnssNi(this); + return mGnssNi; +} + +Return> Gnss::getExtensionGnssMeasurement() { + ENTRY_LOG_CALLFLOW(); + mGnssMeasurement = new GnssMeasurement(); + return mGnssMeasurement; +} + +Return> Gnss::getExtensionGnssConfiguration() { + ENTRY_LOG_CALLFLOW(); + mGnssConfig = new GnssConfiguration(this); + return mGnssConfig; +} + +Return> Gnss::getExtensionGnssGeofencing() { + ENTRY_LOG_CALLFLOW(); + mGnssGeofencingIface = new GnssGeofencing(); + return mGnssGeofencingIface; +} + +Return> Gnss::getExtensionGnssBatching() { + mGnssBatching = new GnssBatching(); + return mGnssBatching; +} + +Return> Gnss::getExtensionGnssDebug() { + ENTRY_LOG_CALLFLOW(); + mGnssDebug = new GnssDebug(this); + return mGnssDebug; +} + +Return> Gnss::getExtensionAGnssRil() { + mGnssRil = new AGnssRil(this); + return mGnssRil; +} + +IGnss* HIDL_FETCH_IGnss(const char* hal) { + ENTRY_LOG_CALLFLOW(); + IGnss* iface = nullptr; + iface = new Gnss(); + if (iface == nullptr) { + LOC_LOGE("%s]: failed to get %s", __FUNCTION__, hal); + } + return iface; +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/Gnss.h b/gps/android/Gnss.h new file mode 100644 index 0000000..e4589d6 --- /dev/null +++ b/gps/android/Gnss.h @@ -0,0 +1,149 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSS_H +#define ANDROID_HARDWARE_GNSS_V1_1_GNSS_H + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; + +struct Gnss : public IGnss { + Gnss(); + ~Gnss(); + + // registerAsService will call interfaceChain to determine the version of service + /* comment this out until we know really how to manipulate hidl version + using interfaceChain_cb = std::function< + void(const ::android::hardware::hidl_vec<::android::hardware::hidl_string>& descriptors)>; + virtual ::android::hardware::Return interfaceChain(interfaceChain_cb _hidl_cb) override { + _hidl_cb({ + "android.hardware.gnss@1.1::IGnss", + ::android::hidl::base::V1_0::IBase::descriptor, + }); + return ::android::hardware::Void(); + } + */ + + /* + * Methods from ::android::hardware::gnss::V1_0::IGnss follow. + * These declarations were generated from Gnss.hal. + */ + Return setCallback(const sp& callback) override; + Return start() override; + Return stop() override; + Return cleanup() override; + Return injectLocation(double latitudeDegrees, + double longitudeDegrees, + float accuracyMeters) override; + Return injectTime(int64_t timeMs, + int64_t timeReferenceMs, + int32_t uncertaintyMs) override; + Return deleteAidingData(IGnss::GnssAidingData aidingDataFlags) override; + Return setPositionMode(IGnss::GnssPositionMode mode, + IGnss::GnssPositionRecurrence recurrence, + uint32_t minIntervalMs, + uint32_t preferredAccuracyMeters, + uint32_t preferredTimeMs) override; + Return> getExtensionAGnss() override; + Return> getExtensionGnssNi() override; + Return> getExtensionGnssMeasurement() override; + Return> getExtensionGnssConfiguration() override; + Return> getExtensionGnssGeofencing() override; + Return> getExtensionGnssBatching() override; + + Return> getExtensionAGnssRil() override; + + inline Return> getExtensionGnssNavigationMessage() override { + return nullptr; + } + + inline Return> getExtensionXtra() override { + return nullptr; + } + + Return> getExtensionGnssDebug() override; + + // These methods are not part of the IGnss base class. + GnssAPIClient* getApi(); + Return setGnssNiCb(const sp& niCb); + Return updateConfiguration(GnssConfig& gnssConfig); + GnssInterface* getGnssInterface(); + + private: + struct GnssDeathRecipient : hidl_death_recipient { + GnssDeathRecipient(sp gnss) : mGnss(gnss) { + } + ~GnssDeathRecipient() = default; + virtual void serviceDied(uint64_t cookie, const wp& who) override; + sp mGnss; + }; + + private: + sp mGnssDeathRecipient = nullptr; + + sp mAGnssIface = nullptr; + sp mGnssNi = nullptr; + sp mGnssMeasurement = nullptr; + sp mGnssConfig = nullptr; + sp mGnssGeofencingIface = nullptr; + sp mGnssBatching = nullptr; + sp mGnssDebug = nullptr; + sp mGnssRil = nullptr; + + GnssAPIClient* mApi = nullptr; + sp mGnssCbIface = nullptr; + sp mGnssNiCbIface = nullptr; + GnssConfig mPendingConfig; + GnssInterface* mGnssInterface = nullptr; +}; + +extern "C" IGnss* HIDL_FETCH_IGnss(const char* name); + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSS_H diff --git a/gps/android/GnssBatching.cpp b/gps/android/GnssBatching.cpp new file mode 100644 index 0000000..6ffadc9 --- /dev/null +++ b/gps/android/GnssBatching.cpp @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "LocSvc_GnssBatchingInterface" + +#include +#include +#include "GnssBatching.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +void GnssBatching::GnssBatchingDeathRecipient::serviceDied( + uint64_t cookie, const wp& who) { + LOC_LOGE("%s] service died. cookie: %llu, who: %p", + __FUNCTION__, static_cast(cookie), &who); + if (mGnssBatching != nullptr) { + mGnssBatching->stop(); + mGnssBatching->cleanup(); + } +} + +GnssBatching::GnssBatching() : mApi(nullptr) { + mGnssBatchingDeathRecipient = new GnssBatchingDeathRecipient(this); +} + +GnssBatching::~GnssBatching() { + if (mApi != nullptr) { + delete mApi; + mApi = nullptr; + } +} + + +// Methods from ::android::hardware::gnss::V1_0::IGnssBatching follow. +Return GnssBatching::init(const sp& callback) { + if (mApi != nullptr) { + LOC_LOGD("%s]: mApi is NOT nullptr, delete it first", __FUNCTION__); + delete mApi; + mApi = nullptr; + } + + mApi = new BatchingAPIClient(callback); + if (mApi == nullptr) { + LOC_LOGE("%s]: failed to create mApi", __FUNCTION__); + return false; + } + + if (mGnssBatchingCbIface != nullptr) { + mGnssBatchingCbIface->unlinkToDeath(mGnssBatchingDeathRecipient); + } + mGnssBatchingCbIface = callback; + if (mGnssBatchingCbIface != nullptr) { + mGnssBatchingCbIface->linkToDeath(mGnssBatchingDeathRecipient, 0 /*cookie*/); + } + + return true; +} + +Return GnssBatching::getBatchSize() { + uint16_t ret = 0; + if (mApi == nullptr) { + LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__); + } else { + ret = mApi->getBatchSize(); + } + return ret; +} + +Return GnssBatching::start(const IGnssBatching::Options& options) { + bool ret = false; + if (mApi == nullptr) { + LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__); + } else { + ret = mApi->startSession(options); + } + return ret; +} + +Return GnssBatching::flush() { + if (mApi == nullptr) { + LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__); + } else { + mApi->flushBatchedLocations(); + } + return Void(); +} + +Return GnssBatching::stop() { + bool ret = false; + if (mApi == nullptr) { + LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__); + } else { + ret = mApi->stopSession(); + } + return ret; +} + +Return GnssBatching::cleanup() { + if (mGnssBatchingCbIface != nullptr) { + mGnssBatchingCbIface->unlinkToDeath(mGnssBatchingDeathRecipient); + } + return Void(); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/GnssBatching.h b/gps/android/GnssBatching.h new file mode 100644 index 0000000..de5d5c3 --- /dev/null +++ b/gps/android/GnssBatching.h @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSSBATCHING_H +#define ANDROID_HARDWARE_GNSS_V1_1_GNSSBATCHING_H + +#include +#include + + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::gnss::V1_0::IGnssBatching; +using ::android::hardware::gnss::V1_0::IGnssBatchingCallback; +using ::android::hidl::base::V1_0::IBase; +using ::android::hardware::hidl_array; +using ::android::hardware::hidl_memory; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::sp; + +class BatchingAPIClient; +struct GnssBatching : public IGnssBatching { + GnssBatching(); + ~GnssBatching(); + + // Methods from ::android::hardware::gnss::V1_0::IGnssBatching follow. + Return init(const sp& callback) override; + Return getBatchSize() override; + Return start(const IGnssBatching::Options& options ) override; + Return flush() override; + Return stop() override; + Return cleanup() override; + + private: + struct GnssBatchingDeathRecipient : hidl_death_recipient { + GnssBatchingDeathRecipient(sp gnssBatching) : + mGnssBatching(gnssBatching) { + } + ~GnssBatchingDeathRecipient() = default; + virtual void serviceDied(uint64_t cookie, const wp& who) override; + sp mGnssBatching; + }; + + private: + sp mGnssBatchingDeathRecipient = nullptr; + sp mGnssBatchingCbIface = nullptr; + BatchingAPIClient* mApi = nullptr; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSBATCHING_H diff --git a/gps/android/GnssConfiguration.cpp b/gps/android/GnssConfiguration.cpp new file mode 100644 index 0000000..51ee892 --- /dev/null +++ b/gps/android/GnssConfiguration.cpp @@ -0,0 +1,227 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "LocSvc_GnssConfigurationInterface" + +#include +#include "Gnss.h" +#include "GnssConfiguration.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +GnssConfiguration::GnssConfiguration(Gnss* gnss) : mGnss(gnss) { +} + +// Methods from ::android::hardware::gps::V1_0::IGnssConfiguration follow. +Return GnssConfiguration::setSuplEs(bool enabled) { + if (mGnss == nullptr) { + LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); + return false; + } + + GnssConfig config; + memset(&config, 0, sizeof(GnssConfig)); + config.size = sizeof(GnssConfig); + config.flags = GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT; + config.suplEmergencyServices = (enabled ? + GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES : + GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO); + + return mGnss->updateConfiguration(config); +} + +Return GnssConfiguration::setSuplVersion(uint32_t version) { + if (mGnss == nullptr) { + LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); + return false; + } + + GnssConfig config; + memset(&config, 0, sizeof(GnssConfig)); + config.size = sizeof(GnssConfig); + config.flags = GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT; + switch (version) { + case 0x00020002: + config.suplVersion = GNSS_CONFIG_SUPL_VERSION_2_0_2; + break; + case 0x00020000: + config.suplVersion = GNSS_CONFIG_SUPL_VERSION_2_0_0; + break; + case 0x00010000: + config.suplVersion = GNSS_CONFIG_SUPL_VERSION_1_0_0; + break; + default: + LOC_LOGE("%s]: invalid version: 0x%x.", __FUNCTION__, version); + return false; + break; + } + + return mGnss->updateConfiguration(config); +} + +Return GnssConfiguration::setSuplMode(uint8_t mode) { + if (mGnss == nullptr) { + LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); + return false; + } + + GnssConfig config; + memset(&config, 0, sizeof(GnssConfig)); + config.size = sizeof(GnssConfig); + config.flags = GNSS_CONFIG_FLAGS_SUPL_MODE_BIT; + switch (mode) { + case 0: + config.suplModeMask = 0; // STANDALONE ONLY + break; + case 1: + config.suplModeMask = GNSS_CONFIG_SUPL_MODE_MSB_BIT; + break; + case 2: + config.suplModeMask = GNSS_CONFIG_SUPL_MODE_MSA_BIT; + break; + case 3: + config.suplModeMask = GNSS_CONFIG_SUPL_MODE_MSB_BIT | GNSS_CONFIG_SUPL_MODE_MSA_BIT; + break; + default: + LOC_LOGE("%s]: invalid mode: %d.", __FUNCTION__, mode); + return false; + break; + } + + return mGnss->updateConfiguration(config); +} + +Return GnssConfiguration::setLppProfile(uint8_t lppProfile) { + if (mGnss == nullptr) { + LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); + return false; + } + + GnssConfig config; + memset(&config, 0, sizeof(GnssConfig)); + config.size = sizeof(GnssConfig); + config.flags = GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT; + switch (lppProfile) { + case 0: + config.lppProfile = GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE; + break; + case 1: + config.lppProfile = GNSS_CONFIG_LPP_PROFILE_USER_PLANE; + break; + case 2: + config.lppProfile = GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE; + break; + case 3: + config.lppProfile = GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE; + break; + default: + LOC_LOGE("%s]: invalid lppProfile: %d.", __FUNCTION__, lppProfile); + return false; + break; + } + + return mGnss->updateConfiguration(config); +} + +Return GnssConfiguration::setGlonassPositioningProtocol(uint8_t protocol) { + if (mGnss == nullptr) { + LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); + return false; + } + + GnssConfig config; + memset(&config, 0, sizeof(GnssConfig)); + config.size = sizeof(GnssConfig); + + config.flags = GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT; + if (protocol & (1<<0)) { + config.aGlonassPositionProtocolMask |= GNSS_CONFIG_RRC_CONTROL_PLANE_BIT; + } + if (protocol & (1<<1)) { + config.aGlonassPositionProtocolMask |= GNSS_CONFIG_RRLP_USER_PLANE_BIT; + } + if (protocol & (1<<2)) { + config.aGlonassPositionProtocolMask |= GNSS_CONFIG_LLP_USER_PLANE_BIT; + } + if (protocol & (1<<3)) { + config.aGlonassPositionProtocolMask |= GNSS_CONFIG_LLP_CONTROL_PLANE_BIT; + } + + return mGnss->updateConfiguration(config); +} + +Return GnssConfiguration::setGpsLock(uint8_t lock) { + if (mGnss == nullptr) { + LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); + return false; + } + + GnssConfig config; + memset(&config, 0, sizeof(GnssConfig)); + config.size = sizeof(GnssConfig); + config.flags = GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT; + switch (lock) { + case 0: + config.gpsLock = GNSS_CONFIG_GPS_LOCK_NONE; + break; + case 1: + config.gpsLock = GNSS_CONFIG_GPS_LOCK_MO; + break; + case 2: + config.gpsLock = GNSS_CONFIG_GPS_LOCK_NI; + break; + case 3: + config.gpsLock = GNSS_CONFIG_GPS_LOCK_MO_AND_NI; + break; + default: + LOC_LOGE("%s]: invalid lock: %d.", __FUNCTION__, lock); + return false; + break; + } + + return mGnss->updateConfiguration(config); +} + +Return GnssConfiguration::setEmergencySuplPdn(bool enabled) { + if (mGnss == nullptr) { + LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); + return false; + } + + GnssConfig config; + memset(&config, 0, sizeof(GnssConfig)); + config.size = sizeof(GnssConfig); + config.flags = GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT; + config.emergencyPdnForEmergencySupl = (enabled ? + GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES : + GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO); + + return mGnss->updateConfiguration(config); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/GnssConfiguration.h b/gps/android/GnssConfiguration.h new file mode 100644 index 0000000..f9ea423 --- /dev/null +++ b/gps/android/GnssConfiguration.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ + + /* Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSSCONFIGURATION_H +#define ANDROID_HARDWARE_GNSS_V1_1_GNSSCONFIGURATION_H + +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::gnss::V1_0::IGnssConfiguration; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; + +/* + * Interface for passing GNSS configuration info from platform to HAL. + */ +struct Gnss; +struct GnssConfiguration : public IGnssConfiguration { + GnssConfiguration(Gnss* gnss); + ~GnssConfiguration() = default; + + /* + * Methods from ::android::hardware::gnss::V1_0::IGnssConfiguration follow. + * These declarations were generated from IGnssConfiguration.hal. + */ + Return setSuplVersion(uint32_t version) override; + Return setSuplMode(uint8_t mode) override; + Return setSuplEs(bool enabled) override; + Return setLppProfile(uint8_t lppProfile) override; + Return setGlonassPositioningProtocol(uint8_t protocol) override; + Return setEmergencySuplPdn(bool enable) override; + Return setGpsLock(uint8_t lock) override; + + private: + Gnss* mGnss = nullptr; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSCONFIGURATION_H diff --git a/gps/android/GnssDebug.cpp b/gps/android/GnssDebug.cpp new file mode 100644 index 0000000..ff467d3 --- /dev/null +++ b/gps/android/GnssDebug.cpp @@ -0,0 +1,143 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "LocSvc_GnssDebugInterface" + +#include +#include +#include "Gnss.h" +#include "GnssDebug.h" +#include "LocationUtil.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::hidl_vec; + +#define GNSS_DEBUG_UNKNOWN_UTC_TIME (1483228800000ULL) // 1/1/2017 00:00 GMT +#define GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC (1.57783680E17) // 5 years in ns + +GnssDebug::GnssDebug(Gnss* gnss) : mGnss(gnss) +{ +} + +/* + * This methods requests position, time and satellite ephemeris debug information + * from the HAL. + * + * @return void +*/ +Return GnssDebug::getDebugData(getDebugData_cb _hidl_cb) +{ + LOC_LOGD("%s]: ", __func__); + + DebugData data = { }; + + if((nullptr == mGnss) || (nullptr == mGnss->getGnssInterface())){ + LOC_LOGE("GnssDebug - Null GNSS interface"); + _hidl_cb(data); + return Void(); + } + + // get debug report snapshot via hal interface + GnssDebugReport reports = { }; + mGnss->getGnssInterface()->getDebugReport(reports); + + // location block + if (reports.mLocation.mValid) { + data.position.valid = true; + data.position.latitudeDegrees = reports.mLocation.mLocation.latitude; + data.position.longitudeDegrees = reports.mLocation.mLocation.longitude; + data.position.altitudeMeters = reports.mLocation.mLocation.altitude; + + data.position.speedMetersPerSec = + (double)(reports.mLocation.mLocation.speed); + data.position.bearingDegrees = + (double)(reports.mLocation.mLocation.bearing); + data.position.horizontalAccuracyMeters = + (double)(reports.mLocation.mLocation.accuracy); + data.position.verticalAccuracyMeters = + reports.mLocation.verticalAccuracyMeters; + data.position.speedAccuracyMetersPerSecond = + reports.mLocation.speedAccuracyMetersPerSecond; + data.position.bearingAccuracyDegrees = + reports.mLocation.bearingAccuracyDegrees; + + timeval tv_now, tv_report; + tv_report.tv_sec = reports.mLocation.mUtcReported.tv_sec; + tv_report.tv_usec = reports.mLocation.mUtcReported.tv_nsec / 1000ULL; + gettimeofday(&tv_now, NULL); + data.position.ageSeconds = + (tv_now.tv_sec - tv_report.tv_sec) + + (float)((tv_now.tv_usec - tv_report.tv_usec)) / 1000000; + } + else { + data.position.valid = false; + } + + // time block + if (reports.mTime.mValid) { + data.time.timeEstimate = reports.mTime.timeEstimate; + data.time.timeUncertaintyNs = reports.mTime.timeUncertaintyNs; + data.time.frequencyUncertaintyNsPerSec = + reports.mTime.frequencyUncertaintyNsPerSec; + } + else { + data.time.timeEstimate = GNSS_DEBUG_UNKNOWN_UTC_TIME; + data.time.timeUncertaintyNs = (float)(GNSS_DEBUG_UNKNOWN_UTC_TIME_UNC); + data.time.frequencyUncertaintyNsPerSec = 0; + } + + // satellite data block + SatelliteData s = { }; + std::vector s_array = { }; + + for (uint32_t i=0; i +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::gnss::V1_0::IGnssDebug; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; + +/* Interface for GNSS Debug support. */ +struct Gnss; +struct GnssDebug : public IGnssDebug { + GnssDebug(Gnss* gnss); + ~GnssDebug() {}; + + /* + * Methods from ::android::hardware::gnss::V1_0::IGnssDebug follow. + * These declarations were generated from IGnssDebug.hal. + */ + Return getDebugData(getDebugData_cb _hidl_cb) override; + +private: + Gnss* mGnss = nullptr; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSDEBUG_H diff --git a/gps/android/GnssGeofencing.cpp b/gps/android/GnssGeofencing.cpp new file mode 100644 index 0000000..035a092 --- /dev/null +++ b/gps/android/GnssGeofencing.cpp @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "GnssHal_GnssGeofencing" + +#include +#include +#include "GnssGeofencing.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +void GnssGeofencing::GnssGeofencingDeathRecipient::serviceDied( + uint64_t cookie, const wp& who) { + LOC_LOGE("%s] service died. cookie: %llu, who: %p", + __FUNCTION__, static_cast(cookie), &who); + if (mGnssGeofencing != nullptr) { + mGnssGeofencing->removeAllGeofences(); + } +} + +GnssGeofencing::GnssGeofencing() : mApi(nullptr) { + mGnssGeofencingDeathRecipient = new GnssGeofencingDeathRecipient(this); +} + +GnssGeofencing::~GnssGeofencing() { + if (mApi != nullptr) { + delete mApi; + mApi = nullptr; + } +} + +// Methods from ::android::hardware::gnss::V1_0::IGnssGeofencing follow. +Return GnssGeofencing::setCallback(const sp& callback) { + if (mApi != nullptr) { + LOC_LOGE("%s]: mApi is NOT nullptr", __FUNCTION__); + return Void(); + } + + mApi = new GeofenceAPIClient(callback); + if (mApi == nullptr) { + LOC_LOGE("%s]: failed to create mApi", __FUNCTION__); + } + + if (mGnssGeofencingCbIface != nullptr) { + mGnssGeofencingCbIface->unlinkToDeath(mGnssGeofencingDeathRecipient); + } + mGnssGeofencingCbIface = callback; + if (mGnssGeofencingCbIface != nullptr) { + mGnssGeofencingCbIface->linkToDeath(mGnssGeofencingDeathRecipient, 0 /*cookie*/); + } + + return Void(); +} + +Return GnssGeofencing::addGeofence( + int32_t geofenceId, + double latitudeDegrees, + double longitudeDegrees, + double radiusMeters, + IGnssGeofenceCallback::GeofenceTransition lastTransition, + int32_t monitorTransitions, + uint32_t notificationResponsivenessMs, + uint32_t unknownTimerMs) { + if (mApi == nullptr) { + LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__); + } else { + mApi->geofenceAdd( + geofenceId, + latitudeDegrees, + longitudeDegrees, + radiusMeters, + static_cast(lastTransition), + monitorTransitions, + notificationResponsivenessMs, + unknownTimerMs); + } + return Void(); +} + +Return GnssGeofencing::pauseGeofence(int32_t geofenceId) { + if (mApi == nullptr) { + LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__); + } else { + mApi->geofencePause(geofenceId); + } + return Void(); +} + +Return GnssGeofencing::resumeGeofence(int32_t geofenceId, int32_t monitorTransitions) { + if (mApi == nullptr) { + LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__); + } else { + mApi->geofenceResume(geofenceId, monitorTransitions); + } + return Void(); +} + +Return GnssGeofencing::removeGeofence(int32_t geofenceId) { + if (mApi == nullptr) { + LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__); + } else { + mApi->geofenceRemove(geofenceId); + } + return Void(); +} + +Return GnssGeofencing::removeAllGeofences() { + if (mApi == nullptr) { + LOC_LOGD("%s]: mApi is nullptr, do nothing", __FUNCTION__); + } else { + mApi->geofenceRemoveAll(); + } + return Void(); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/GnssGeofencing.h b/gps/android/GnssGeofencing.h new file mode 100644 index 0000000..7af5f91 --- /dev/null +++ b/gps/android/GnssGeofencing.h @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSSGEOFENCING_H +#define ANDROID_HARDWARE_GNSS_V1_1_GNSSGEOFENCING_H + +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::gnss::V1_0::IGnssGeofenceCallback; +using ::android::hardware::gnss::V1_0::IGnssGeofencing; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; + +class GeofenceAPIClient; +struct GnssGeofencing : public IGnssGeofencing { + GnssGeofencing(); + ~GnssGeofencing(); + + /* + * Methods from ::android::hardware::gnss::V1_0::IGnssGeofencing follow. + * These declarations were generated from IGnssGeofencing.hal. + */ + Return setCallback(const sp& callback) override; + Return addGeofence(int32_t geofenceId, + double latitudeDegrees, + double longitudeDegrees, + double radiusMeters, + IGnssGeofenceCallback::GeofenceTransition lastTransition, + int32_t monitorTransitions, + uint32_t notificationResponsivenessMs, + uint32_t unknownTimerMs) override; + + Return pauseGeofence(int32_t geofenceId) override; + Return resumeGeofence(int32_t geofenceId, int32_t monitorTransitions) override; + Return removeGeofence(int32_t geofenceId) override; + + private: + // This method is not part of the IGnss base class. + // It is called by GnssGeofencingDeathRecipient to remove all geofences added so far. + Return removeAllGeofences(); + + private: + struct GnssGeofencingDeathRecipient : hidl_death_recipient { + GnssGeofencingDeathRecipient(sp gnssGeofencing) : + mGnssGeofencing(gnssGeofencing) { + } + ~GnssGeofencingDeathRecipient() = default; + virtual void serviceDied(uint64_t cookie, const wp& who) override; + sp mGnssGeofencing; + }; + + private: + sp mGnssGeofencingDeathRecipient = nullptr; + sp mGnssGeofencingCbIface = nullptr; + GeofenceAPIClient* mApi = nullptr; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSGEOFENCING_H diff --git a/gps/android/GnssMeasurement.cpp b/gps/android/GnssMeasurement.cpp new file mode 100644 index 0000000..8cbfabd --- /dev/null +++ b/gps/android/GnssMeasurement.cpp @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "LocSvc_GnssMeasurementInterface" + +#include +#include +#include "GnssMeasurement.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +void GnssMeasurement::GnssMeasurementDeathRecipient::serviceDied( + uint64_t cookie, const wp& who) { + LOC_LOGE("%s] service died. cookie: %llu, who: %p", + __FUNCTION__, static_cast(cookie), &who); + if (mGnssMeasurement != nullptr) { + mGnssMeasurement->close(); + } +} + +GnssMeasurement::GnssMeasurement() { + mGnssMeasurementDeathRecipient = new GnssMeasurementDeathRecipient(this); + mApi = new MeasurementAPIClient(); +} + +GnssMeasurement::~GnssMeasurement() { + if (mApi) { + delete mApi; + mApi = nullptr; + } +} + +// Methods from ::android::hardware::gnss::V1_0::IGnssMeasurement follow. +Return GnssMeasurement::setCallback( + const sp& callback) { + + Return ret = + IGnssMeasurement::GnssMeasurementStatus::ERROR_GENERIC; + if (mGnssMeasurementCbIface != nullptr) { + LOC_LOGE("%s]: GnssMeasurementCallback is already set", __FUNCTION__); + return IGnssMeasurement::GnssMeasurementStatus::ERROR_ALREADY_INIT; + } + + if (callback == nullptr) { + LOC_LOGE("%s]: callback is nullptr", __FUNCTION__); + return ret; + } + if (mApi == nullptr) { + LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__); + return ret; + } + + mGnssMeasurementCbIface = callback; + mGnssMeasurementCbIface->linkToDeath(mGnssMeasurementDeathRecipient, 0 /*cookie*/); + + return mApi->measurementSetCallback(callback); +} + +Return GnssMeasurement::close() { + if (mApi == nullptr) { + LOC_LOGE("%s]: mApi is nullptr", __FUNCTION__); + return Void(); + } + + if (mGnssMeasurementCbIface != nullptr) { + mGnssMeasurementCbIface->unlinkToDeath(mGnssMeasurementDeathRecipient); + mGnssMeasurementCbIface = nullptr; + } + mApi->measurementClose(); + + return Void(); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/GnssMeasurement.h b/gps/android/GnssMeasurement.h new file mode 100644 index 0000000..5073169 --- /dev/null +++ b/gps/android/GnssMeasurement.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSSMEASUREMENT_H +#define ANDROID_HARDWARE_GNSS_V1_1_GNSSMEASUREMENT_H + +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::gnss::V1_0::IGnssMeasurement; +using ::android::hardware::gnss::V1_0::IGnssMeasurementCallback; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; + +class MeasurementAPIClient; +struct GnssMeasurement : public IGnssMeasurement { + GnssMeasurement(); + ~GnssMeasurement(); + + /* + * Methods from ::android::hardware::gnss::V1_0::IGnssMeasurement follow. + * These declarations were generated from IGnssMeasurement.hal. + */ + Return setCallback( + const sp& callback) override; + Return close() override; + + private: + struct GnssMeasurementDeathRecipient : hidl_death_recipient { + GnssMeasurementDeathRecipient(sp gnssMeasurement) : + mGnssMeasurement(gnssMeasurement) { + } + ~GnssMeasurementDeathRecipient() = default; + virtual void serviceDied(uint64_t cookie, const wp& who) override; + sp mGnssMeasurement; + }; + + private: + sp mGnssMeasurementDeathRecipient = nullptr; + sp mGnssMeasurementCbIface = nullptr; + MeasurementAPIClient* mApi; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSMEASUREMENT_H diff --git a/gps/android/GnssNi.cpp b/gps/android/GnssNi.cpp new file mode 100644 index 0000000..4437932 --- /dev/null +++ b/gps/android/GnssNi.cpp @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "LocSvc_GnssNiInterface" + +#include +#include "Gnss.h" +#include "GnssNi.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +void GnssNi::GnssNiDeathRecipient::serviceDied(uint64_t cookie, const wp& who) { + LOC_LOGE("%s] service died. cookie: %llu, who: %p", + __FUNCTION__, static_cast(cookie), &who); + // we do nothing here + // Gnss::GnssDeathRecipient will stop the session +} + +GnssNi::GnssNi(Gnss* gnss) : mGnss(gnss) { + mGnssNiDeathRecipient = new GnssNiDeathRecipient(this); +} + +// Methods from ::android::hardware::gnss::V1_0::IGnssNi follow. +Return GnssNi::setCallback(const sp& callback) { + if (mGnss == nullptr) { + LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); + return Void(); + } + + mGnss->setGnssNiCb(callback); + + if (mGnssNiCbIface != nullptr) { + mGnssNiCbIface->unlinkToDeath(mGnssNiDeathRecipient); + } + mGnssNiCbIface = callback; + if (mGnssNiCbIface != nullptr) { + mGnssNiCbIface->linkToDeath(mGnssNiDeathRecipient, 0 /*cookie*/); + } + + return Void(); +} + +Return GnssNi::respond(int32_t notifId, IGnssNiCallback::GnssUserResponseType userResponse) { + if (mGnss == nullptr) { + LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__); + return Void(); + } + + GnssAPIClient* api = mGnss->getApi(); + if (api == nullptr) { + LOC_LOGE("%s]: api is nullptr", __FUNCTION__); + return Void(); + } + + api->gnssNiRespond(notifId, userResponse); + + return Void(); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/GnssNi.h b/gps/android/GnssNi.h new file mode 100644 index 0000000..f6fe0bb --- /dev/null +++ b/gps/android/GnssNi.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_HARDWARE_GNSS_V1_1_GNSSNI_H +#define ANDROID_HARDWARE_GNSS_V1_1_GNSSNI_H + +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::gnss::V1_0::IGnssNi; +using ::android::hardware::gnss::V1_0::IGnssNiCallback; +using ::android::hardware::Return; +using ::android::hardware::Void; +using ::android::hardware::hidl_vec; +using ::android::hardware::hidl_string; +using ::android::sp; + +struct Gnss; +struct GnssNi : public IGnssNi { + GnssNi(Gnss* gnss); + ~GnssNi() = default; + + /* + * Methods from ::android::hardware::gnss::V1_0::IGnssNi follow. + * These declarations were generated from IGnssNi.hal. + */ + Return setCallback(const sp& callback) override; + Return respond(int32_t notifId, + IGnssNiCallback::GnssUserResponseType userResponse) override; + + private: + struct GnssNiDeathRecipient : hidl_death_recipient { + GnssNiDeathRecipient(sp gnssNi) : mGnssNi(gnssNi) { + } + ~GnssNiDeathRecipient() = default; + virtual void serviceDied(uint64_t cookie, const wp& who) override; + sp mGnssNi; + }; + + private: + sp mGnssNiDeathRecipient = nullptr; + sp mGnssNiCbIface = nullptr; + Gnss* mGnss = nullptr; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V1_1_GNSSNI_H diff --git a/gps/android/android.hardware.gnss@1.0-service-qti.rc b/gps/android/android.hardware.gnss@1.0-service-qti.rc new file mode 100644 index 0000000..d4d40fa --- /dev/null +++ b/gps/android/android.hardware.gnss@1.0-service-qti.rc @@ -0,0 +1,4 @@ +service gnss_service /vendor/bin/hw/android.hardware.gnss@1.0-service-qti + class main + user gps + group system gps radio diff --git a/gps/android/location_api/BatchingAPIClient.cpp b/gps/android/location_api/BatchingAPIClient.cpp new file mode 100644 index 0000000..0b66d38 --- /dev/null +++ b/gps/android/location_api/BatchingAPIClient.cpp @@ -0,0 +1,191 @@ +/* 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_NDEBUG 0 +#define LOG_TAG "LocSvc_BatchingAPIClient" + +#include +#include + +#include "LocationUtil.h" +#include "BatchingAPIClient.h" + +#include "limits.h" + + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +static void convertBatchOption(const IGnssBatching::Options& in, LocationOptions& out, + LocationCapabilitiesMask mask); + +BatchingAPIClient::BatchingAPIClient(const sp& callback) : + LocationAPIClientBase(), + mGnssBatchingCbIface(callback), + mDefaultId(UINT_MAX), + mLocationCapabilitiesMask(0) +{ + LOC_LOGD("%s]: (%p)", __FUNCTION__, &callback); + + LocationCallbacks locationCallbacks; + memset(&locationCallbacks, 0, sizeof(LocationCallbacks)); + locationCallbacks.size = sizeof(LocationCallbacks); + + locationCallbacks.trackingCb = nullptr; + locationCallbacks.batchingCb = nullptr; + if (mGnssBatchingCbIface != nullptr) { + locationCallbacks.batchingCb = [this](size_t count, Location* location, + BatchingOptions batchOptions) { + onBatchingCb(count, location, batchOptions); + }; + } + locationCallbacks.geofenceBreachCb = nullptr; + locationCallbacks.geofenceStatusCb = nullptr; + locationCallbacks.gnssLocationInfoCb = nullptr; + locationCallbacks.gnssNiCb = nullptr; + locationCallbacks.gnssSvCb = nullptr; + locationCallbacks.gnssNmeaCb = nullptr; + locationCallbacks.gnssMeasurementsCb = nullptr; + + locAPISetCallbacks(locationCallbacks); +} + +BatchingAPIClient::~BatchingAPIClient() +{ + LOC_LOGD("%s]: ()", __FUNCTION__); +} + +int BatchingAPIClient::getBatchSize() +{ + LOC_LOGD("%s]: ()", __FUNCTION__); + return locAPIGetBatchSize(); +} + +int BatchingAPIClient::startSession(const IGnssBatching::Options& opts) +{ + LOC_LOGD("%s]: (%lld %d)", __FUNCTION__, + static_cast(opts.periodNanos), static_cast(opts.flags)); + int retVal = -1; + LocationOptions options; + convertBatchOption(opts, options, mLocationCapabilitiesMask); + uint32_t mode = 0; + if (opts.flags == static_cast(IGnssBatching::Flag::WAKEUP_ON_FIFO_FULL)) { + mode = SESSION_MODE_ON_FULL; + } + if (locAPIStartSession(mDefaultId, mode, options) == LOCATION_ERROR_SUCCESS) { + retVal = 1; + } + return retVal; +} + +int BatchingAPIClient::updateSessionOptions(const IGnssBatching::Options& opts) +{ + LOC_LOGD("%s]: (%lld %d)", __FUNCTION__, + static_cast(opts.periodNanos), static_cast(opts.flags)); + int retVal = -1; + LocationOptions options; + convertBatchOption(opts, options, mLocationCapabilitiesMask); + + uint32_t mode = 0; + if (opts.flags == static_cast(IGnssBatching::Flag::WAKEUP_ON_FIFO_FULL)) { + mode = SESSION_MODE_ON_FULL; + } + if (locAPIUpdateSessionOptions(mDefaultId, mode, options) == LOCATION_ERROR_SUCCESS) { + retVal = 1; + } + return retVal; +} + +int BatchingAPIClient::stopSession() +{ + LOC_LOGD("%s]: ", __FUNCTION__); + int retVal = -1; + if (locAPIStopSession(mDefaultId) == LOCATION_ERROR_SUCCESS) { + retVal = 1; + } + return retVal; +} + +void BatchingAPIClient::getBatchedLocation(int last_n_locations) +{ + LOC_LOGD("%s]: (%d)", __FUNCTION__, last_n_locations); + locAPIGetBatchedLocations(mDefaultId, last_n_locations); +} + +void BatchingAPIClient::flushBatchedLocations() +{ + LOC_LOGD("%s]: ()", __FUNCTION__); + locAPIGetBatchedLocations(mDefaultId, SIZE_MAX); +} + +void BatchingAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) +{ + LOC_LOGD("%s]: (%02x)", __FUNCTION__, capabilitiesMask); + mLocationCapabilitiesMask = capabilitiesMask; +} + +void BatchingAPIClient::onBatchingCb(size_t count, Location* location, BatchingOptions batchOptions) +{ + LOC_LOGD("%s]: (count: %zu)", __FUNCTION__, count); + if (mGnssBatchingCbIface != nullptr && count > 0) { + hidl_vec locationVec; + locationVec.resize(count); + for (size_t i = 0; i < count; i++) { + convertGnssLocation(location[i], locationVec[i]); + } + auto r = mGnssBatchingCbIface->gnssLocationBatchCb(locationVec); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssLocationBatchCb description=%s", + __func__, r.description().c_str()); + } + } +} + +static void convertBatchOption(const IGnssBatching::Options& in, LocationOptions& out, + LocationCapabilitiesMask mask) +{ + memset(&out, 0, sizeof(LocationOptions)); + out.size = sizeof(LocationOptions); + out.minInterval = (uint32_t)(in.periodNanos / 1000000L); + out.minDistance = 0; + out.mode = GNSS_SUPL_MODE_STANDALONE; + if (mask & LOCATION_CAPABILITIES_GNSS_MSA_BIT) + out.mode = GNSS_SUPL_MODE_MSA; + if (mask & LOCATION_CAPABILITIES_GNSS_MSB_BIT) + out.mode = GNSS_SUPL_MODE_MSB; +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/location_api/BatchingAPIClient.h b/gps/android/location_api/BatchingAPIClient.h new file mode 100644 index 0000000..c951a83 --- /dev/null +++ b/gps/android/location_api/BatchingAPIClient.h @@ -0,0 +1,75 @@ +/* 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 BATCHING_API_CLINET_H +#define BATCHING_API_CLINET_H + +#include +#include +#include + +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +class BatchingAPIClient : public LocationAPIClientBase +{ +public: + BatchingAPIClient(const sp& callback); + ~BatchingAPIClient(); + int getBatchSize(); + int startSession(const IGnssBatching::Options& options); + int updateSessionOptions(const IGnssBatching::Options& options); + int stopSession(); + void getBatchedLocation(int last_n_locations); + void flushBatchedLocations(); + + inline LocationCapabilitiesMask getCapabilities() { return mLocationCapabilitiesMask; } + + // callbacks + void onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) final; + void onBatchingCb(size_t count, Location* location, BatchingOptions batchOptions) final; + +private: + sp mGnssBatchingCbIface; + uint32_t mDefaultId; + int mBatchSize; + LocationCapabilitiesMask mLocationCapabilitiesMask; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android +#endif // BATCHING_API_CLINET_H diff --git a/gps/android/location_api/GeofenceAPIClient.cpp b/gps/android/location_api/GeofenceAPIClient.cpp new file mode 100644 index 0000000..6167177 --- /dev/null +++ b/gps/android/location_api/GeofenceAPIClient.cpp @@ -0,0 +1,273 @@ +/* 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_NDEBUG 0 +#define LOG_TAG "LocSvc_GeofenceApiClient" + +#include +#include + +#include "LocationUtil.h" +#include "GeofenceAPIClient.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + + +GeofenceAPIClient::GeofenceAPIClient(const sp& callback) : + LocationAPIClientBase(), + mGnssGeofencingCbIface(callback) +{ + LOC_LOGD("%s]: (%p)", __FUNCTION__, &callback); + + LocationCallbacks locationCallbacks; + memset(&locationCallbacks, 0, sizeof(LocationCallbacks)); + locationCallbacks.size = sizeof(LocationCallbacks); + + locationCallbacks.trackingCb = nullptr; + locationCallbacks.batchingCb = nullptr; + + locationCallbacks.geofenceBreachCb = nullptr; + if (mGnssGeofencingCbIface != nullptr) { + locationCallbacks.geofenceBreachCb = + [this](GeofenceBreachNotification geofenceBreachNotification) { + onGeofenceBreachCb(geofenceBreachNotification); + }; + + locationCallbacks.geofenceStatusCb = + [this](GeofenceStatusNotification geofenceStatusNotification) { + onGeofenceStatusCb(geofenceStatusNotification); + }; + } + + locationCallbacks.gnssLocationInfoCb = nullptr; + locationCallbacks.gnssNiCb = nullptr; + locationCallbacks.gnssSvCb = nullptr; + locationCallbacks.gnssNmeaCb = nullptr; + locationCallbacks.gnssMeasurementsCb = nullptr; + + locAPISetCallbacks(locationCallbacks); +} + +void GeofenceAPIClient::geofenceAdd(uint32_t geofence_id, double latitude, double longitude, + double radius_meters, int32_t last_transition, int32_t monitor_transitions, + uint32_t notification_responsiveness_ms, uint32_t unknown_timer_ms) +{ + LOC_LOGD("%s]: (%d %f %f %f %d %d %d %d)", __FUNCTION__, + geofence_id, latitude, longitude, radius_meters, + last_transition, monitor_transitions, notification_responsiveness_ms, unknown_timer_ms); + + GeofenceOption options; + memset(&options, 0, sizeof(GeofenceOption)); + options.size = sizeof(GeofenceOption); + if (monitor_transitions & IGnssGeofenceCallback::GeofenceTransition::ENTERED) + options.breachTypeMask |= GEOFENCE_BREACH_ENTER_BIT; + if (monitor_transitions & IGnssGeofenceCallback::GeofenceTransition::EXITED) + options.breachTypeMask |= GEOFENCE_BREACH_EXIT_BIT; + options.responsiveness = notification_responsiveness_ms; + + GeofenceInfo data; + data.size = sizeof(GeofenceInfo); + data.latitude = latitude; + data.longitude = longitude; + data.radius = radius_meters; + + LocationError err = (LocationError)locAPIAddGeofences(1, &geofence_id, &options, &data); + if (LOCATION_ERROR_SUCCESS != err) { + onAddGeofencesCb(1, &err, &geofence_id); + } +} + +void GeofenceAPIClient::geofencePause(uint32_t geofence_id) +{ + LOC_LOGD("%s]: (%d)", __FUNCTION__, geofence_id); + locAPIPauseGeofences(1, &geofence_id); +} + +void GeofenceAPIClient::geofenceResume(uint32_t geofence_id, int32_t monitor_transitions) +{ + LOC_LOGD("%s]: (%d %d)", __FUNCTION__, geofence_id, monitor_transitions); + GeofenceBreachTypeMask mask = 0; + if (monitor_transitions & IGnssGeofenceCallback::GeofenceTransition::ENTERED) + mask |= GEOFENCE_BREACH_ENTER_BIT; + if (monitor_transitions & IGnssGeofenceCallback::GeofenceTransition::EXITED) + mask |= GEOFENCE_BREACH_EXIT_BIT; + locAPIResumeGeofences(1, &geofence_id, &mask); +} + +void GeofenceAPIClient::geofenceRemove(uint32_t geofence_id) +{ + LOC_LOGD("%s]: (%d)", __FUNCTION__, geofence_id); + locAPIRemoveGeofences(1, &geofence_id); +} + +void GeofenceAPIClient::geofenceRemoveAll() +{ + LOC_LOGD("%s]", __FUNCTION__); + // TODO locAPIRemoveAllGeofences(); +} + +// callbacks +void GeofenceAPIClient::onGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification) +{ + LOC_LOGD("%s]: (%zu)", __FUNCTION__, geofenceBreachNotification.count); + if (mGnssGeofencingCbIface != nullptr) { + for (size_t i = 0; i < geofenceBreachNotification.count; i++) { + GnssLocation gnssLocation; + convertGnssLocation(geofenceBreachNotification.location, gnssLocation); + + IGnssGeofenceCallback::GeofenceTransition transition; + if (geofenceBreachNotification.type == GEOFENCE_BREACH_ENTER) + transition = IGnssGeofenceCallback::GeofenceTransition::ENTERED; + else if (geofenceBreachNotification.type == GEOFENCE_BREACH_EXIT) + transition = IGnssGeofenceCallback::GeofenceTransition::EXITED; + else { + // continue with other breach if transition is + // nether GPS_GEOFENCE_ENTERED nor GPS_GEOFENCE_EXITED + continue; + } + + auto r = mGnssGeofencingCbIface->gnssGeofenceTransitionCb( + geofenceBreachNotification.ids[i], gnssLocation, transition, + static_cast(geofenceBreachNotification.timestamp)); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssGeofenceTransitionCb description=%s", + __func__, r.description().c_str()); + } + } + } +} + +void GeofenceAPIClient::onGeofenceStatusCb(GeofenceStatusNotification geofenceStatusNotification) +{ + LOC_LOGD("%s]: (%d)", __FUNCTION__, geofenceStatusNotification.available); + if (mGnssGeofencingCbIface != nullptr) { + IGnssGeofenceCallback::GeofenceAvailability status = + IGnssGeofenceCallback::GeofenceAvailability::UNAVAILABLE; + if (geofenceStatusNotification.available == GEOFENCE_STATUS_AVAILABILE_YES) { + status = IGnssGeofenceCallback::GeofenceAvailability::AVAILABLE; + } + GnssLocation gnssLocation; + memset(&gnssLocation, 0, sizeof(GnssLocation)); + auto r = mGnssGeofencingCbIface->gnssGeofenceStatusCb(status, gnssLocation); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssGeofenceStatusCb description=%s", + __func__, r.description().c_str()); + } + } +} + +void GeofenceAPIClient::onAddGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) +{ + LOC_LOGD("%s]: (%zu)", __FUNCTION__, count); + if (mGnssGeofencingCbIface != nullptr) { + for (size_t i = 0; i < count; i++) { + IGnssGeofenceCallback::GeofenceStatus status = + IGnssGeofenceCallback::GeofenceStatus::ERROR_GENERIC; + if (errors[i] == LOCATION_ERROR_SUCCESS) + status = IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS; + else if (errors[i] == LOCATION_ERROR_ID_EXISTS) + status = IGnssGeofenceCallback::GeofenceStatus::ERROR_ID_EXISTS; + auto r = mGnssGeofencingCbIface->gnssGeofenceAddCb(ids[i], status); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssGeofenceAddCb description=%s", + __func__, r.description().c_str()); + } + } + } +} + +void GeofenceAPIClient::onRemoveGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) +{ + LOC_LOGD("%s]: (%zu)", __FUNCTION__, count); + if (mGnssGeofencingCbIface != nullptr) { + for (size_t i = 0; i < count; i++) { + IGnssGeofenceCallback::GeofenceStatus status = + IGnssGeofenceCallback::GeofenceStatus::ERROR_GENERIC; + if (errors[i] == LOCATION_ERROR_SUCCESS) + status = IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS; + else if (errors[i] == LOCATION_ERROR_ID_UNKNOWN) + status = IGnssGeofenceCallback::GeofenceStatus::ERROR_ID_UNKNOWN; + auto r = mGnssGeofencingCbIface->gnssGeofenceRemoveCb(ids[i], status); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssGeofenceRemoveCb description=%s", + __func__, r.description().c_str()); + } + } + } +} + +void GeofenceAPIClient::onPauseGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) +{ + LOC_LOGD("%s]: (%zu)", __FUNCTION__, count); + if (mGnssGeofencingCbIface != nullptr) { + for (size_t i = 0; i < count; i++) { + IGnssGeofenceCallback::GeofenceStatus status = + IGnssGeofenceCallback::GeofenceStatus::ERROR_GENERIC; + if (errors[i] == LOCATION_ERROR_SUCCESS) + status = IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS; + else if (errors[i] == LOCATION_ERROR_ID_UNKNOWN) + status = IGnssGeofenceCallback::GeofenceStatus::ERROR_ID_UNKNOWN; + auto r = mGnssGeofencingCbIface->gnssGeofencePauseCb(ids[i], status); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssGeofencePauseCb description=%s", + __func__, r.description().c_str()); + } + } + } +} + +void GeofenceAPIClient::onResumeGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) +{ + LOC_LOGD("%s]: (%zu)", __FUNCTION__, count); + if (mGnssGeofencingCbIface != nullptr) { + for (size_t i = 0; i < count; i++) { + IGnssGeofenceCallback::GeofenceStatus status = + IGnssGeofenceCallback::GeofenceStatus::ERROR_GENERIC; + if (errors[i] == LOCATION_ERROR_SUCCESS) + status = IGnssGeofenceCallback::GeofenceStatus::OPERATION_SUCCESS; + else if (errors[i] == LOCATION_ERROR_ID_UNKNOWN) + status = IGnssGeofenceCallback::GeofenceStatus::ERROR_ID_UNKNOWN; + auto r = mGnssGeofencingCbIface->gnssGeofenceResumeCb(ids[i], status); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssGeofenceResumeCb description=%s", + __func__, r.description().c_str()); + } + } + } +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/location_api/GeofenceAPIClient.h b/gps/android/location_api/GeofenceAPIClient.h new file mode 100644 index 0000000..f779bcb --- /dev/null +++ b/gps/android/location_api/GeofenceAPIClient.h @@ -0,0 +1,76 @@ +/* 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 GEOFENCE_API_CLINET_H +#define GEOFENCE_API_CLINET_H + + +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::sp; + +class GeofenceAPIClient : public LocationAPIClientBase +{ +public: + GeofenceAPIClient(const sp& callback); + virtual ~GeofenceAPIClient() = default; + + void geofenceAdd(uint32_t geofence_id, double latitude, double longitude, + double radius_meters, int32_t last_transition, int32_t monitor_transitions, + uint32_t notification_responsiveness_ms, uint32_t unknown_timer_ms); + void geofencePause(uint32_t geofence_id); + void geofenceResume(uint32_t geofence_id, int32_t monitor_transitions); + void geofenceRemove(uint32_t geofence_id); + void geofenceRemoveAll(); + + // callbacks + void onGeofenceBreachCb(GeofenceBreachNotification geofenceBreachNotification) final; + void onGeofenceStatusCb(GeofenceStatusNotification geofenceStatusNotification) final; + void onAddGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; + void onRemoveGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; + void onPauseGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; + void onResumeGeofencesCb(size_t count, LocationError* errors, uint32_t* ids) final; + +private: + sp mGnssGeofencingCbIface; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android +#endif // GEOFENCE_API_CLINET_H diff --git a/gps/android/location_api/GnssAPIClient.cpp b/gps/android/location_api/GnssAPIClient.cpp new file mode 100644 index 0000000..0cccb27 --- /dev/null +++ b/gps/android/location_api/GnssAPIClient.cpp @@ -0,0 +1,498 @@ +/* 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_NDEBUG 0 +#define LOG_TAG "LocSvc_GnssAPIClient" + +#include +#include + +#include "LocationUtil.h" +#include "GnssAPIClient.h" +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +static void convertGnssSvStatus(GnssSvNotification& in, IGnssCallback::GnssSvStatus& out); + +GnssAPIClient::GnssAPIClient(const sp& gpsCb, + const sp& niCb) : + LocationAPIClientBase(), + mGnssCbIface(nullptr), + mGnssNiCbIface(nullptr), + mControlClient(new LocationAPIControlClient()), + mLocationCapabilitiesMask(0), + mLocationCapabilitiesCached(false) +{ + LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb); + + // set default LocationOptions. + memset(&mLocationOptions, 0, sizeof(LocationOptions)); + mLocationOptions.size = sizeof(LocationOptions); + mLocationOptions.minInterval = 1000; + mLocationOptions.minDistance = 0; + mLocationOptions.mode = GNSS_SUPL_MODE_STANDALONE; + + gnssUpdateCallbacks(gpsCb, niCb); +} + +GnssAPIClient::~GnssAPIClient() +{ + LOC_LOGD("%s]: ()", __FUNCTION__); + if (mControlClient) { + delete mControlClient; + mControlClient = nullptr; + } +} + +// for GpsInterface +void GnssAPIClient::gnssUpdateCallbacks(const sp& gpsCb, + const sp& niCb) +{ + LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb); + + mGnssCbIface = gpsCb; + mGnssNiCbIface = niCb; + + LocationCallbacks locationCallbacks; + memset(&locationCallbacks, 0, sizeof(LocationCallbacks)); + locationCallbacks.size = sizeof(LocationCallbacks); + + locationCallbacks.trackingCb = nullptr; + if (mGnssCbIface != nullptr) { + locationCallbacks.trackingCb = [this](Location location) { + onTrackingCb(location); + }; + } + + locationCallbacks.batchingCb = nullptr; + locationCallbacks.geofenceBreachCb = nullptr; + locationCallbacks.geofenceStatusCb = nullptr; + locationCallbacks.gnssLocationInfoCb = nullptr; + + locationCallbacks.gnssNiCb = nullptr; + loc_core::ContextBase* context = + loc_core::LocDualContext::getLocFgContext( + NULL, NULL, + loc_core::LocDualContext::mLocationHalName, false); + if (mGnssNiCbIface != nullptr && !context->hasAgpsExtendedCapabilities()) { + LOC_LOGD("Registering NI CB"); + locationCallbacks.gnssNiCb = [this](uint32_t id, GnssNiNotification gnssNiNotification) { + onGnssNiCb(id, gnssNiNotification); + }; + } + + locationCallbacks.gnssSvCb = nullptr; + if (mGnssCbIface != nullptr) { + locationCallbacks.gnssSvCb = [this](GnssSvNotification gnssSvNotification) { + onGnssSvCb(gnssSvNotification); + }; + } + + locationCallbacks.gnssNmeaCb = nullptr; + if (mGnssCbIface != nullptr) { + locationCallbacks.gnssNmeaCb = [this](GnssNmeaNotification gnssNmeaNotification) { + onGnssNmeaCb(gnssNmeaNotification); + }; + } + + locationCallbacks.gnssMeasurementsCb = nullptr; + + locAPISetCallbacks(locationCallbacks); +} + +bool GnssAPIClient::gnssStart() +{ + LOC_LOGD("%s]: ()", __FUNCTION__); + bool retVal = true; + locAPIStartTracking(mLocationOptions); + return retVal; +} + +bool GnssAPIClient::gnssStop() +{ + LOC_LOGD("%s]: ()", __FUNCTION__); + bool retVal = true; + locAPIStopTracking(); + return retVal; +} + +bool GnssAPIClient::gnssSetPositionMode(IGnss::GnssPositionMode mode, + IGnss::GnssPositionRecurrence recurrence, uint32_t minIntervalMs, + uint32_t preferredAccuracyMeters, uint32_t preferredTimeMs) +{ + LOC_LOGD("%s]: (%d %d %d %d %d)", __FUNCTION__, + (int)mode, recurrence, minIntervalMs, preferredAccuracyMeters, preferredTimeMs); + bool retVal = true; + memset(&mLocationOptions, 0, sizeof(LocationOptions)); + mLocationOptions.size = sizeof(LocationOptions); + mLocationOptions.minInterval = minIntervalMs; + mLocationOptions.minDistance = preferredAccuracyMeters; + if (mode == IGnss::GnssPositionMode::STANDALONE) + mLocationOptions.mode = GNSS_SUPL_MODE_STANDALONE; + else if (mode == IGnss::GnssPositionMode::MS_BASED) + mLocationOptions.mode = GNSS_SUPL_MODE_MSB; + else if (mode == IGnss::GnssPositionMode::MS_ASSISTED) + mLocationOptions.mode = GNSS_SUPL_MODE_MSA; + else { + LOC_LOGD("%s]: invalid GnssPositionMode: %d", __FUNCTION__, (int)mode); + retVal = false; + } + locAPIUpdateTrackingOptions(mLocationOptions); + return retVal; +} + +// for GpsNiInterface +void GnssAPIClient::gnssNiRespond(int32_t notifId, + IGnssNiCallback::GnssUserResponseType userResponse) +{ + LOC_LOGD("%s]: (%d %d)", __FUNCTION__, notifId, static_cast(userResponse)); + GnssNiResponse data = GNSS_NI_RESPONSE_IGNORE; + if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_ACCEPT) + data = GNSS_NI_RESPONSE_ACCEPT; + else if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_DENY) + data = GNSS_NI_RESPONSE_DENY; + else if (userResponse == IGnssNiCallback::GnssUserResponseType::RESPONSE_NORESP) + data = GNSS_NI_RESPONSE_NO_RESPONSE; + else { + LOC_LOGD("%s]: invalid GnssUserResponseType: %d", __FUNCTION__, (int)userResponse); + return; + } + locAPIGnssNiResponse(notifId, data); +} + +// these apis using LocationAPIControlClient +void GnssAPIClient::gnssDeleteAidingData(IGnss::GnssAidingData aidingDataFlags) +{ + LOC_LOGD("%s]: (%02hx)", __FUNCTION__, aidingDataFlags); + if (mControlClient == nullptr) { + return; + } + GnssAidingData data; + memset(&data, 0, sizeof (GnssAidingData)); + data.sv.svTypeMask = GNSS_AIDING_DATA_SV_TYPE_GPS_BIT | + GNSS_AIDING_DATA_SV_TYPE_GLONASS_BIT | + GNSS_AIDING_DATA_SV_TYPE_QZSS_BIT | + GNSS_AIDING_DATA_SV_TYPE_BEIDOU_BIT | + GNSS_AIDING_DATA_SV_TYPE_GALILEO_BIT; + + if (aidingDataFlags == IGnss::GnssAidingData::DELETE_ALL) + data.deleteAll = true; + else { + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_EPHEMERIS) + data.sv.svMask |= GNSS_AIDING_DATA_SV_EPHEMERIS_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_ALMANAC) + data.sv.svMask |= GNSS_AIDING_DATA_SV_ALMANAC_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_POSITION) + data.common.mask |= GNSS_AIDING_DATA_COMMON_POSITION_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_TIME) + data.common.mask |= GNSS_AIDING_DATA_COMMON_TIME_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_IONO) + data.sv.svMask |= GNSS_AIDING_DATA_SV_IONOSPHERE_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_UTC) + data.common.mask |= GNSS_AIDING_DATA_COMMON_UTC_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_HEALTH) + data.sv.svMask |= GNSS_AIDING_DATA_SV_HEALTH_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SVDIR) + data.sv.svMask |= GNSS_AIDING_DATA_SV_DIRECTION_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SVSTEER) + data.sv.svMask |= GNSS_AIDING_DATA_SV_STEER_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_SADATA) + data.sv.svMask |= GNSS_AIDING_DATA_SV_SA_DATA_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_RTI) + data.common.mask |= GNSS_AIDING_DATA_COMMON_RTI_BIT; + if (aidingDataFlags & IGnss::GnssAidingData::DELETE_CELLDB_INFO) + data.common.mask |= GNSS_AIDING_DATA_COMMON_CELLDB_BIT; + } + mControlClient->locAPIGnssDeleteAidingData(data); +} + +void GnssAPIClient::gnssEnable(LocationTechnologyType techType) +{ + LOC_LOGD("%s]: (%0d)", __FUNCTION__, techType); + if (mControlClient == nullptr) { + return; + } + mControlClient->locAPIEnable(techType); +} + +void GnssAPIClient::gnssDisable() +{ + LOC_LOGD("%s]: ()", __FUNCTION__); + if (mControlClient == nullptr) { + return; + } + mControlClient->locAPIDisable(); +} + +void GnssAPIClient::gnssConfigurationUpdate(const GnssConfig& gnssConfig) +{ + LOC_LOGD("%s]: (%02x)", __FUNCTION__, gnssConfig.flags); + if (mControlClient == nullptr) { + return; + } + mControlClient->locAPIGnssUpdateConfig(gnssConfig); +} + +void GnssAPIClient::requestCapabilities() { + // only send capablities if it's already cached, otherwise the first time LocationAPI + // is initialized, capabilities will be sent by LocationAPI + if (mLocationCapabilitiesCached) { + onCapabilitiesCb(mLocationCapabilitiesMask); + } +} + +// callbacks +void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) +{ + LOC_LOGD("%s]: (%02x)", __FUNCTION__, capabilitiesMask); + mLocationCapabilitiesMask = capabilitiesMask; + mLocationCapabilitiesCached = true; + if (mGnssCbIface != nullptr) { + uint32_t data = 0; + if ((capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT) || + (capabilitiesMask & LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT) || + (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT) || + (capabilitiesMask & LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT)) + data |= IGnssCallback::Capabilities::SCHEDULING; + if (capabilitiesMask & LOCATION_CAPABILITIES_GEOFENCE_BIT) + data |= IGnssCallback::Capabilities::GEOFENCING; + if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) + data |= IGnssCallback::Capabilities::MEASUREMENTS; + if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSB_BIT) + data |= IGnssCallback::Capabilities::MSB; + if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MSA_BIT) + data |= IGnssCallback::Capabilities::MSA; + auto r = mGnssCbIface->gnssSetCapabilitesCb(data); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssSetCapabilitesCb description=%s", + __func__, r.description().c_str()); + } + } + if (mGnssCbIface != nullptr) { + IGnssCallback::GnssSystemInfo gnssInfo; + if (capabilitiesMask & LOCATION_CAPABILITIES_DEBUG_NMEA_BIT) { + gnssInfo.yearOfHw = 2017; + } else if (capabilitiesMask & LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT) { + gnssInfo.yearOfHw = 2016; + } else { + gnssInfo.yearOfHw = 2015; + } + LOC_LOGV("%s:%d] set_system_info_cb (%d)", __FUNCTION__, __LINE__, gnssInfo.yearOfHw); + auto r = mGnssCbIface->gnssSetSystemInfoCb(gnssInfo); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssSetSystemInfoCb description=%s", + __func__, r.description().c_str()); + } + } +} + +void GnssAPIClient::onTrackingCb(Location location) +{ + LOC_LOGD("%s]: (flags: %02x)", __FUNCTION__, location.flags); + if (mGnssCbIface != nullptr) { + GnssLocation gnssLocation; + convertGnssLocation(location, gnssLocation); + auto r = mGnssCbIface->gnssLocationCb(gnssLocation); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssLocationCb description=%s", + __func__, r.description().c_str()); + } + } +} + +void GnssAPIClient::onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotification) +{ + LOC_LOGD("%s]: (id: %d)", __FUNCTION__, id); + + if (mGnssNiCbIface == nullptr) { + LOC_LOGE("%s]: mGnssNiCbIface is nullptr", __FUNCTION__); + return; + } + + IGnssNiCallback::GnssNiNotification notificationGnss = {}; + + notificationGnss.notificationId = id; + + if (gnssNiNotification.type == GNSS_NI_TYPE_VOICE) + notificationGnss.niType = IGnssNiCallback::GnssNiType::VOICE; + else if (gnssNiNotification.type == GNSS_NI_TYPE_SUPL) + notificationGnss.niType = IGnssNiCallback::GnssNiType::UMTS_SUPL; + else if (gnssNiNotification.type == GNSS_NI_TYPE_CONTROL_PLANE) + notificationGnss.niType = IGnssNiCallback::GnssNiType::UMTS_CTRL_PLANE; + else if (gnssNiNotification.type == GNSS_NI_TYPE_EMERGENCY_SUPL) + notificationGnss.niType = IGnssNiCallback::GnssNiType::EMERGENCY_SUPL; + + if (gnssNiNotification.options & GNSS_NI_OPTIONS_NOTIFICATION_BIT) + notificationGnss.notifyFlags |= IGnssNiCallback::GnssNiNotifyFlags::NEED_NOTIFY; + if (gnssNiNotification.options & GNSS_NI_OPTIONS_VERIFICATION_BIT) + notificationGnss.notifyFlags |= IGnssNiCallback::GnssNiNotifyFlags::NEED_VERIFY; + if (gnssNiNotification.options & GNSS_NI_OPTIONS_PRIVACY_OVERRIDE_BIT) + notificationGnss.notifyFlags |= IGnssNiCallback::GnssNiNotifyFlags::PRIVACY_OVERRIDE; + + notificationGnss.timeoutSec = gnssNiNotification.timeout; + + if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_ACCEPT) + notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_ACCEPT; + else if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_DENY) + notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_DENY; + else if (gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_NO_RESPONSE || + gnssNiNotification.timeoutResponse == GNSS_NI_RESPONSE_IGNORE) + notificationGnss.defaultResponse = IGnssNiCallback::GnssUserResponseType::RESPONSE_NORESP; + + notificationGnss.requestorId = gnssNiNotification.requestor; + + notificationGnss.notificationMessage = gnssNiNotification.message; + + if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_NONE) + notificationGnss.requestorIdEncoding = + IGnssNiCallback::GnssNiEncodingType::ENC_NONE; + else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_GSM_DEFAULT) + notificationGnss.requestorIdEncoding = + IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_GSM_DEFAULT; + else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_UTF8) + notificationGnss.requestorIdEncoding = + IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UTF8; + else if (gnssNiNotification.requestorEncoding == GNSS_NI_ENCODING_TYPE_UCS2) + notificationGnss.requestorIdEncoding = + IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UCS2; + + if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_NONE) + notificationGnss.notificationIdEncoding = + IGnssNiCallback::GnssNiEncodingType::ENC_NONE; + else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_GSM_DEFAULT) + notificationGnss.notificationIdEncoding = + IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_GSM_DEFAULT; + else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_UTF8) + notificationGnss.notificationIdEncoding = + IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UTF8; + else if (gnssNiNotification.messageEncoding == GNSS_NI_ENCODING_TYPE_UCS2) + notificationGnss.notificationIdEncoding = + IGnssNiCallback::GnssNiEncodingType::ENC_SUPL_UCS2; + + mGnssNiCbIface->niNotifyCb(notificationGnss); +} + +void GnssAPIClient::onGnssSvCb(GnssSvNotification gnssSvNotification) +{ + LOC_LOGD("%s]: (count: %zu)", __FUNCTION__, gnssSvNotification.count); + if (mGnssCbIface != nullptr) { + IGnssCallback::GnssSvStatus svStatus; + convertGnssSvStatus(gnssSvNotification, svStatus); + auto r = mGnssCbIface->gnssSvStatusCb(svStatus); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssSvStatusCb description=%s", + __func__, r.description().c_str()); + } + } +} + +void GnssAPIClient::onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification) +{ + if (mGnssCbIface != nullptr) { + android::hardware::hidl_string nmeaString; + nmeaString.setToExternal(gnssNmeaNotification.nmea, gnssNmeaNotification.length); + auto r = mGnssCbIface->gnssNmeaCb( + static_cast(gnssNmeaNotification.timestamp), nmeaString); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssNmeaCb nmea=%s length=%zu description=%s", __func__, + gnssNmeaNotification.nmea, gnssNmeaNotification.length, r.description().c_str()); + } + } +} + +void GnssAPIClient::onStartTrackingCb(LocationError error) +{ + LOC_LOGD("%s]: (%d)", __FUNCTION__, error); + if (error == LOCATION_ERROR_SUCCESS && mGnssCbIface != nullptr) { + auto r = mGnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_ON); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb ENGINE_ON description=%s", + __func__, r.description().c_str()); + } + r = mGnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_BEGIN); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb SESSION_BEGIN description=%s", + __func__, r.description().c_str()); + } + } +} + +void GnssAPIClient::onStopTrackingCb(LocationError error) +{ + LOC_LOGD("%s]: (%d)", __FUNCTION__, error); + if (error == LOCATION_ERROR_SUCCESS && mGnssCbIface != nullptr) { + auto r = mGnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::SESSION_END); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb SESSION_END description=%s", + __func__, r.description().c_str()); + } + r = mGnssCbIface->gnssStatusCb(IGnssCallback::GnssStatusValue::ENGINE_OFF); + if (!r.isOk()) { + LOC_LOGE("%s] Error from gnssStatusCb ENGINE_OFF description=%s", + __func__, r.description().c_str()); + } + } +} + +static void convertGnssSvStatus(GnssSvNotification& in, IGnssCallback::GnssSvStatus& out) +{ + memset(&out, 0, sizeof(IGnssCallback::GnssSvStatus)); + out.numSvs = in.count; + if (out.numSvs > static_cast(GnssMax::SVS_COUNT)) { + LOC_LOGW("%s]: Too many satellites %zd. Clamps to %d.", + __FUNCTION__, out.numSvs, GnssMax::SVS_COUNT); + out.numSvs = static_cast(GnssMax::SVS_COUNT); + } + for (size_t i = 0; i < out.numSvs; i++) { + IGnssCallback::GnssSvInfo& info = out.gnssSvList[i]; + info.svid = in.gnssSvs[i].svId; + convertGnssConstellationType(in.gnssSvs[i].type, info.constellation); + info.cN0Dbhz = in.gnssSvs[i].cN0Dbhz; + info.elevationDegrees = in.gnssSvs[i].elevation; + info.azimuthDegrees = in.gnssSvs[i].azimuth; + info.svFlag = static_cast(IGnssCallback::GnssSvFlags::NONE); + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_EPHEMER_BIT) + info.svFlag |= IGnssCallback::GnssSvFlags::HAS_EPHEMERIS_DATA; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_HAS_ALMANAC_BIT) + info.svFlag |= IGnssCallback::GnssSvFlags::HAS_ALMANAC_DATA; + if (in.gnssSvs[i].gnssSvOptionsMask & GNSS_SV_OPTIONS_USED_IN_FIX_BIT) + info.svFlag |= IGnssCallback::GnssSvFlags::USED_IN_FIX; + } +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/location_api/GnssAPIClient.h b/gps/android/location_api/GnssAPIClient.h new file mode 100644 index 0000000..295a9e9 --- /dev/null +++ b/gps/android/location_api/GnssAPIClient.h @@ -0,0 +1,107 @@ +/* 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 GNSS_API_CLINET_H +#define GNSS_API_CLINET_H + + +#include +#include +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::sp; + +class GnssAPIClient : public LocationAPIClientBase +{ +public: + GnssAPIClient(const sp& gpsCb, + const sp& niCb); + virtual ~GnssAPIClient(); + GnssAPIClient(const GnssAPIClient&) = delete; + GnssAPIClient& operator=(const GnssAPIClient&) = delete; + + // for GpsInterface + void gnssUpdateCallbacks(const sp& gpsCb, + const sp& niCb); + bool gnssStart(); + bool gnssStop(); + bool gnssSetPositionMode(IGnss::GnssPositionMode mode, + IGnss::GnssPositionRecurrence recurrence, + uint32_t minIntervalMs, + uint32_t preferredAccuracyMeters, + uint32_t preferredTimeMs); + + // for GpsNiInterface + void gnssNiRespond(int32_t notifId, IGnssNiCallback::GnssUserResponseType userResponse); + + // these apis using LocationAPIControlClient + void gnssDeleteAidingData(IGnss::GnssAidingData aidingDataFlags); + void gnssEnable(LocationTechnologyType techType); + void gnssDisable(); + void gnssConfigurationUpdate(const GnssConfig& gnssConfig); + + inline LocationCapabilitiesMask gnssGetCapabilities() const { + return mLocationCapabilitiesMask; + } + void requestCapabilities(); + + // callbacks we are interested in + void onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask) final; + void onTrackingCb(Location location) final; + void onGnssNiCb(uint32_t id, GnssNiNotification gnssNiNotification) final; + void onGnssSvCb(GnssSvNotification gnssSvNotification) final; + void onGnssNmeaCb(GnssNmeaNotification gnssNmeaNotification) final; + + void onStartTrackingCb(LocationError error) final; + void onStopTrackingCb(LocationError error) final; + +private: + sp mGnssCbIface; + sp mGnssNiCbIface; + + LocationAPIControlClient* mControlClient; + LocationCapabilitiesMask mLocationCapabilitiesMask; + bool mLocationCapabilitiesCached; + + LocationOptions mLocationOptions; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android +#endif // GNSS_API_CLINET_H diff --git a/gps/android/location_api/LocationUtil.cpp b/gps/android/location_api/LocationUtil.cpp new file mode 100644 index 0000000..311c0b2 --- /dev/null +++ b/gps/android/location_api/LocationUtil.cpp @@ -0,0 +1,153 @@ +/* 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. + * + */ + +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +void convertGnssLocation(Location& in, GnssLocation& out) +{ + memset(&out, 0, sizeof(GnssLocation)); + if (in.flags & LOCATION_HAS_LAT_LONG_BIT) + out.gnssLocationFlags |= GnssLocationFlags::HAS_LAT_LONG; + if (in.flags & LOCATION_HAS_ALTITUDE_BIT) + out.gnssLocationFlags |= GnssLocationFlags::HAS_ALTITUDE; + if (in.flags & LOCATION_HAS_SPEED_BIT) + out.gnssLocationFlags |= GnssLocationFlags::HAS_SPEED; + if (in.flags & LOCATION_HAS_BEARING_BIT) + out.gnssLocationFlags |= GnssLocationFlags::HAS_BEARING; + if (in.flags & LOCATION_HAS_ACCURACY_BIT) + out.gnssLocationFlags |= GnssLocationFlags::HAS_HORIZONTAL_ACCURACY; + if (in.flags & LOCATION_HAS_VERTICAL_ACCURACY_BIT) + out.gnssLocationFlags |= GnssLocationFlags::HAS_VERTICAL_ACCURACY; + if (in.flags & LOCATION_HAS_SPEED_ACCURACY_BIT) + out.gnssLocationFlags |= GnssLocationFlags::HAS_SPEED_ACCURACY; + if (in.flags & LOCATION_HAS_BEARING_ACCURACY_BIT) + out.gnssLocationFlags |= GnssLocationFlags::HAS_BEARING_ACCURACY; + out.latitudeDegrees = in.latitude; + out.longitudeDegrees = in.longitude; + out.altitudeMeters = in.altitude; + out.speedMetersPerSec = in.speed; + out.bearingDegrees = in.bearing; + out.horizontalAccuracyMeters = in.accuracy; + out.verticalAccuracyMeters = in.verticalAccuracy; + out.speedAccuracyMetersPerSecond = in.speedAccuracy; + out.bearingAccuracyDegrees = in.bearingAccuracy; + out.timestamp = static_cast(in.timestamp); +} + +void convertGnssConstellationType(GnssSvType& in, GnssConstellationType& out) +{ + switch(in) { + case GNSS_SV_TYPE_GPS: + out = GnssConstellationType::GPS; + break; + case GNSS_SV_TYPE_SBAS: + out = GnssConstellationType::SBAS; + break; + case GNSS_SV_TYPE_GLONASS: + out = GnssConstellationType::GLONASS; + break; + case GNSS_SV_TYPE_QZSS: + out = GnssConstellationType::QZSS; + break; + case GNSS_SV_TYPE_BEIDOU: + out = GnssConstellationType::BEIDOU; + break; + case GNSS_SV_TYPE_GALILEO: + out = GnssConstellationType::GALILEO; + break; + case GNSS_SV_TYPE_UNKNOWN: + default: + out = GnssConstellationType::UNKNOWN; + break; + } +} + +void convertGnssEphemerisType(GnssEphemerisType& in, GnssDebug::SatelliteEphemerisType& out) +{ + switch(in) { + case GNSS_EPH_TYPE_EPHEMERIS: + out = GnssDebug::SatelliteEphemerisType::EPHEMERIS; + break; + case GNSS_EPH_TYPE_ALMANAC: + out = GnssDebug::SatelliteEphemerisType::ALMANAC_ONLY; + break; + case GNSS_EPH_TYPE_UNKNOWN: + default: + out = GnssDebug::SatelliteEphemerisType::NOT_AVAILABLE; + break; + } +} + +void convertGnssEphemerisSource(GnssEphemerisSource& in, GnssDebug::SatelliteEphemerisSource& out) +{ + switch(in) { + case GNSS_EPH_SOURCE_DEMODULATED: + out = GnssDebug::SatelliteEphemerisSource::DEMODULATED; + break; + case GNSS_EPH_SOURCE_SUPL_PROVIDED: + out = GnssDebug::SatelliteEphemerisSource::SUPL_PROVIDED; + break; + case GNSS_EPH_SOURCE_OTHER_SERVER_PROVIDED: + out = GnssDebug::SatelliteEphemerisSource::OTHER_SERVER_PROVIDED; + break; + case GNSS_EPH_SOURCE_LOCAL: + case GNSS_EPH_SOURCE_UNKNOWN: + default: + out = GnssDebug::SatelliteEphemerisSource::OTHER; + break; + } +} + +void convertGnssEphemerisHealth(GnssEphemerisHealth& in, GnssDebug::SatelliteEphemerisHealth& out) +{ + switch(in) { + case GNSS_EPH_HEALTH_GOOD: + out = GnssDebug::SatelliteEphemerisHealth::GOOD; + break; + case GNSS_EPH_HEALTH_BAD: + out = GnssDebug::SatelliteEphemerisHealth::BAD; + break; + case GNSS_EPH_HEALTH_UNKNOWN: + default: + out = GnssDebug::SatelliteEphemerisHealth::UNKNOWN; + break; + } +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/gnsspps/gnsspps.h b/gps/android/location_api/LocationUtil.h similarity index 60% rename from gps/gnsspps/gnsspps.h rename to gps/android/location_api/LocationUtil.h index 3642f3b..44d5e02 100644 --- a/gps/gnsspps/gnsspps.h +++ b/gps/android/location_api/LocationUtil.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved. +/* 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 @@ -9,7 +9,7 @@ * 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 Foundatoin, nor the names of its + * * 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. * @@ -24,22 +24,31 @@ * 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 _GNSSPPS_H -#define _GNSSPPS_H -#ifdef __cplusplus -extern "C" { -#endif +#ifndef LOCATION_UTIL_H +#define LOCATION_UTIL_H -/* opens the device and fetches from PPS source */ -int initPPS(char *devname); -/* updates the fine time stamp */ -int getPPS(struct timespec *current_ts, struct timespec *current_boottime, struct timespec *last_boottime); -/* stops fetching and closes the device */ -void deInitPPS(); +#include +#include +#include -#ifdef __cplusplus -} -#endif -#endif +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +void convertGnssLocation(Location& in, GnssLocation& out); +void convertGnssConstellationType(GnssSvType& in, GnssConstellationType& out); +void convertGnssEphemerisType(GnssEphemerisType& in, GnssDebug::SatelliteEphemerisType& out); +void convertGnssEphemerisSource(GnssEphemerisSource& in, GnssDebug::SatelliteEphemerisSource& out); +void convertGnssEphemerisHealth(GnssEphemerisHealth& in, GnssDebug::SatelliteEphemerisHealth& out); + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android +#endif // LOCATION_UTIL_H diff --git a/gps/android/location_api/MeasurementAPIClient.cpp b/gps/android/location_api/MeasurementAPIClient.cpp new file mode 100644 index 0000000..dd7ceac --- /dev/null +++ b/gps/android/location_api/MeasurementAPIClient.cpp @@ -0,0 +1,257 @@ +/* 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_NDEBUG 0 +#define LOG_TAG "LocSvc_MeasurementAPIClient" + +#include +#include + +#include "LocationUtil.h" +#include "MeasurementAPIClient.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +static void convertGnssData(GnssMeasurementsNotification& in, + IGnssMeasurementCallback::GnssData& out); +static void convertGnssMeasurement(GnssMeasurementsData& in, + IGnssMeasurementCallback::GnssMeasurement& out); +static void convertGnssClock(GnssMeasurementsClock& in, IGnssMeasurementCallback::GnssClock& out); + +MeasurementAPIClient::MeasurementAPIClient() : + mGnssMeasurementCbIface(nullptr), + mTracking(false) +{ + LOC_LOGD("%s]: ()", __FUNCTION__); +} + +MeasurementAPIClient::~MeasurementAPIClient() +{ + LOC_LOGD("%s]: ()", __FUNCTION__); +} + +// for GpsInterface +Return +MeasurementAPIClient::measurementSetCallback(const sp& callback) +{ + LOC_LOGD("%s]: (%p)", __FUNCTION__, &callback); + + mGnssMeasurementCbIface = callback; + + LocationCallbacks locationCallbacks; + memset(&locationCallbacks, 0, sizeof(LocationCallbacks)); + locationCallbacks.size = sizeof(LocationCallbacks); + + locationCallbacks.trackingCb = nullptr; + locationCallbacks.batchingCb = nullptr; + locationCallbacks.geofenceBreachCb = nullptr; + locationCallbacks.geofenceStatusCb = nullptr; + locationCallbacks.gnssLocationInfoCb = nullptr; + locationCallbacks.gnssNiCb = nullptr; + locationCallbacks.gnssSvCb = nullptr; + locationCallbacks.gnssNmeaCb = nullptr; + + locationCallbacks.gnssMeasurementsCb = nullptr; + if (mGnssMeasurementCbIface != nullptr) { + locationCallbacks.gnssMeasurementsCb = + [this](GnssMeasurementsNotification gnssMeasurementsNotification) { + onGnssMeasurementsCb(gnssMeasurementsNotification); + }; + } + + locAPISetCallbacks(locationCallbacks); + LocationOptions options; + memset(&options, 0, sizeof(LocationOptions)); + options.size = sizeof(LocationOptions); + options.minInterval = 1000; + options.mode = GNSS_SUPL_MODE_STANDALONE; + mTracking = true; + LOC_LOGD("%s]: start tracking session", __FUNCTION__); + locAPIStartTracking(options); + + return IGnssMeasurement::GnssMeasurementStatus::SUCCESS; +} + +// for GpsMeasurementInterface +void MeasurementAPIClient::measurementClose() { + LOC_LOGD("%s]: ()", __FUNCTION__); + mTracking = false; + locAPIStopTracking(); +} + +// callbacks +void MeasurementAPIClient::onGnssMeasurementsCb( + GnssMeasurementsNotification gnssMeasurementsNotification) +{ + LOC_LOGD("%s]: (count: %zu active: %zu)", + __FUNCTION__, gnssMeasurementsNotification.count, mTracking); + if (mTracking) { + if (mGnssMeasurementCbIface != nullptr) { + IGnssMeasurementCallback::GnssData gnssData; + convertGnssData(gnssMeasurementsNotification, gnssData); + auto r = mGnssMeasurementCbIface->GnssMeasurementCb(gnssData); + if (!r.isOk()) { + LOC_LOGE("%s] Error from GnssMeasurementCb description=%s", + __func__, r.description().c_str()); + } + } + } +} + +static void convertGnssMeasurement(GnssMeasurementsData& in, + IGnssMeasurementCallback::GnssMeasurement& out) +{ + memset(&out, 0, sizeof(IGnssMeasurementCallback::GnssMeasurement)); + if (in.flags & GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT) + out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_SNR; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT) + out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_FREQUENCY; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_CYCLES_BIT) + out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_CYCLES; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_BIT) + out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_PHASE; + if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_PHASE_UNCERTAINTY_BIT) + out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_CARRIER_PHASE_UNCERTAINTY; + if (in.flags & GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT) + out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_AUTOMATIC_GAIN_CONTROL; + out.svid = in.svId; + convertGnssConstellationType(in.svType, out.constellation); + out.timeOffsetNs = in.timeOffsetNs; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_CODE_LOCK_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_CODE_LOCK; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_BIT_SYNC_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BIT_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_SUBFRAME_SYNC_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SUBFRAME_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_TOW_DECODED_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_TOW_DECODED; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_MSEC_AMBIGUOUS_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_MSEC_AMBIGUOUS; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_SYMBOL_SYNC_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SYMBOL_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_GLO_STRING_SYNC_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GLO_STRING_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_GLO_TOD_DECODED_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GLO_TOD_DECODED; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_BDS_D2_BIT_SYNC_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BDS_D2_BIT_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_BDS_D2_SUBFRAME_SYNC_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_BDS_D2_SUBFRAME_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1BC_CODE_LOCK_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1BC_CODE_LOCK; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1C_2ND_CODE_LOCK_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1C_2ND_CODE_LOCK; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_GAL_E1B_PAGE_SYNC_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_GAL_E1B_PAGE_SYNC; + if (in.stateMask & GNSS_MEASUREMENTS_STATE_SBAS_SYNC_BIT) + out.state |= IGnssMeasurementCallback::GnssMeasurementState::STATE_SBAS_SYNC; + out.receivedSvTimeInNs = in.receivedSvTimeNs; + out.receivedSvTimeUncertaintyInNs = in.receivedSvTimeUncertaintyNs; + out.cN0DbHz = in.carrierToNoiseDbHz; + out.pseudorangeRateMps = in.pseudorangeRateMps; + out.pseudorangeRateUncertaintyMps = in.pseudorangeRateUncertaintyMps; + if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_VALID_BIT) + out.accumulatedDeltaRangeState |= + IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_VALID; + if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_RESET_BIT) + out.accumulatedDeltaRangeState |= + IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_RESET; + if (in.adrStateMask & GNSS_MEASUREMENTS_ACCUMULATED_DELTA_RANGE_STATE_CYCLE_SLIP_BIT) + out.accumulatedDeltaRangeState |= + IGnssMeasurementCallback::GnssAccumulatedDeltaRangeState::ADR_STATE_CYCLE_SLIP; + out.accumulatedDeltaRangeM = in.adrMeters; + out.accumulatedDeltaRangeUncertaintyM = in.adrUncertaintyMeters; + out.carrierFrequencyHz = in.carrierFrequencyHz; + out.carrierCycles = in.carrierCycles; + out.carrierPhase = in.carrierPhase; + out.carrierPhaseUncertainty = in.carrierPhaseUncertainty; + uint8_t indicator = + static_cast(IGnssMeasurementCallback::GnssMultipathIndicator::INDICATOR_UNKNOWN); + if (in.multipathIndicator & GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_PRESENT) + indicator |= IGnssMeasurementCallback::GnssMultipathIndicator::INDICATOR_PRESENT; + if (in.multipathIndicator & GNSS_MEASUREMENTS_MULTIPATH_INDICATOR_NOT_PRESENT) + indicator |= IGnssMeasurementCallback::GnssMultipathIndicator::INDICATIOR_NOT_PRESENT; + out.multipathIndicator = + static_cast(indicator); + out.snrDb = in.signalToNoiseRatioDb; + out.agcLevelDb = in.agcLevelDb; +} + +static void convertGnssClock(GnssMeasurementsClock& in, IGnssMeasurementCallback::GnssClock& out) +{ + memset(&out, 0, sizeof(IGnssMeasurementCallback::GnssClock)); + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_LEAP_SECOND_BIT) + out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_LEAP_SECOND; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_TIME_UNCERTAINTY_BIT) + out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_TIME_UNCERTAINTY; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_FULL_BIAS_BIT) + out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_FULL_BIAS; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_BIT) + out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_BIAS; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_BIAS_UNCERTAINTY_BIT) + out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_BIAS_UNCERTAINTY; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_BIT) + out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_DRIFT; + if (in.flags & GNSS_MEASUREMENTS_CLOCK_FLAGS_DRIFT_UNCERTAINTY_BIT) + out.gnssClockFlags |= IGnssMeasurementCallback::GnssClockFlags::HAS_DRIFT_UNCERTAINTY; + out.leapSecond = in.leapSecond; + out.timeNs = in.timeNs; + out.timeUncertaintyNs = in.timeUncertaintyNs; + out.fullBiasNs = in.fullBiasNs; + out.biasNs = in.biasNs; + out.biasUncertaintyNs = in.biasUncertaintyNs; + out.driftNsps = in.driftNsps; + out.driftUncertaintyNsps = in.driftUncertaintyNsps; + out.hwClockDiscontinuityCount = in.hwClockDiscontinuityCount; +} + +static void convertGnssData(GnssMeasurementsNotification& in, + IGnssMeasurementCallback::GnssData& out) +{ + out.measurementCount = in.count; + if (out.measurementCount > static_cast(GnssMax::SVS_COUNT)) { + LOC_LOGW("%s]: Too many measurement %zd. Clamps to %d.", + __FUNCTION__, out.measurementCount, GnssMax::SVS_COUNT); + out.measurementCount = static_cast(GnssMax::SVS_COUNT); + } + for (size_t i = 0; i < out.measurementCount; i++) { + convertGnssMeasurement(in.measurements[i], out.measurements[i]); + } + convertGnssClock(in.clock, out.clock); +} + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gps/android/location_api/MeasurementAPIClient.h b/gps/android/location_api/MeasurementAPIClient.h new file mode 100644 index 0000000..422564d --- /dev/null +++ b/gps/android/location_api/MeasurementAPIClient.h @@ -0,0 +1,75 @@ +/* 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 MEASUREMENT_API_CLINET_H +#define MEASUREMENT_API_CLINET_H + + +#include +#include +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V1_0 { +namespace implementation { + +using ::android::hardware::gnss::V1_0::IGnssMeasurement; +using ::android::sp; + +class MeasurementAPIClient : public LocationAPIClientBase +{ +public: + MeasurementAPIClient(); + virtual ~MeasurementAPIClient(); + MeasurementAPIClient(const MeasurementAPIClient&) = delete; + MeasurementAPIClient& operator=(const MeasurementAPIClient&) = delete; + + // for GpsMeasurementInterface + Return measurementSetCallback( + const sp& callback); + void measurementClose(); + + // callbacks we are interested in + void onGnssMeasurementsCb(GnssMeasurementsNotification gnssMeasurementsNotification) final; + +private: + sp mGnssMeasurementCbIface; + + bool mTracking; +}; + +} // namespace implementation +} // namespace V1_0 +} // namespace gnss +} // namespace hardware +} // namespace android +#endif // MEASUREMENT_API_CLINET_H diff --git a/gps/android/service.cpp b/gps/android/service.cpp new file mode 100644 index 0000000..5779e67 --- /dev/null +++ b/gps/android/service.cpp @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2017, The Linux Foundation. All rights reserved. + * Not a Contribution + */ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "android.hardware.gnss@1.0-service-qti" + +#include +#include + +using android::hardware::gnss::V1_0::IGnss; +using android::hardware::defaultPassthroughServiceImplementation; + +int main() { + return defaultPassthroughServiceImplementation(); +} diff --git a/gps/configure.ac b/gps/configure.ac new file mode 100644 index 0000000..ec41c86 --- /dev/null +++ b/gps/configure.ac @@ -0,0 +1,91 @@ +# configure.ac -- Autoconf script for gps loc_hal +# +# Process this file with autoconf to produce a configure script + +# Requires autoconf tool later than 2.61 +AC_PREREQ(2.61) +# Initialize the gps loc-hal package version 1.0.0 +AC_INIT([loc-hal],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([utils/loc_cfg.cpp]) +# 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([QMI], [qmi]) +AC_SUBST([QMI_CFLAGS]) +AC_SUBST([QMI_LIBS]) + +PKG_CHECK_MODULES([QMIF], [qmi-framework]) +AC_SUBST([QMIF_CFLAGS]) +AC_SUBST([QMIF_LIBS]) + +PKG_CHECK_MODULES([DATA], [data]) +AC_SUBST([DATA_CFLAGS]) +AC_SUBST([DATA_LIBS]) + +PKG_CHECK_MODULES([LOCPLA], [loc-pla]) +AC_SUBST([LOCPLA_CFLAGS]) +AC_SUBST([LOCPLA_LIBS]) + +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_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 \ + core/Makefile \ + location/Makefile \ + gnss/Makefile \ + loc-hal.pc \ + ]) + +AC_OUTPUT diff --git a/gps/core/Android.mk b/gps/core/Android.mk index 1782229..dba0b0a 100644 --- a/gps/core/Android.mk +++ b/gps/core/Android.mk @@ -1,3 +1,4 @@ +ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) ifneq ($(BUILD_TINY_ANDROID),true) LOCAL_PATH := $(call my-dir) @@ -5,8 +6,8 @@ LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := libloc_core -LOCAL_MODULE_OWNER := qcom - +LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib +LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64 LOCAL_MODULE_TAGS := optional ifeq ($(TARGET_DEVICE),apq8026_lw) @@ -21,6 +22,7 @@ LOCAL_SHARED_LIBRARIES := \ libcutils \ libgps.utils \ libdl \ + liblog \ libloc_pla LOCAL_SRC_FILES += \ @@ -28,32 +30,40 @@ LOCAL_SRC_FILES += \ LocAdapterBase.cpp \ ContextBase.cpp \ LocDualContext.cpp \ - loc_core_log.cpp + loc_core_log.cpp \ + data-items/DataItemsFactoryProxy.cpp \ + data-items/common/ClientIndex.cpp \ + data-items/common/DataItemIndex.cpp \ + data-items/common/IndexFactory.cpp \ + SystemStatusOsObserver.cpp \ + SystemStatus.cpp LOCAL_CFLAGS += \ -fno-short-enums \ -D_ANDROID_ LOCAL_C_INCLUDES:= \ - $(TARGET_OUT_HEADERS)/gps.utils \ - $(TARGET_OUT_HEADERS)/libflp \ - $(TARGET_OUT_HEADERS)/libloc_pla + $(LOCAL_PATH)/data-items \ + $(LOCAL_PATH)/data-items/common \ + $(LOCAL_PATH)/observer \ -LOCAL_COPY_HEADERS_TO:= libloc_core/ -LOCAL_COPY_HEADERS:= \ - LocApiBase.h \ - LocAdapterBase.h \ - ContextBase.h \ - LocDualContext.h \ - LBSProxyBase.h \ - UlpProxyBase.h \ - gps_extended_c.h \ - gps_extended.h \ - loc_core_log.h \ - LocAdapterProxyBase.h +LOCAL_HEADER_LIBRARIES := \ + libgps.utils_headers \ + libloc_pla_headers \ + liblocation_api_headers -LOCAL_PRELINK_MODULE := false +LOCAL_CFLAGS += $(GNSS_CFLAGS) include $(BUILD_SHARED_LIBRARY) +include $(CLEAR_VARS) +LOCAL_MODULE := libloc_core_headers +LOCAL_EXPORT_C_INCLUDE_DIRS := \ + $(LOCAL_PATH) \ + $(LOCAL_PATH)/data-items \ + $(LOCAL_PATH)/data-items/common \ + $(LOCAL_PATH)/observer +include $(BUILD_HEADER_LIBRARY) + endif # not BUILD_TINY_ANDROID +endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE diff --git a/gps/core/ContextBase.cpp b/gps/core/ContextBase.cpp index d2f9070..8af48fc 100644 --- a/gps/core/ContextBase.cpp +++ b/gps/core/ContextBase.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014,2016-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 @@ -26,7 +26,7 @@ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ -#define LOG_NDDEBUG 0 +#define LOG_NDEBUG 0 #define LOG_TAG "LocSvc_CtxBase" #include @@ -40,8 +40,114 @@ namespace loc_core { -loc_gps_cfg_s_type ContextBase::mGps_conf {0}; -loc_sap_cfg_s_type ContextBase::mSap_conf {0}; +loc_gps_cfg_s_type ContextBase::mGps_conf {}; +loc_sap_cfg_s_type ContextBase::mSap_conf {}; + +const loc_param_s_type ContextBase::mGps_conf_table[] = +{ + {"GPS_LOCK", &mGps_conf.GPS_LOCK, NULL, 'n'}, + {"SUPL_VER", &mGps_conf.SUPL_VER, NULL, 'n'}, + {"LPP_PROFILE", &mGps_conf.LPP_PROFILE, NULL, 'n'}, + {"A_GLONASS_POS_PROTOCOL_SELECT", &mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT, NULL, 'n'}, + {"LPPE_CP_TECHNOLOGY", &mGps_conf.LPPE_CP_TECHNOLOGY, NULL, 'n'}, + {"LPPE_UP_TECHNOLOGY", &mGps_conf.LPPE_UP_TECHNOLOGY, NULL, 'n'}, + {"AGPS_CERT_WRITABLE_MASK", &mGps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'}, + {"SUPL_MODE", &mGps_conf.SUPL_MODE, NULL, 'n'}, + {"SUPL_ES", &mGps_conf.SUPL_ES, NULL, 'n'}, + {"INTERMEDIATE_POS", &mGps_conf.INTERMEDIATE_POS, NULL, 'n'}, + {"ACCURACY_THRES", &mGps_conf.ACCURACY_THRES, NULL, 'n'}, + {"NMEA_PROVIDER", &mGps_conf.NMEA_PROVIDER, NULL, 'n'}, + {"CAPABILITIES", &mGps_conf.CAPABILITIES, NULL, 'n'}, + {"XTRA_VERSION_CHECK", &mGps_conf.XTRA_VERSION_CHECK, NULL, 'n'}, + {"XTRA_SERVER_1", &mGps_conf.XTRA_SERVER_1, NULL, 's'}, + {"XTRA_SERVER_2", &mGps_conf.XTRA_SERVER_2, NULL, 's'}, + {"XTRA_SERVER_3", &mGps_conf.XTRA_SERVER_3, NULL, 's'}, + {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", &mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL, NULL, 'n'}, + {"AGPS_CONFIG_INJECT", &mGps_conf.AGPS_CONFIG_INJECT, NULL, 'n'}, + {"EXTERNAL_DR_ENABLED", &mGps_conf.EXTERNAL_DR_ENABLED, NULL, 'n'}, +}; + +const loc_param_s_type ContextBase::mSap_conf_table[] = +{ + {"GYRO_BIAS_RANDOM_WALK", &mSap_conf.GYRO_BIAS_RANDOM_WALK, &mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'}, + {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, + {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, + {"RATE_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, + {"VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY", &mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY, &mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, + {"SENSOR_ACCEL_BATCHES_PER_SEC", &mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, NULL, 'n'}, + {"SENSOR_ACCEL_SAMPLES_PER_BATCH", &mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, NULL, 'n'}, + {"SENSOR_GYRO_BATCHES_PER_SEC", &mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC, NULL, 'n'}, + {"SENSOR_GYRO_SAMPLES_PER_BATCH", &mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, NULL, 'n'}, + {"SENSOR_ACCEL_BATCHES_PER_SEC_HIGH", &mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, NULL, 'n'}, + {"SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH", &mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, NULL, 'n'}, + {"SENSOR_GYRO_BATCHES_PER_SEC_HIGH", &mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, NULL, 'n'}, + {"SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH", &mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, NULL, 'n'}, + {"SENSOR_CONTROL_MODE", &mSap_conf.SENSOR_CONTROL_MODE, NULL, 'n'}, + {"SENSOR_USAGE", &mSap_conf.SENSOR_USAGE, NULL, 'n'}, + {"SENSOR_ALGORITHM_CONFIG_MASK", &mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'}, + {"SENSOR_PROVIDER", &mSap_conf.SENSOR_PROVIDER, NULL, 'n'} +}; + +void ContextBase::readConfig() +{ + /*Defaults for gps.conf*/ + mGps_conf.INTERMEDIATE_POS = 0; + mGps_conf.ACCURACY_THRES = 0; + mGps_conf.NMEA_PROVIDER = 0; + mGps_conf.GPS_LOCK = 0; + mGps_conf.SUPL_VER = 0x10000; + mGps_conf.SUPL_MODE = 0x1; + mGps_conf.SUPL_ES = 0; + mGps_conf.CAPABILITIES = 0x7; + /* LTE Positioning Profile configuration is disable by default*/ + mGps_conf.LPP_PROFILE = 0; + /*By default no positioning protocol is selected on A-GLONASS system*/ + mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0; + /*XTRA version check is disabled by default*/ + mGps_conf.XTRA_VERSION_CHECK=0; + /*Use emergency PDN by default*/ + mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1; + /* By default no LPPe CP technology is enabled*/ + mGps_conf.LPPE_CP_TECHNOLOGY = 0; + /* By default no LPPe UP technology is enabled*/ + mGps_conf.LPPE_UP_TECHNOLOGY = 0; + + /*Defaults for sap.conf*/ + mSap_conf.GYRO_BIAS_RANDOM_WALK = 0; + mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2; + mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5; + mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC = 2; + mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH = 5; + mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH = 4; + mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH = 25; + mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH = 4; + mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH = 25; + mSap_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */ + mSap_conf.SENSOR_USAGE = 0; /* Enabled */ + mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/ + /* Values MUST be set by OEMs in configuration for sensor-assisted + navigation to work. There are NO default values */ + mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0; + mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0; + mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0; + mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0; + mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0; + mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; + mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; + mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; + mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; + /* default provider is SSC */ + mSap_conf.SENSOR_PROVIDER = 1; + + /* None of the 10 slots for agps certificates are writable by default */ + mGps_conf.AGPS_CERT_WRITABLE_MASK = 0; + + /* inject supl config to modem with config values from config.xml or gps.conf, default 1 */ + mGps_conf.AGPS_CONFIG_INJECT = 1; + + UTIL_READ_CONF(LOC_PATH_GPS_CONF, mGps_conf_table); + UTIL_READ_CONF(LOC_PATH_SAP_CONF, mSap_conf_table); +} uint32_t ContextBase::getCarrierCapabilities() { #define carrierMSA (uint32_t)0x2 @@ -88,31 +194,35 @@ LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask) { LocApiBase* locApi = NULL; - if (NULL == (locApi = mLBSProxy->getLocApi(mMsgTask, exMask, this))) { - void *handle = NULL; - //try to see if LocApiV02 is present - if ((handle = dlopen("libloc_api_v02.so", RTLD_NOW)) != NULL) { - LOC_LOGD("%s:%d]: libloc_api_v02.so is present", __func__, __LINE__); - getLocApi_t* getter = (getLocApi_t*) dlsym(handle, "getLocApi"); - if (getter != NULL) { - LOC_LOGD("%s:%d]: getter is not NULL for LocApiV02", __func__, - __LINE__); - locApi = (*getter)(mMsgTask, exMask, this); - } - } - // only RPC is the option now - else { - LOC_LOGD("%s:%d]: libloc_api_v02.so is NOT present. Trying RPC", - __func__, __LINE__); - handle = dlopen("libloc_api-rpc-qc.so", RTLD_NOW); - if (NULL != handle) { + // Check the target + if (TARGET_NO_GNSS != loc_get_target()){ + + if (NULL == (locApi = mLBSProxy->getLocApi(mMsgTask, exMask, this))) { + void *handle = NULL; + //try to see if LocApiV02 is present + if ((handle = dlopen("libloc_api_v02.so", RTLD_NOW)) != NULL) { + LOC_LOGD("%s:%d]: libloc_api_v02.so is present", __func__, __LINE__); getLocApi_t* getter = (getLocApi_t*) dlsym(handle, "getLocApi"); - if (NULL != getter) { - LOC_LOGD("%s:%d]: getter is not NULL in RPC", __func__, + if (getter != NULL) { + LOC_LOGD("%s:%d]: getter is not NULL for LocApiV02", __func__, __LINE__); locApi = (*getter)(mMsgTask, exMask, this); } } + // only RPC is the option now + else { + LOC_LOGD("%s:%d]: libloc_api_v02.so is NOT present. Trying RPC", + __func__, __LINE__); + handle = dlopen("libloc_api-rpc-qc.so", RTLD_NOW); + if (NULL != handle) { + getLocApi_t* getter = (getLocApi_t*) dlsym(handle, "getLocApi"); + if (NULL != getter) { + LOC_LOGD("%s:%d]: getter is not NULL in RPC", __func__, + __LINE__); + locApi = (*getter)(mMsgTask, exMask, this); + } + } + } } } diff --git a/gps/core/ContextBase.h b/gps/core/ContextBase.h index 87d2acf..83de999 100644 --- a/gps/core/ContextBase.h +++ b/gps/core/ContextBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-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 @@ -34,6 +34,7 @@ #include #include #include +#include #define MAX_XTRA_SERVER_URL_LENGTH 256 @@ -105,6 +106,8 @@ class LocAdapterBase; class ContextBase { static LBSProxyBase* getLBSProxy(const char* libName); LocApiBase* createLocApi(LOC_API_ADAPTER_EVENT_MASK_T excludedMask); + static const loc_param_s_type mGps_conf_table[]; + static const loc_param_s_type mSap_conf_table[]; protected: const LBSProxyBase* mLBSProxy; const MsgTask* mMsgTask; @@ -135,6 +138,7 @@ public: static loc_gps_cfg_s_type mGps_conf; static loc_sap_cfg_s_type mSap_conf; + void readConfig(); static uint32_t getCarrierCapabilities(); }; diff --git a/gps/core/LocAdapterBase.cpp b/gps/core/LocAdapterBase.cpp index 6a3f969..3943819 100644 --- a/gps/core/LocAdapterBase.cpp +++ b/gps/core/LocAdapterBase.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016-2017The 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 @@ -26,7 +26,7 @@ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ -#define LOG_NDDEBUG 0 +#define LOG_NDEBUG 0 #define LOG_TAG "LocSvc_LocAdapterBase" #include @@ -50,6 +50,16 @@ LocAdapterBase::LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask, mLocApi->addAdapter(this); } +uint32_t LocAdapterBase::mSessionIdCounter(1); + +uint32_t LocAdapterBase::generateSessionId() +{ + if (++mSessionIdCounter == 0xFFFFFFFF) + mSessionIdCounter = 1; + + return mSessionIdCounter; +} + void LocAdapterBase::handleEngineUpEvent() { if (mLocAdapterProxyBase) { @@ -65,46 +75,45 @@ void LocAdapterBase::handleEngineDownEvent() } void LocAdapterBase:: - reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask) { - if (mLocAdapterProxyBase == NULL || - !mLocAdapterProxyBase->reportPosition(location, - locationExtended, - status, - loc_technology_mask)) { + reportPositionEvent(const UlpLocation& location, + const GpsLocationExtended& locationExtended, + enum loc_sess_status status, + LocPosTechMask loc_technology_mask, + bool /*fromUlp*/) { + if (mLocAdapterProxyBase != NULL) { + mLocAdapterProxyBase->reportPositionEvent((UlpLocation&)location, + (GpsLocationExtended&)locationExtended, + status, + loc_technology_mask); + } else { DEFAULT_IMPL() } } void LocAdapterBase:: - reportSv(GnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt) + reportSvEvent(const GnssSvNotification& /*svNotify*/, bool /*fromUlp*/) DEFAULT_IMPL() void LocAdapterBase:: - reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet) + reportSvMeasurementEvent(GnssSvMeasurementSet &/*svMeasurementSet*/) DEFAULT_IMPL() void LocAdapterBase:: - reportSvPolynomial(GnssSvPolynomial &svPolynomial) + reportSvPolynomialEvent(GnssSvPolynomial &/*svPolynomial*/) DEFAULT_IMPL() void LocAdapterBase:: - reportStatus(GpsStatusValue status) + reportStatus(LocGpsStatusValue /*status*/) DEFAULT_IMPL() void LocAdapterBase:: - reportNmea(const char* nmea, int length) + reportNmeaEvent(const char* /*nmea*/, size_t /*length*/, bool /*fromUlp*/) DEFAULT_IMPL() bool LocAdapterBase:: - reportXtraServer(const char* url1, const char* url2, - const char* url3, const int maxlength) + reportXtraServer(const char* /*url1*/, const char* /*url2*/, + const char* /*url3*/, const int /*maxlength*/) DEFAULT_IMPL(false) bool LocAdapterBase:: @@ -120,15 +129,15 @@ bool LocAdapterBase:: DEFAULT_IMPL(false) bool LocAdapterBase:: - requestATL(int connHandle, AGpsType agps_type) + requestATL(int /*connHandle*/, LocAGpsType /*agps_type*/) DEFAULT_IMPL(false) bool LocAdapterBase:: - releaseATL(int connHandle) + releaseATL(int /*connHandle*/) DEFAULT_IMPL(false) bool LocAdapterBase:: - requestSuplES(int connHandle) + requestSuplES(int /*connHandle*/) DEFAULT_IMPL(false) bool LocAdapterBase:: @@ -140,10 +149,16 @@ bool LocAdapterBase:: DEFAULT_IMPL(false) bool LocAdapterBase:: - requestNiNotify(GpsNiNotification ¬ify, const void* data) + requestNiNotifyEvent(const GnssNiNotification &/*notify*/, const void* /*data*/) DEFAULT_IMPL(false) void LocAdapterBase:: - reportGnssMeasurementData(GnssData &gnssMeasurementData) + reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& /*measurements*/, + int /*msInWeek*/) DEFAULT_IMPL() + +bool LocAdapterBase:: + reportWwanZppFix(LocGpsLocation &/*zppLoc*/) +DEFAULT_IMPL(false) + } // namespace loc_core diff --git a/gps/core/LocAdapterBase.h b/gps/core/LocAdapterBase.h index af25138..e7beca8 100644 --- a/gps/core/LocAdapterBase.h +++ b/gps/core/LocAdapterBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014,2016 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016-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 @@ -32,19 +32,39 @@ #include #include #include +#include +#include + +typedef struct LocationSessionKey { + LocationAPI* client; + uint32_t id; + inline LocationSessionKey(LocationAPI* _client, uint32_t _id) : + client(_client), id(_id) {} +} LocationSessionKey; +inline bool operator <(LocationSessionKey const& left, LocationSessionKey const& right) { + return left.id < right.id || (left.id == right.id && left.client < right.client); +} +inline bool operator ==(LocationSessionKey const& left, LocationSessionKey const& right) { + return left.id == right.id && left.client == right.client; +} +inline bool operator !=(LocationSessionKey const& left, LocationSessionKey const& right) { + return left.id != right.id || left.client != right.client; +} +typedef std::map LocationSessionMap; namespace loc_core { class LocAdapterProxyBase; class LocAdapterBase { +private: + static uint32_t mSessionIdCounter; protected: LOC_API_ADAPTER_EVENT_MASK_T mEvtMask; ContextBase* mContext; LocApiBase* mLocApi; LocAdapterProxyBase* mLocAdapterProxyBase; const MsgTask* mMsgTask; - inline LocAdapterBase(const MsgTask* msgTask) : mEvtMask(0), mContext(NULL), mLocApi(NULL), mLocAdapterProxyBase(NULL), mMsgTask(msgTask) {} @@ -70,11 +90,19 @@ public: } inline void updateEvtMask(LOC_API_ADAPTER_EVENT_MASK_T event, - loc_registration_mask_status isEnabled) + loc_registration_mask_status status) { - mEvtMask = - isEnabled == LOC_REGISTRATION_MASK_ENABLED ? (mEvtMask|event):(mEvtMask&~event); - + switch(status) { + case (LOC_REGISTRATION_MASK_ENABLED): + mEvtMask = mEvtMask | event; + break; + case (LOC_REGISTRATION_MASK_DISABLED): + mEvtMask = mEvtMask &~ event; + break; + case (LOC_REGISTRATION_MASK_SET): + mEvtMask = event; + break; + } mLocApi->updateEvtMask(); } @@ -82,48 +110,49 @@ public: return mLocApi->isFeatureSupported(featureVal); } + uint32_t generateSessionId(); + // This will be overridden by the individual adapters // if necessary. - inline virtual void setUlpProxy(UlpProxyBase* ulp) { + inline virtual void setUlpProxyCommand(UlpProxyBase* ulp) { (void)ulp; } virtual void handleEngineUpEvent(); virtual void handleEngineDownEvent(); - inline virtual void setPositionModeInt(LocPosMode& posMode) { + inline virtual void setPositionModeCommand(LocPosMode& posMode) { (void)posMode; } - virtual void startFixInt() {} - virtual void stopFixInt() {} - virtual void getZppInt() {} - virtual void reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask); - virtual void reportSv(GnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt); - virtual void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet); - virtual void reportSvPolynomial(GnssSvPolynomial &svPolynomial); - virtual void reportStatus(GpsStatusValue status); - virtual void reportNmea(const char* nmea, int length); + virtual void startTrackingCommand() {} + virtual void stopTrackingCommand() {} + virtual void getZppCommand() {} + virtual void reportPositionEvent(const UlpLocation& location, + const GpsLocationExtended& locationExtended, + enum loc_sess_status status, + LocPosTechMask loc_technology_mask, + bool fromUlp=false); + virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp=false); + virtual void reportNmeaEvent(const char* nmea, size_t length, bool fromUlp=false); + virtual void reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet); + virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial); + virtual void reportStatus(LocGpsStatusValue status); virtual bool reportXtraServer(const char* url1, const char* url2, const char* url3, const int maxlength); virtual bool requestXtraData(); virtual bool requestTime(); virtual bool requestLocation(); - virtual bool requestATL(int connHandle, AGpsType agps_type); + virtual bool requestATL(int connHandle, LocAGpsType agps_type); virtual bool releaseATL(int connHandle); virtual bool requestSuplES(int connHandle); virtual bool reportDataCallOpened(); virtual bool reportDataCallClosed(); - virtual bool requestNiNotify(GpsNiNotification ¬ify, - const void* data); + virtual bool requestNiNotifyEvent(const GnssNiNotification ¬ify, const void* data); inline virtual bool isInSession() { return false; } ContextBase* getContext() const { return mContext; } - virtual void reportGnssMeasurementData(GnssData &gnssMeasurementData); + virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurements, + int msInWeek); + virtual bool reportWwanZppFix(LocGpsLocation &zppLoc); }; } // namespace loc_core diff --git a/gps/core/LocAdapterProxyBase.h b/gps/core/LocAdapterProxyBase.h index 82cba6b..044f59b 100644 --- a/gps/core/LocAdapterProxyBase.h +++ b/gps/core/LocAdapterProxyBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2014 The Linux Foundation. All rights reserved. +/* Copyright (c) 2014, 2016-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 @@ -51,22 +51,25 @@ protected: mLocAdapterBase->updateEvtMask(event,isEnabled); } + inline uint32_t generateSessionId() { + return mLocAdapterBase->generateSessionId(); + } public: inline ContextBase* getContext() const { return mLocAdapterBase->getContext(); } + inline virtual void handleEngineUpEvent() {}; inline virtual void handleEngineDownEvent() {}; - inline virtual bool reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask) { + inline virtual void reportPositionEvent(UlpLocation &location, + GpsLocationExtended &locationExtended, + enum loc_sess_status status, + LocPosTechMask loc_technology_mask) { (void)location; (void)locationExtended; (void)status; (void)loc_technology_mask; - return false; } }; diff --git a/gps/core/LocApiBase.cpp b/gps/core/LocApiBase.cpp index fdfc537..e0845de 100644 --- a/gps/core/LocApiBase.cpp +++ b/gps/core/LocApiBase.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014,2016 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016-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 @@ -26,10 +26,11 @@ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ -#define LOG_NDDEBUG 0 +#define LOG_NDEBUG 0 //Define to enable LOGV #define LOG_TAG "LocSvc_LocApiBase" #include +#include #include #include #include @@ -96,10 +97,10 @@ struct LocSsrMsg : public LocMsg { mLocApi->close(); mLocApi->open(mLocApi->getEvtMask()); } - inline void locallog() { + inline void locallog() const { LOC_LOGV("LocSsrMsg"); } - inline virtual void log() { + inline virtual void log() const { locallog(); } }; @@ -116,11 +117,11 @@ struct LocOpenMsg : public LocMsg { inline virtual void proc() const { mLocApi->open(mMask); } - inline void locallog() { + inline void locallog() const { LOC_LOGV("%s:%d]: LocOpen Mask: %x\n", __func__, __LINE__, mMask); } - inline virtual void log() { + inline virtual void log() const { locallog(); } }; @@ -128,8 +129,8 @@ struct LocOpenMsg : public LocMsg { LocApiBase::LocApiBase(const MsgTask* msgTask, LOC_API_ADAPTER_EVENT_MASK_T excludedMask, ContextBase* context) : - mExcludedMask(excludedMask), mMsgTask(msgTask), - mMask(0), mSupportedMsg(0), mContext(context) + mMsgTask(msgTask), mContext(context), mSupportedMsg(0), + mMask(0), mExcludedMask(excludedMask) { memset(mLocAdapters, 0, sizeof(mLocAdapters)); memset(mFeaturesSupported, 0, sizeof(mFeaturesSupported)); @@ -227,65 +228,70 @@ void LocApiBase::handleEngineDownEvent() TO_ALL_LOCADAPTERS(mLocAdapters[i]->handleEngineDownEvent()); } -void LocApiBase::reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, +void LocApiBase::reportPosition(UlpLocation& location, + GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask) { // print the location info before delivering - LOC_LOGV("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n " + LOC_LOGD("flags: %d\n source: %d\n latitude: %f\n longitude: %f\n " "altitude: %f\n speed: %f\n bearing: %f\n accuracy: %f\n " - "timestamp: %lld\n rawDataSize: %d\n rawData: %p\n " - "Session status: %d\n Technology mask: %u", + "timestamp: %" PRId64 "\n rawDataSize: %d\n rawData: %p\n " + "Session status: %d\n Technology mask: %u\n " + "SV used in fix (gps/glo/bds/gal/qzss) : \ + (%" PRIx64 "/%" PRIx64 "/%" PRIx64 "/%" PRIx64 "/%" PRIx64 ")", location.gpsLocation.flags, location.position_source, location.gpsLocation.latitude, location.gpsLocation.longitude, location.gpsLocation.altitude, location.gpsLocation.speed, location.gpsLocation.bearing, location.gpsLocation.accuracy, location.gpsLocation.timestamp, location.rawDataSize, - location.rawData, status, loc_technology_mask); + location.rawData, status, loc_technology_mask, + locationExtended.gnss_sv_used_ids.gps_sv_used_ids_mask, + locationExtended.gnss_sv_used_ids.glo_sv_used_ids_mask, + locationExtended.gnss_sv_used_ids.bds_sv_used_ids_mask, + locationExtended.gnss_sv_used_ids.gal_sv_used_ids_mask, + locationExtended.gnss_sv_used_ids.qzss_sv_used_ids_mask); // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS( - mLocAdapters[i]->reportPosition(location, - locationExtended, - locationExt, - status, - loc_technology_mask) + mLocAdapters[i]->reportPositionEvent(location, locationExtended, + status, loc_technology_mask) ); } -void LocApiBase::reportSv(GnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt) +void LocApiBase::reportWwanZppFix(LocGpsLocation &zppLoc) +{ + // loop through adapters, and deliver to the first handling adapter. + TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportWwanZppFix(zppLoc)); +} + +void LocApiBase::reportSv(GnssSvNotification& svNotify) { const char* constellationString[] = { "Unknown", "GPS", "SBAS", "GLONASS", "QZSS", "BEIDOU", "GALILEO" }; // print the SV info before delivering - LOC_LOGV("num sv: %d\n" + LOC_LOGV("num sv: %zu\n" " sv: constellation svid cN0" " elevation azimuth flags", - svStatus.num_svs); - for (int i = 0; i < svStatus.num_svs && i < GNSS_MAX_SVS; i++) { - if (svStatus.gnss_sv_list[i].constellation > + svNotify.count); + for (size_t i = 0; i < svNotify.count && i < LOC_GNSS_MAX_SVS; i++) { + if (svNotify.gnssSvs[i].type > sizeof(constellationString) / sizeof(constellationString[0]) - 1) { - svStatus.gnss_sv_list[i].constellation = 0; + svNotify.gnssSvs[i].type = GNSS_SV_TYPE_UNKNOWN; } - LOC_LOGV(" %03d: %*s %02d %f %f %f 0x%02X", + LOC_LOGV(" %03zu: %*s %02d %f %f %f 0x%02X", i, 13, - constellationString[svStatus.gnss_sv_list[i].constellation], - svStatus.gnss_sv_list[i].svid, - svStatus.gnss_sv_list[i].c_n0_dbhz, - svStatus.gnss_sv_list[i].elevation, - svStatus.gnss_sv_list[i].azimuth, - svStatus.gnss_sv_list[i].flags); + constellationString[svNotify.gnssSvs[i].type], + svNotify.gnssSvs[i].svId, + svNotify.gnssSvs[i].cN0Dbhz, + svNotify.gnssSvs[i].elevation, + svNotify.gnssSvs[i].azimuth, + svNotify.gnssSvs[i].gnssSvOptionsMask); } // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS( - mLocAdapters[i]->reportSv(svStatus, - locationExtended, - svExt) + mLocAdapters[i]->reportSvEvent(svNotify) ); } @@ -293,7 +299,7 @@ void LocApiBase::reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet) { // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS( - mLocAdapters[i]->reportSvMeasurement(svMeasurementSet) + mLocAdapters[i]->reportSvMeasurementEvent(svMeasurementSet) ); } @@ -301,11 +307,11 @@ void LocApiBase::reportSvPolynomial(GnssSvPolynomial &svPolynomial) { // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS( - mLocAdapters[i]->reportSvPolynomial(svPolynomial) + mLocAdapters[i]->reportSvPolynomialEvent(svPolynomial) ); } -void LocApiBase::reportStatus(GpsStatusValue status) +void LocApiBase::reportStatus(LocGpsStatusValue status) { // loop through adapters, and deliver to all adapters. TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportStatus(status)); @@ -314,7 +320,7 @@ void LocApiBase::reportStatus(GpsStatusValue status) void LocApiBase::reportNmea(const char* nmea, int length) { // loop through adapters, and deliver to all adapters. - TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmea(nmea, length)); + TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportNmeaEvent(nmea, length)); } void LocApiBase::reportXtraServer(const char* url1, const char* url2, @@ -343,7 +349,7 @@ void LocApiBase::requestLocation() TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestLocation()); } -void LocApiBase::requestATL(int connHandle, AGpsType agps_type) +void LocApiBase::requestATL(int connHandle, LocAGpsType agps_type) { // loop through adapters, and deliver to the first handling adapter. TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestATL(connHandle, agps_type)); @@ -373,10 +379,10 @@ void LocApiBase::reportDataCallClosed() TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->reportDataCallClosed()); } -void LocApiBase::requestNiNotify(GpsNiNotification ¬ify, const void* data) +void LocApiBase::requestNiNotify(GnssNiNotification ¬ify, const void* data) { // loop through adapters, and deliver to the first handling adapter. - TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotify(notify, data)); + TO_1ST_HANDLING_LOCADAPTERS(mLocAdapters[i]->requestNiNotifyEvent(notify, data)); } void LocApiBase::saveSupportedMsgList(uint64_t supportedMsgList) @@ -395,14 +401,15 @@ void* LocApiBase :: getSibling() LocApiProxyBase* LocApiBase :: getLocApiProxy() DEFAULT_IMPL(NULL) -void LocApiBase::reportGnssMeasurementData(GnssData &gnssMeasurementData) +void LocApiBase::reportGnssMeasurementData(GnssMeasurementsNotification& measurements, + int msInWeek) { // loop through adapters, and deliver to all adapters. - TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssMeasurementData(gnssMeasurementData)); + TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssMeasurementDataEvent(measurements, msInWeek)); } enum loc_api_adapter_err LocApiBase:: - open(LOC_API_ADAPTER_EVENT_MASK_T mask) + open(LOC_API_ADAPTER_EVENT_MASK_T /*mask*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: @@ -410,35 +417,35 @@ enum loc_api_adapter_err LocApiBase:: DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - startFix(const LocPosMode& posMode) + startFix(const LocPosMode& /*posMode*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: stopFix() DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +LocationError LocApiBase:: + deleteAidingData(const GnssAidingData& /*data*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) + enum loc_api_adapter_err LocApiBase:: - deleteAidingData(GpsAidingData f) + enableData(int /*enable*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - enableData(int enable) + setAPN(char* /*apn*/, int /*len*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setAPN(char* apn, int len) + injectPosition(double /*latitude*/, double /*longitude*/, float /*accuracy*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - injectPosition(double latitude, double longitude, float accuracy) + setTime(LocGpsUtcTime /*time*/, int64_t /*timeReference*/, int /*uncertainty*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setTime(GpsUtcTime time, int64_t timeReference, int uncertainty) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - setXtraData(char* data, int length) + setXtraData(char* /*data*/, int /*length*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: @@ -446,104 +453,108 @@ enum loc_api_adapter_err LocApiBase:: DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - atlOpenStatus(int handle, int is_succ, char* apn, - AGpsBearerType bear, AGpsType agpsType) + atlOpenStatus(int /*handle*/, int /*is_succ*/, char* /*apn*/, + AGpsBearerType /*bear*/, LocAGpsType /*agpsType*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - atlCloseStatus(int handle, int is_succ) + atlCloseStatus(int /*handle*/, int /*is_succ*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setPositionMode(const LocPosMode& posMode) + setPositionMode(const LocPosMode& /*posMode*/) +DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) + +LocationError LocApiBase:: + setServer(const char* /*url*/, int /*len*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) + +LocationError LocApiBase:: + setServer(unsigned int /*ip*/, int /*port*/, LocServerType /*type*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) + +LocationError LocApiBase:: + informNiResponse(GnssNiResponse /*userResponse*/, const void* /*passThroughData*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) + +LocationError LocApiBase:: + setSUPLVersion(GnssConfigSuplVersion /*version*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) + +enum loc_api_adapter_err LocApiBase:: + setNMEATypes (uint32_t /*typesMask*/) +DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) + +LocationError LocApiBase:: + setLPPConfig(GnssConfigLppProfile /*profile*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) + +enum loc_api_adapter_err LocApiBase:: + setSensorControlConfig(int /*sensorUsage*/, + int /*sensorProvider*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setServer(const char* url, int len) + setSensorProperties(bool /*gyroBiasVarianceRandomWalk_valid*/, + float /*gyroBiasVarianceRandomWalk*/, + bool /*accelBiasVarianceRandomWalk_valid*/, + float /*accelBiasVarianceRandomWalk*/, + bool /*angleBiasVarianceRandomWalk_valid*/, + float /*angleBiasVarianceRandomWalk*/, + bool /*rateBiasVarianceRandomWalk_valid*/, + float /*rateBiasVarianceRandomWalk*/, + bool /*velocityBiasVarianceRandomWalk_valid*/, + float /*velocityBiasVarianceRandomWalk*/) DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - setServer(unsigned int ip, int port, - LocServerType type) + setSensorPerfControlConfig(int /*controlMode*/, + int /*accelSamplesPerBatch*/, + int /*accelBatchesPerSec*/, + int /*gyroSamplesPerBatch*/, + int /*gyroBatchesPerSec*/, + int /*accelSamplesPerBatchHigh*/, + int /*accelBatchesPerSecHigh*/, + int /*gyroSamplesPerBatchHigh*/, + int /*gyroBatchesPerSecHigh*/, + int /*algorithmConfig*/) +DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) + +LocationError LocApiBase:: + setAGLONASSProtocol(GnssConfigAGlonassPositionProtocolMask /*aGlonassProtocol*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) + +LocationError LocApiBase:: + setLPPeProtocolCp(GnssConfigLppeControlPlaneMask /*lppeCP*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) + +LocationError LocApiBase:: + setLPPeProtocolUp(GnssConfigLppeUserPlaneMask /*lppeUP*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) + +enum loc_api_adapter_err LocApiBase:: + getWwanZppFix() DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) enum loc_api_adapter_err LocApiBase:: - informNiResponse(GpsUserResponseType userResponse, - const void* passThroughData) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - setSUPLVersion(uint32_t version) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - setNMEATypes (uint32_t typesMask) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - setLPPConfig(uint32_t profile) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - setSensorControlConfig(int sensorUsage, - int sensorProvider) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, - float gyroBiasVarianceRandomWalk, - bool accelBiasVarianceRandomWalk_valid, - float accelBiasVarianceRandomWalk, - bool angleBiasVarianceRandomWalk_valid, - float angleBiasVarianceRandomWalk, - bool rateBiasVarianceRandomWalk_valid, - float rateBiasVarianceRandomWalk, - bool velocityBiasVarianceRandomWalk_valid, - float velocityBiasVarianceRandomWalk) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - setSensorPerfControlConfig(int controlMode, - int accelSamplesPerBatch, - int accelBatchesPerSec, - int gyroSamplesPerBatch, - int gyroBatchesPerSec, - int accelSamplesPerBatchHigh, - int accelBatchesPerSecHigh, - int gyroSamplesPerBatchHigh, - int gyroBatchesPerSecHigh, - int algorithmConfig) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - setAGLONASSProtocol(unsigned long aGlonassProtocol) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP) - DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - getWwanZppFix(GpsLocation& zppLoc) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) - -enum loc_api_adapter_err LocApiBase:: - getBestAvailableZppFix(GpsLocation& zppLoc) + getBestAvailableZppFix(LocGpsLocation& zppLoc) { memset(&zppLoc, 0, sizeof(zppLoc)); DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) } enum loc_api_adapter_err LocApiBase:: - getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask) + getBestAvailableZppFix(LocGpsLocation & zppLoc, GpsLocationExtended & locationExtended, + LocPosTechMask & tech_mask) { memset(&zppLoc, 0, sizeof(zppLoc)); memset(&tech_mask, 0, sizeof(tech_mask)); + memset(&locationExtended, 0, sizeof (locationExtended)); DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) } int LocApiBase:: - initDataServiceClient() + initDataServiceClient(bool /*isDueToSsr*/) DEFAULT_IMPL(-1) int LocApiBase:: @@ -558,23 +569,27 @@ void LocApiBase:: closeDataCall() DEFAULT_IMPL() -int LocApiBase:: - setGpsLock(LOC_GPS_LOCK_MASK lock) -DEFAULT_IMPL(-1) +void LocApiBase:: + releaseDataServiceClient() +DEFAULT_IMPL() + +LocationError LocApiBase:: + setGpsLock(GnssConfigGpsLock /*lock*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) void LocApiBase:: - installAGpsCert(const DerEncodedCertificate* pData, - size_t length, - uint32_t slotBitMask) + installAGpsCert(const LocDerEncodedCertificate* /*pData*/, + size_t /*length*/, + uint32_t /*slotBitMask*/) DEFAULT_IMPL() int LocApiBase:: getGpsLock() DEFAULT_IMPL(-1) -enum loc_api_adapter_err LocApiBase:: - setXtraVersionCheck(enum xtra_version_check check) -DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS) +LocationError LocApiBase:: + setXtraVersionCheck(uint32_t /*check*/) +DEFAULT_IMPL(LOCATION_ERROR_SUCCESS) bool LocApiBase:: gnssConstellationConfig() diff --git a/gps/core/LocApiBase.h b/gps/core/LocApiBase.h index 066695c..f66bfe1 100644 --- a/gps/core/LocApiBase.h +++ b/gps/core/LocApiBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, 2016 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016-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 @@ -32,6 +32,7 @@ #include #include #include +#include #include #include @@ -102,40 +103,37 @@ public: inline void sendMsg(const LocMsg* msg) const { mMsgTask->sendMsg(msg); } - void addAdapter(LocAdapterBase* adapter); void removeAdapter(LocAdapterBase* adapter); // upward calls void handleEngineUpEvent(); void handleEngineDownEvent(); - void reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, + void reportPosition(UlpLocation& location, + GpsLocationExtended& locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask = LOC_POS_TECH_MASK_DEFAULT); - void reportSv(GnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt); + void reportSv(GnssSvNotification& svNotify); void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet); void reportSvPolynomial(GnssSvPolynomial &svPolynomial); - void reportStatus(GpsStatusValue status); + void reportStatus(LocGpsStatusValue status); void reportNmea(const char* nmea, int length); void reportXtraServer(const char* url1, const char* url2, const char* url3, const int maxlength); void requestXtraData(); void requestTime(); void requestLocation(); - void requestATL(int connHandle, AGpsType agps_type); + void requestATL(int connHandle, LocAGpsType agps_type); void releaseATL(int connHandle); void requestSuplES(int connHandle); void reportDataCallOpened(); void reportDataCallClosed(); - void requestNiNotify(GpsNiNotification ¬ify, const void* data); + void requestNiNotify(GnssNiNotification ¬ify, const void* data); void saveSupportedMsgList(uint64_t supportedMsgList); - void reportGnssMeasurementData(GnssData &gnssMeasurementData); + void reportGnssMeasurementData(GnssMeasurementsNotification& measurements, int msInWeek); void saveSupportedFeatureList(uint8_t *featureList); + void reportWwanZppFix(LocGpsLocation &zppLoc); // downward calls // All below functions are to be defined by adapter specific modules: @@ -147,8 +145,8 @@ public: startFix(const LocPosMode& posMode); virtual enum loc_api_adapter_err stopFix(); - virtual enum loc_api_adapter_err - deleteAidingData(GpsAidingData f); + virtual LocationError + deleteAidingData(const GnssAidingData& data); virtual enum loc_api_adapter_err enableData(int enable); virtual enum loc_api_adapter_err @@ -156,30 +154,28 @@ public: virtual enum loc_api_adapter_err injectPosition(double latitude, double longitude, float accuracy); virtual enum loc_api_adapter_err - setTime(GpsUtcTime time, int64_t timeReference, int uncertainty); + setTime(LocGpsUtcTime time, int64_t timeReference, int uncertainty); virtual enum loc_api_adapter_err setXtraData(char* data, int length); virtual enum loc_api_adapter_err requestXtraServer(); virtual enum loc_api_adapter_err - atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bear, AGpsType agpsType); + atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bear, LocAGpsType agpsType); virtual enum loc_api_adapter_err atlCloseStatus(int handle, int is_succ); virtual enum loc_api_adapter_err setPositionMode(const LocPosMode& posMode); - virtual enum loc_api_adapter_err + virtual LocationError setServer(const char* url, int len); - virtual enum loc_api_adapter_err + virtual LocationError setServer(unsigned int ip, int port, LocServerType type); - virtual enum loc_api_adapter_err - informNiResponse(GpsUserResponseType userResponse, const void* passThroughData); - virtual enum loc_api_adapter_err - setSUPLVersion(uint32_t version); + virtual LocationError + informNiResponse(GnssNiResponse userResponse, const void* passThroughData); + virtual LocationError setSUPLVersion(GnssConfigSuplVersion version); virtual enum loc_api_adapter_err setNMEATypes (uint32_t typesMask); - virtual enum loc_api_adapter_err - setLPPConfig(uint32_t profile); + virtual LocationError setLPPConfig(GnssConfigLppProfile profile); virtual enum loc_api_adapter_err setSensorControlConfig(int sensorUsage, int sensorProvider); virtual enum loc_api_adapter_err @@ -204,21 +200,23 @@ public: int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig); + virtual LocationError + setAGLONASSProtocol(GnssConfigAGlonassPositionProtocolMask aGlonassProtocol); + virtual LocationError setLPPeProtocolCp(GnssConfigLppeControlPlaneMask lppeCP); + virtual LocationError setLPPeProtocolUp(GnssConfigLppeUserPlaneMask lppeUP); virtual enum loc_api_adapter_err - setAGLONASSProtocol(unsigned long aGlonassProtocol); + getWwanZppFix(); virtual enum loc_api_adapter_err - setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP); + getBestAvailableZppFix(LocGpsLocation & zppLoc); virtual enum loc_api_adapter_err - getWwanZppFix(GpsLocation & zppLoc); - virtual enum loc_api_adapter_err - getBestAvailableZppFix(GpsLocation & zppLoc); - virtual enum loc_api_adapter_err - getBestAvailableZppFix(GpsLocation & zppLoc, LocPosTechMask & tech_mask); - virtual int initDataServiceClient(); + getBestAvailableZppFix(LocGpsLocation & zppLoc, GpsLocationExtended & locationExtended, + LocPosTechMask & tech_mask); + virtual int initDataServiceClient(bool isDueToSsr); virtual int openAndStartDataCall(); virtual void stopDataCall(); virtual void closeDataCall(); - virtual void installAGpsCert(const DerEncodedCertificate* pData, + virtual void releaseDataServiceClient(); + virtual void installAGpsCert(const LocDerEncodedCertificate* pData, size_t length, uint32_t slotBitMask); inline virtual void setInSession(bool inSession) { @@ -236,15 +234,10 @@ public: return (messageChecker & mSupportedMsg) == messageChecker; } } + void updateEvtMask(); - /*Values for lock - 1 = Do not lock any position sessions - 2 = Lock MI position sessions - 3 = Lock MT position sessions - 4 = Lock all position sessions - */ - virtual int setGpsLock(LOC_GPS_LOCK_MASK lock); + virtual LocationError setGpsLock(GnssConfigGpsLock lock); /* Returns Current value of GPS Lock on success @@ -252,8 +245,7 @@ public: */ virtual int getGpsLock(void); - virtual enum loc_api_adapter_err setXtraVersionCheck(enum xtra_version_check check); - + virtual LocationError setXtraVersionCheck(uint32_t check); /* Check if the modem support the service */ diff --git a/gps/core/LocDualContext.cpp b/gps/core/LocDualContext.cpp index 74b2903..fd3450d 100644 --- a/gps/core/LocDualContext.cpp +++ b/gps/core/LocDualContext.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 2016-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 @@ -26,7 +26,7 @@ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ -#define LOG_NDDEBUG 0 +#define LOG_NDEBUG 0 #define LOG_TAG "LocSvc_DualCtx" #include @@ -44,8 +44,7 @@ LocDualContext::mFgExclMask = 0; // excluded events for background clients const LOC_API_ADAPTER_EVENT_MASK_T LocDualContext::mBgExclMask = - (LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT | - LOC_API_ADAPTER_BIT_SATELLITE_REPORT | + (LOC_API_ADAPTER_BIT_SATELLITE_REPORT | LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT | LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT | LOC_API_ADAPTER_BIT_IOCTL_REPORT | diff --git a/gps/core/LocDualContext.h b/gps/core/LocDualContext.h index ce77a1a..3b3ce2c 100644 --- a/gps/core/LocDualContext.h +++ b/gps/core/LocDualContext.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2014, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2014, 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 diff --git a/gps/core/Makefile.am b/gps/core/Makefile.am new file mode 100644 index 0000000..568880c --- /dev/null +++ b/gps/core/Makefile.am @@ -0,0 +1,61 @@ +AM_CFLAGS = -I./ \ + -I../utils \ + -I../location \ + $(LOCPLA_CFLAGS) \ + $(GPSUTILS_CFLAGS) \ + -I$(WORKSPACE)/gps-noship/flp \ + -D__func__=__PRETTY_FUNCTION__ \ + -fno-short-enums \ + -std=c++11 + +libloc_core_la_h_sources = \ + LocApiBase.h \ + LocAdapterBase.h \ + ContextBase.h \ + LocDualContext.h \ + LBSProxyBase.h \ + UlpProxyBase.h \ + loc_core_log.h \ + LocAdapterProxyBase.h \ + data-items/DataItemId.h \ + data-items/IDataItemCore.h \ + observer/IDataItemObserver.h \ + observer/IDataItemSubscription.h \ + observer/IFrameworkActionReq.h \ + observer/IOsObserver.h \ + SystemStatusOsObserver.h \ + SystemStatus.h + +libloc_core_la_c_sources = \ + LocApiBase.cpp \ + LocAdapterBase.cpp \ + ContextBase.cpp \ + LocDualContext.cpp \ + loc_core_log.cpp \ + data-items/DataItemsFactoryProxy.cpp \ + data-items/common/ClientIndex.cpp \ + data-items/common/DataItemIndex.cpp \ + data-items/common/IndexFactory.cpp \ + SystemStatusOsObserver.cpp \ + SystemStatus.cpp + +library_includedir = $(pkgincludedir)/core + +library_include_HEADERS = $(libloc_core_la_h_sources) + +libloc_core_la_SOURCES = $(libloc_core_la_c_sources) + +if USE_GLIB +libloc_core_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ +libloc_core_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 +libloc_core_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ +else +libloc_core_la_CFLAGS = $(AM_CFLAGS) +libloc_core_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0 +libloc_core_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) +endif + +libloc_core_la_LIBADD = -lstdc++ -ldl $(LOCPLA_LIBS) $(GPSUTILS_LIBS) + +#Create and Install libraries +lib_LTLIBRARIES = libloc_core.la diff --git a/gps/core/SystemStatus.cpp b/gps/core/SystemStatus.cpp new file mode 100644 index 0000000..52d28c7 --- /dev/null +++ b/gps/core/SystemStatus.cpp @@ -0,0 +1,1788 @@ +/* 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_SystemStatus" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace loc_core +{ + +/****************************************************************************** + SystemStatusNmeaBase - base class for all NMEA parsers +******************************************************************************/ +class SystemStatusNmeaBase +{ +protected: + std::vector mField; + + SystemStatusNmeaBase(const char *str_in, uint32_t len_in) + { + // check size and talker + if (!loc_nmea_is_debug(str_in, len_in)) { + return; + } + + std::string parser(str_in); + std::string::size_type index = 0; + + // verify checksum field + index = parser.find("*"); + if (index == std::string::npos) { + return; + } + parser[index] = ','; + + // tokenize parser + while (1) { + std::string str; + index = parser.find(","); + if (index == std::string::npos) { + break; + } + str = parser.substr(0, index); + parser = parser.substr(index + 1); + mField.push_back(str); + } + } + + virtual ~SystemStatusNmeaBase() { } + +public: + static const uint32_t NMEA_MINSIZE = DEBUG_NMEA_MINSIZE; + static const uint32_t NMEA_MAXSIZE = DEBUG_NMEA_MAXSIZE; +}; + +/****************************************************************************** + SystemStatusPQWM1 +******************************************************************************/ +class SystemStatusPQWM1 +{ +public: + uint16_t mGpsWeek; // x1 + uint32_t mGpsTowMs; // x2 + uint8_t mTimeValid; // x3 + uint8_t mTimeSource; // x4 + int32_t mTimeUnc; // x5 + int32_t mClockFreqBias; // x6 + int32_t mClockFreqBiasUnc; // x7 + uint8_t mXoState; // x8 + int32_t mPgaGain; // x9 + uint32_t mGpsBpAmpI; // xA + uint32_t mGpsBpAmpQ; // xB + uint32_t mAdcI; // xC + uint32_t mAdcQ; // xD + uint32_t mJammerGps; // xE + uint32_t mJammerGlo; // xF + uint32_t mJammerBds; // x10 + uint32_t mJammerGal; // x11 + uint32_t mRecErrorRecovery; // x12 + double mAgcGps; // x13 + double mAgcGlo; // x14 + double mAgcBds; // x15 + double mAgcGal; // x16 + int32_t mLeapSeconds;// x17 + int32_t mLeapSecUnc; // x18 +}; + +// parser +class SystemStatusPQWM1parser : public SystemStatusNmeaBase +{ +private: + enum + { + eTalker = 0, + eGpsWeek = 1, + eGpsTowMs = 2, + eTimeValid = 3, + eTimeSource = 4, + eTimeUnc = 5, + eClockFreqBias = 6, + eClockFreqBiasUnc = 7, + eXoState = 8, + ePgaGain = 9, + eGpsBpAmpI = 10, + eGpsBpAmpQ = 11, + eAdcI = 12, + eAdcQ = 13, + eJammerGps = 14, + eJammerGlo = 15, + eJammerBds = 16, + eJammerGal = 17, + eRecErrorRecovery = 18, + eAgcGps = 19, + eAgcGlo = 20, + eAgcBds = 21, + eAgcGal = 22, + eLeapSeconds = 23, + eLeapSecUnc = 24, + eMax + }; + SystemStatusPQWM1 mM1; + +public: + inline uint16_t getGpsWeek() { return mM1.mGpsWeek; } + inline uint32_t getGpsTowMs() { return mM1.mGpsTowMs; } + inline uint8_t getTimeValid() { return mM1.mTimeValid; } + inline uint8_t getTimeSource() { return mM1.mTimeSource; } + inline int32_t getTimeUnc() { return mM1.mTimeUnc; } + inline int32_t getClockFreqBias() { return mM1.mClockFreqBias; } + inline int32_t getClockFreqBiasUnc() { return mM1.mClockFreqBiasUnc; } + inline uint8_t getXoState() { return mM1.mXoState;} + inline int32_t getPgaGain() { return mM1.mPgaGain; } + inline uint32_t getGpsBpAmpI() { return mM1.mGpsBpAmpI; } + inline uint32_t getGpsBpAmpQ() { return mM1.mGpsBpAmpQ; } + inline uint32_t getAdcI() { return mM1.mAdcI; } + inline uint32_t getAdcQ() { return mM1.mAdcQ; } + inline uint32_t getJammerGps() { return mM1.mJammerGps; } + inline uint32_t getJammerGlo() { return mM1.mJammerGlo; } + inline uint32_t getJammerBds() { return mM1.mJammerBds; } + inline uint32_t getJammerGal() { return mM1.mJammerGal; } + inline uint32_t getAgcGps() { return mM1.mAgcGps; } + inline uint32_t getAgcGlo() { return mM1.mAgcGlo; } + inline uint32_t getAgcBds() { return mM1.mAgcBds; } + inline uint32_t getAgcGal() { return mM1.mAgcGal; } + inline uint32_t getRecErrorRecovery() { return mM1.mRecErrorRecovery; } + inline int32_t getLeapSeconds(){ return mM1.mLeapSeconds; } + inline int32_t getLeapSecUnc() { return mM1.mLeapSecUnc; } + + SystemStatusPQWM1parser(const char *str_in, uint32_t len_in) + : SystemStatusNmeaBase(str_in, len_in) + { + memset(&mM1, 0, sizeof(mM1)); + if (mField.size() < eMax) { + LOC_LOGE("PQWM1parser - invalid size=%zu", mField.size()); + mM1.mTimeValid = 0; + return; + } + mM1.mGpsWeek = atoi(mField[eGpsWeek].c_str()); + mM1.mGpsTowMs = atoi(mField[eGpsTowMs].c_str()); + mM1.mTimeValid = atoi(mField[eTimeValid].c_str()); + mM1.mTimeSource = atoi(mField[eTimeSource].c_str()); + mM1.mTimeUnc = atoi(mField[eTimeUnc].c_str()); + mM1.mClockFreqBias = atoi(mField[eClockFreqBias].c_str()); + mM1.mClockFreqBiasUnc = atoi(mField[eClockFreqBiasUnc].c_str()); + mM1.mXoState = atoi(mField[eXoState].c_str()); + mM1.mPgaGain = atoi(mField[ePgaGain].c_str()); + mM1.mGpsBpAmpI = atoi(mField[eGpsBpAmpI].c_str()); + mM1.mGpsBpAmpQ = atoi(mField[eGpsBpAmpQ].c_str()); + mM1.mAdcI = atoi(mField[eAdcI].c_str()); + mM1.mAdcQ = atoi(mField[eAdcQ].c_str()); + mM1.mJammerGps = atoi(mField[eJammerGps].c_str()); + mM1.mJammerGlo = atoi(mField[eJammerGlo].c_str()); + mM1.mJammerBds = atoi(mField[eJammerBds].c_str()); + mM1.mJammerGal = atoi(mField[eJammerGal].c_str()); + mM1.mRecErrorRecovery = atoi(mField[eRecErrorRecovery].c_str()); + mM1.mAgcGps = atof(mField[eAgcGps].c_str()); + mM1.mAgcGlo = atof(mField[eAgcGlo].c_str()); + mM1.mAgcBds = atof(mField[eAgcBds].c_str()); + mM1.mAgcGal = atof(mField[eAgcGal].c_str()); + mM1.mLeapSeconds = atoi(mField[eLeapSeconds].c_str()); + mM1.mLeapSecUnc = atoi(mField[eLeapSecUnc].c_str()); + } + + inline SystemStatusPQWM1& get() { return mM1;} //getparser +}; + +/****************************************************************************** + SystemStatusPQWP1 +******************************************************************************/ +class SystemStatusPQWP1 +{ +public: + uint8_t mEpiValidity; // x4 + float mEpiLat; // x5 + float mEpiLon; // x6 + float mEpiAlt; // x7 + float mEpiHepe; // x8 + float mEpiAltUnc; // x9 + uint8_t mEpiSrc; // x10 +}; + +class SystemStatusPQWP1parser : public SystemStatusNmeaBase +{ +private: + enum + { + eTalker = 0, + eUtcTime = 1, + eEpiValidity = 2, + eEpiLat = 3, + eEpiLon = 4, + eEpiAlt = 5, + eEpiHepe = 6, + eEpiAltUnc = 7, + eEpiSrc = 8, + eMax + }; + SystemStatusPQWP1 mP1; + +public: + inline uint8_t getEpiValidity() { return mP1.mEpiValidity; } + inline float getEpiLat() { return mP1.mEpiLat; } + inline float getEpiLon() { return mP1.mEpiLon; } + inline float getEpiAlt() { return mP1.mEpiAlt; } + inline float getEpiHepe() { return mP1.mEpiHepe; } + inline float getEpiAltUnc() { return mP1.mEpiAltUnc; } + inline uint8_t getEpiSrc() { return mP1.mEpiSrc; } + + SystemStatusPQWP1parser(const char *str_in, uint32_t len_in) + : SystemStatusNmeaBase(str_in, len_in) + { + if (mField.size() < eMax) { + return; + } + memset(&mP1, 0, sizeof(mP1)); + mP1.mEpiValidity = strtol(mField[eEpiValidity].c_str(), NULL, 16); + mP1.mEpiLat = atof(mField[eEpiLat].c_str()); + mP1.mEpiLon = atof(mField[eEpiLon].c_str()); + mP1.mEpiAlt = atof(mField[eEpiAlt].c_str()); + mP1.mEpiHepe = atoi(mField[eEpiHepe].c_str()); + mP1.mEpiAltUnc = atof(mField[eEpiAltUnc].c_str()); + mP1.mEpiSrc = atoi(mField[eEpiSrc].c_str()); + } + + inline SystemStatusPQWP1& get() { return mP1;} +}; + +/****************************************************************************** + SystemStatusPQWP2 +******************************************************************************/ +class SystemStatusPQWP2 +{ +public: + float mBestLat; // x4 + float mBestLon; // x5 + float mBestAlt; // x6 + float mBestHepe; // x7 + float mBestAltUnc; // x8 +}; + +class SystemStatusPQWP2parser : public SystemStatusNmeaBase +{ +private: + enum + { + eTalker = 0, + eUtcTime = 1, + eBestLat = 2, + eBestLon = 3, + eBestAlt = 4, + eBestHepe = 5, + eBestAltUnc = 6, + eMax + }; + SystemStatusPQWP2 mP2; + +public: + inline float getBestLat() { return mP2.mBestLat; } + inline float getBestLon() { return mP2.mBestLon; } + inline float getBestAlt() { return mP2.mBestAlt; } + inline float getBestHepe() { return mP2.mBestHepe; } + inline float getBestAltUnc() { return mP2.mBestAltUnc; } + + SystemStatusPQWP2parser(const char *str_in, uint32_t len_in) + : SystemStatusNmeaBase(str_in, len_in) + { + if (mField.size() < eMax) { + return; + } + memset(&mP2, 0, sizeof(mP2)); + mP2.mBestLat = atof(mField[eBestLat].c_str()); + mP2.mBestLon = atof(mField[eBestLon].c_str()); + mP2.mBestAlt = atof(mField[eBestAlt].c_str()); + mP2.mBestHepe = atof(mField[eBestHepe].c_str()); + mP2.mBestAltUnc = atof(mField[eBestAltUnc].c_str()); + } + + inline SystemStatusPQWP2& get() { return mP2;} +}; + +/****************************************************************************** + SystemStatusPQWP3 +******************************************************************************/ +class SystemStatusPQWP3 +{ +public: + uint8_t mXtraValidMask; + uint32_t mGpsXtraAge; + uint32_t mGloXtraAge; + uint32_t mBdsXtraAge; + uint32_t mGalXtraAge; + uint32_t mQzssXtraAge; + uint32_t mGpsXtraValid; + uint32_t mGloXtraValid; + uint64_t mBdsXtraValid; + uint64_t mGalXtraValid; + uint8_t mQzssXtraValid; +}; + +class SystemStatusPQWP3parser : public SystemStatusNmeaBase +{ +private: + enum + { + eTalker = 0, + eUtcTime = 1, + eXtraValidMask = 2, + eGpsXtraAge = 3, + eGloXtraAge = 4, + eBdsXtraAge = 5, + eGalXtraAge = 6, + eQzssXtraAge = 7, + eGpsXtraValid = 8, + eGloXtraValid = 9, + eBdsXtraValid = 10, + eGalXtraValid = 11, + eQzssXtraValid = 12, + eMax + }; + SystemStatusPQWP3 mP3; + +public: + inline uint8_t getXtraValid() { return mP3.mXtraValidMask; } + inline uint32_t getGpsXtraAge() { return mP3.mGpsXtraAge; } + inline uint32_t getGloXtraAge() { return mP3.mGloXtraAge; } + inline uint32_t getBdsXtraAge() { return mP3.mBdsXtraAge; } + inline uint32_t getGalXtraAge() { return mP3.mGalXtraAge; } + inline uint32_t getQzssXtraAge() { return mP3.mQzssXtraAge; } + inline uint32_t getGpsXtraValid() { return mP3.mGpsXtraValid; } + inline uint32_t getGloXtraValid() { return mP3.mGloXtraValid; } + inline uint64_t getBdsXtraValid() { return mP3.mBdsXtraValid; } + inline uint64_t getGalXtraValid() { return mP3.mGalXtraValid; } + inline uint8_t getQzssXtraValid() { return mP3.mQzssXtraValid; } + + SystemStatusPQWP3parser(const char *str_in, uint32_t len_in) + : SystemStatusNmeaBase(str_in, len_in) + { + if (mField.size() < eMax) { + return; + } + memset(&mP3, 0, sizeof(mP3)); + mP3.mXtraValidMask = strtol(mField[eXtraValidMask].c_str(), NULL, 16); + mP3.mGpsXtraAge = atoi(mField[eGpsXtraAge].c_str()); + mP3.mGloXtraAge = atoi(mField[eGloXtraAge].c_str()); + mP3.mBdsXtraAge = atoi(mField[eBdsXtraAge].c_str()); + mP3.mGalXtraAge = atoi(mField[eGalXtraAge].c_str()); + mP3.mQzssXtraAge = atoi(mField[eQzssXtraAge].c_str()); + mP3.mGpsXtraValid = strtol(mField[eGpsXtraValid].c_str(), NULL, 16); + mP3.mGloXtraValid = strtol(mField[eGloXtraValid].c_str(), NULL, 16); + mP3.mBdsXtraValid = strtol(mField[eBdsXtraValid].c_str(), NULL, 16); + mP3.mGalXtraValid = strtol(mField[eGalXtraValid].c_str(), NULL, 16); + mP3.mQzssXtraValid = strtol(mField[eQzssXtraValid].c_str(), NULL, 16); + } + + inline SystemStatusPQWP3& get() { return mP3;} +}; + +/****************************************************************************** + SystemStatusPQWP4 +******************************************************************************/ +class SystemStatusPQWP4 +{ +public: + uint32_t mGpsEpheValid; + uint32_t mGloEpheValid; + uint64_t mBdsEpheValid; + uint64_t mGalEpheValid; + uint8_t mQzssEpheValid; +}; + +class SystemStatusPQWP4parser : public SystemStatusNmeaBase +{ +private: + enum + { + eTalker = 0, + eUtcTime = 1, + eGpsEpheValid = 2, + eGloEpheValid = 3, + eBdsEpheValid = 4, + eGalEpheValid = 5, + eQzssEpheValid = 6, + eMax + }; + SystemStatusPQWP4 mP4; + +public: + inline uint32_t getGpsEpheValid() { return mP4.mGpsEpheValid; } + inline uint32_t getGloEpheValid() { return mP4.mGloEpheValid; } + inline uint64_t getBdsEpheValid() { return mP4.mBdsEpheValid; } + inline uint64_t getGalEpheValid() { return mP4.mGalEpheValid; } + inline uint8_t getQzssEpheValid() { return mP4.mQzssEpheValid; } + + SystemStatusPQWP4parser(const char *str_in, uint32_t len_in) + : SystemStatusNmeaBase(str_in, len_in) + { + if (mField.size() < eMax) { + return; + } + memset(&mP4, 0, sizeof(mP4)); + mP4.mGpsEpheValid = strtol(mField[eGpsEpheValid].c_str(), NULL, 16); + mP4.mGloEpheValid = strtol(mField[eGloEpheValid].c_str(), NULL, 16); + mP4.mBdsEpheValid = strtol(mField[eBdsEpheValid].c_str(), NULL, 16); + mP4.mGalEpheValid = strtol(mField[eGalEpheValid].c_str(), NULL, 16); + mP4.mQzssEpheValid = strtol(mField[eQzssEpheValid].c_str(), NULL, 16); + } + + inline SystemStatusPQWP4& get() { return mP4;} +}; + +/****************************************************************************** + SystemStatusPQWP5 +******************************************************************************/ +class SystemStatusPQWP5 +{ +public: + uint32_t mGpsUnknownMask; + uint32_t mGloUnknownMask; + uint64_t mBdsUnknownMask; + uint64_t mGalUnknownMask; + uint8_t mQzssUnknownMask; + uint32_t mGpsGoodMask; + uint32_t mGloGoodMask; + uint64_t mBdsGoodMask; + uint64_t mGalGoodMask; + uint8_t mQzssGoodMask; + uint32_t mGpsBadMask; + uint32_t mGloBadMask; + uint64_t mBdsBadMask; + uint64_t mGalBadMask; + uint8_t mQzssBadMask; +}; + +class SystemStatusPQWP5parser : public SystemStatusNmeaBase +{ +private: + enum + { + eTalker = 0, + eUtcTime = 1, + eGpsUnknownMask = 2, + eGloUnknownMask = 3, + eBdsUnknownMask = 4, + eGalUnknownMask = 5, + eQzssUnknownMask = 6, + eGpsGoodMask = 7, + eGloGoodMask = 8, + eBdsGoodMask = 9, + eGalGoodMask = 10, + eQzssGoodMask = 11, + eGpsBadMask = 12, + eGloBadMask = 13, + eBdsBadMask = 14, + eGalBadMask = 15, + eQzssBadMask = 16, + eMax + }; + SystemStatusPQWP5 mP5; + +public: + inline uint32_t getGpsUnknownMask() { return mP5.mGpsUnknownMask; } + inline uint32_t getGloUnknownMask() { return mP5.mGloUnknownMask; } + inline uint64_t getBdsUnknownMask() { return mP5.mBdsUnknownMask; } + inline uint64_t getGalUnknownMask() { return mP5.mGalUnknownMask; } + inline uint8_t getQzssUnknownMask() { return mP5.mQzssUnknownMask; } + inline uint32_t getGpsGoodMask() { return mP5.mGpsGoodMask; } + inline uint32_t getGloGoodMask() { return mP5.mGloGoodMask; } + inline uint64_t getBdsGoodMask() { return mP5.mBdsGoodMask; } + inline uint64_t getGalGoodMask() { return mP5.mGalGoodMask; } + inline uint8_t getQzssGoodMask() { return mP5.mQzssGoodMask; } + inline uint32_t getGpsBadMask() { return mP5.mGpsBadMask; } + inline uint32_t getGloBadMask() { return mP5.mGloBadMask; } + inline uint64_t getBdsBadMask() { return mP5.mBdsBadMask; } + inline uint64_t getGalBadMask() { return mP5.mGalBadMask; } + inline uint8_t getQzssBadMask() { return mP5.mQzssBadMask; } + + SystemStatusPQWP5parser(const char *str_in, uint32_t len_in) + : SystemStatusNmeaBase(str_in, len_in) + { + if (mField.size() < eMax) { + return; + } + memset(&mP5, 0, sizeof(mP5)); + mP5.mGpsUnknownMask = strtol(mField[eGpsUnknownMask].c_str(), NULL, 16); + mP5.mGloUnknownMask = strtol(mField[eGloUnknownMask].c_str(), NULL, 16); + mP5.mBdsUnknownMask = strtol(mField[eBdsUnknownMask].c_str(), NULL, 16); + mP5.mGalUnknownMask = strtol(mField[eGalUnknownMask].c_str(), NULL, 16); + mP5.mQzssUnknownMask = strtol(mField[eQzssUnknownMask].c_str(), NULL, 16); + mP5.mGpsGoodMask = strtol(mField[eGpsGoodMask].c_str(), NULL, 16); + mP5.mGloGoodMask = strtol(mField[eGloGoodMask].c_str(), NULL, 16); + mP5.mBdsGoodMask = strtol(mField[eBdsGoodMask].c_str(), NULL, 16); + mP5.mGalGoodMask = strtol(mField[eGalGoodMask].c_str(), NULL, 16); + mP5.mQzssGoodMask = strtol(mField[eQzssGoodMask].c_str(), NULL, 16); + mP5.mGpsBadMask = strtol(mField[eGpsBadMask].c_str(), NULL, 16); + mP5.mGloBadMask = strtol(mField[eGloBadMask].c_str(), NULL, 16); + mP5.mBdsBadMask = strtol(mField[eBdsBadMask].c_str(), NULL, 16); + mP5.mGalBadMask = strtol(mField[eGalBadMask].c_str(), NULL, 16); + mP5.mQzssBadMask = strtol(mField[eQzssBadMask].c_str(), NULL, 16); + } + + inline SystemStatusPQWP5& get() { return mP5;} +}; + +/****************************************************************************** + SystemStatusPQWP6parser +******************************************************************************/ +class SystemStatusPQWP6 +{ +public: + uint32_t mFixInfoMask; +}; + +class SystemStatusPQWP6parser : public SystemStatusNmeaBase +{ +private: + enum + { + eTalker = 0, + eUtcTime = 1, + eFixInfoMask = 2, + eMax + }; + SystemStatusPQWP6 mP6; + +public: + inline uint32_t getFixInfoMask() { return mP6.mFixInfoMask; } + + SystemStatusPQWP6parser(const char *str_in, uint32_t len_in) + : SystemStatusNmeaBase(str_in, len_in) + { + if (mField.size() < eMax) { + return; + } + memset(&mP6, 0, sizeof(mP6)); + mP6.mFixInfoMask = strtol(mField[eFixInfoMask].c_str(), NULL, 16); + } + + inline SystemStatusPQWP6& get() { return mP6;} +}; + +/****************************************************************************** + SystemStatusPQWP7parser +******************************************************************************/ +class SystemStatusPQWP7 +{ +public: + SystemStatusNav mNav[SV_ALL_NUM]; +}; + +class SystemStatusPQWP7parser : public SystemStatusNmeaBase +{ +private: + enum + { + eTalker = 0, + eUtcTime = 1, + eMax = 2 + SV_ALL_NUM*3 + }; + SystemStatusPQWP7 mP7; + +public: + SystemStatusPQWP7parser(const char *str_in, uint32_t len_in) + : SystemStatusNmeaBase(str_in, len_in) + { + if (mField.size() < eMax) { + LOC_LOGE("PQWP7parser - invalid size=%zu", mField.size()); + return; + } + for (uint32_t i=0; i maxTimeAndClock) { + mCache.mTimeAndClock.erase(mCache.mTimeAndClock.begin()); + } + } + return true; +} + +bool SystemStatus::setXoState(const SystemStatusPQWM1& nmea) +{ + SystemStatusXoState s(nmea); + if (!mCache.mXoState.empty() && mCache.mXoState.back().equals(s)) { + mCache.mXoState.back().mUtcReported = s.mUtcReported; + } else { + mCache.mXoState.push_back(s); + if (mCache.mXoState.size() > maxXoState) { + mCache.mXoState.erase(mCache.mXoState.begin()); + } + } + return true; +} + +bool SystemStatus::setRfAndParams(const SystemStatusPQWM1& nmea) +{ + SystemStatusRfAndParams s(nmea); + if (!mCache.mRfAndParams.empty() && mCache.mRfAndParams.back().equals(s)) { + mCache.mRfAndParams.back().mUtcReported = s.mUtcReported; + } else { + mCache.mRfAndParams.push_back(s); + if (mCache.mRfAndParams.size() > maxRfAndParams) { + mCache.mRfAndParams.erase(mCache.mRfAndParams.begin()); + } + } + return true; +} + +bool SystemStatus::setErrRecovery(const SystemStatusPQWM1& nmea) +{ + SystemStatusErrRecovery s(nmea); + if (!mCache.mErrRecovery.empty() && mCache.mErrRecovery.back().equals(s)) { + mCache.mErrRecovery.back().mUtcReported = s.mUtcReported; + } else { + mCache.mErrRecovery.push_back(s); + if (mCache.mErrRecovery.size() > maxErrRecovery) { + mCache.mErrRecovery.erase(mCache.mErrRecovery.begin()); + } + } + return true; +} + +/****************************************************************************** + SystemStatus - Px functions +******************************************************************************/ +bool SystemStatus::setInjectedPosition(const SystemStatusPQWP1& nmea) +{ + SystemStatusInjectedPosition s(nmea); + if (!mCache.mInjectedPosition.empty() && mCache.mInjectedPosition.back().equals(s)) { + mCache.mInjectedPosition.back().mUtcReported = s.mUtcReported; + } else { + mCache.mInjectedPosition.push_back(s); + if (mCache.mInjectedPosition.size() > maxInjectedPosition) { + mCache.mInjectedPosition.erase(mCache.mInjectedPosition.begin()); + } + } + return true; +} + +bool SystemStatus::setBestPosition(const SystemStatusPQWP2& nmea) +{ + SystemStatusBestPosition s(nmea); + if (!mCache.mBestPosition.empty() && mCache.mBestPosition.back().equals(s)) { + mCache.mBestPosition.back().mUtcReported = s.mUtcReported; + } else { + mCache.mBestPosition.push_back(s); + if (mCache.mBestPosition.size() > maxBestPosition) { + mCache.mBestPosition.erase(mCache.mBestPosition.begin()); + } + } + return true; +} + +bool SystemStatus::setXtra(const SystemStatusPQWP3& nmea) +{ + SystemStatusXtra s(nmea); + if (!mCache.mXtra.empty() && mCache.mXtra.back().equals(s)) { + mCache.mXtra.back().mUtcReported = s.mUtcReported; + } else { + mCache.mXtra.push_back(s); + if (mCache.mXtra.size() > maxXtra) { + mCache.mXtra.erase(mCache.mXtra.begin()); + } + } + return true; +} + +bool SystemStatus::setEphemeris(const SystemStatusPQWP4& nmea) +{ + SystemStatusEphemeris s(nmea); + if (!mCache.mEphemeris.empty() && mCache.mEphemeris.back().equals(s)) { + mCache.mEphemeris.back().mUtcReported = s.mUtcReported; + } else { + mCache.mEphemeris.push_back(s); + if (mCache.mEphemeris.size() > maxEphemeris) { + mCache.mEphemeris.erase(mCache.mEphemeris.begin()); + } + } + return true; +} + +bool SystemStatus::setSvHealth(const SystemStatusPQWP5& nmea) +{ + SystemStatusSvHealth s(nmea); + if (!mCache.mSvHealth.empty() && mCache.mSvHealth.back().equals(s)) { + mCache.mSvHealth.back().mUtcReported = s.mUtcReported; + } else { + mCache.mSvHealth.push_back(s); + if (mCache.mSvHealth.size() > maxSvHealth) { + mCache.mSvHealth.erase(mCache.mSvHealth.begin()); + } + } + return true; +} + +bool SystemStatus::setPdr(const SystemStatusPQWP6& nmea) +{ + SystemStatusPdr s(nmea); + if (!mCache.mPdr.empty() && mCache.mPdr.back().equals(s)) { + mCache.mPdr.back().mUtcReported = s.mUtcReported; + } else { + mCache.mPdr.push_back(s); + if (mCache.mPdr.size() > maxPdr) { + mCache.mPdr.erase(mCache.mPdr.begin()); + } + } + return true; +} + +bool SystemStatus::setNavData(const SystemStatusPQWP7& nmea) +{ + SystemStatusNavData s(nmea); + if (!mCache.mNavData.empty() && mCache.mNavData.back().equals(s)) { + mCache.mNavData.back().mUtcReported = s.mUtcReported; + } else { + mCache.mNavData.push_back(s); + if (mCache.mNavData.size() > maxNavData) { + mCache.mNavData.erase(mCache.mNavData.begin()); + } + } + return true; +} + +/****************************************************************************** + SystemStatus - Sx functions +******************************************************************************/ +bool SystemStatus::setPositionFailure(const SystemStatusPQWS1& nmea) +{ + SystemStatusPositionFailure s(nmea); + if (!mCache.mPositionFailure.empty() && mCache.mPositionFailure.back().equals(s)) { + mCache.mPositionFailure.back().mUtcReported = s.mUtcReported; + } else { + mCache.mPositionFailure.push_back(s); + if (mCache.mPositionFailure.size() > maxPositionFailure) { + mCache.mPositionFailure.erase(mCache.mPositionFailure.begin()); + } + } + return true; +} + +/****************************************************************************** + SystemStatus - storing dataitems +******************************************************************************/ +bool SystemStatus::setNetworkInfo(IDataItemCore* dataitem) +{ + SystemStatusNetworkInfo* data = reinterpret_cast(dataitem); + SystemStatusNetworkInfo s(data->mType,data->mTypeName,data->mSubTypeName, + data->mAvailable,data->mConnected,data->mRoaming); + s.dump(); + mConnected = data->mConnected; + + if (!mCache.mNetworkInfo.empty() && mCache.mNetworkInfo.back().equals(s)) { + mCache.mNetworkInfo.back().mUtcReported = s.mUtcReported; + } else { + mCache.mNetworkInfo.push_back(s); + if (mCache.mNetworkInfo.size() > maxNetworkInfo) { + mCache.mNetworkInfo.erase(mCache.mNetworkInfo.begin()); + } + } + return true; +} + +/****************************************************************************** +@brief API to set report data into internal buffer + +@param[In] data pointer to the NMEA string +@param[In] len length of the NMEA string + +@return true when successfully done +******************************************************************************/ +static uint32_t cnt = 0; +static uint32_t cnt_m1 = 0; +static uint32_t cnt_p1 = 0; +static uint32_t cnt_p2 = 0; +static uint32_t cnt_p3 = 0; +static uint32_t cnt_p4 = 0; +static uint32_t cnt_p5 = 0; +static uint32_t cnt_p6 = 0; +static uint32_t cnt_p7 = 0; +static uint32_t cnt_s1 = 0; + +bool SystemStatus::setNmeaString(const char *data, uint32_t len) +{ + bool ret = false; + if (!loc_nmea_is_debug(data, len)) { + return false; + } + + char buf[SystemStatusNmeaBase::NMEA_MAXSIZE + 1] = { 0 }; + strlcpy(buf, data, sizeof(buf)); + + pthread_mutex_lock(&mMutexSystemStatus); + + // parse the received nmea strings here + if (0 == strncmp(data, "$PQWM1", SystemStatusNmeaBase::NMEA_MINSIZE)) { + SystemStatusPQWM1 s = SystemStatusPQWM1parser(buf, len).get(); + ret = setTimeAndCLock(s); + ret |= setXoState(s); + ret |= setRfAndParams(s); + ret |= setErrRecovery(s); + cnt_m1++; + } + else if (0 == strncmp(data, "$PQWP1", SystemStatusNmeaBase::NMEA_MINSIZE)) { + ret = setInjectedPosition(SystemStatusPQWP1parser(buf, len).get()); + cnt_p1++; + } + else if (0 == strncmp(data, "$PQWP2", SystemStatusNmeaBase::NMEA_MINSIZE)) { + ret = setBestPosition(SystemStatusPQWP2parser(buf, len).get()); + cnt_p2++; + } + else if (0 == strncmp(data, "$PQWP3", SystemStatusNmeaBase::NMEA_MINSIZE)) { + ret = setXtra(SystemStatusPQWP3parser(buf, len).get()); + cnt_p3++; + } + else if (0 == strncmp(data, "$PQWP4", SystemStatusNmeaBase::NMEA_MINSIZE)) { + ret = setEphemeris(SystemStatusPQWP4parser(buf, len).get()); + cnt_p4++; + } + else if (0 == strncmp(data, "$PQWP5", SystemStatusNmeaBase::NMEA_MINSIZE)) { + ret = setSvHealth(SystemStatusPQWP5parser(buf, len).get()); + cnt_p5++; + } + else if (0 == strncmp(data, "$PQWP6", SystemStatusNmeaBase::NMEA_MINSIZE)) { + ret = setPdr(SystemStatusPQWP6parser(buf, len).get()); + cnt_p6++; + } + else if (0 == strncmp(data, "$PQWP7", SystemStatusNmeaBase::NMEA_MINSIZE)) { + ret = setNavData(SystemStatusPQWP7parser(buf, len).get()); + cnt_p7++; + } + else if (0 == strncmp(data, "$PQWS1", SystemStatusNmeaBase::NMEA_MINSIZE)) { + ret = setPositionFailure(SystemStatusPQWS1parser(buf, len).get()); + cnt_s1++; + } + else { + // do nothing + } + cnt++; + LOC_LOGV("setNmeaString: cnt=%d M:%d 1:%d 2:%d 3:%d 4:%d 5:%d 6:%d 7:%d S:%d", + cnt, + cnt_m1, + cnt_p1, + cnt_p2, + cnt_p3, + cnt_p4, + cnt_p5, + cnt_p6, + cnt_p7, + cnt_s1); + + pthread_mutex_unlock(&mMutexSystemStatus); + return ret; +} + +/****************************************************************************** +@brief API to set report position data into internal buffer + +@param[In] UlpLocation + +@return true when successfully done +******************************************************************************/ +bool SystemStatus::eventPosition(const UlpLocation& location, + const GpsLocationExtended& locationEx) +{ + SystemStatusLocation s(location, locationEx); + if (!mCache.mLocation.empty() && mCache.mLocation.back().equals(s)) { + mCache.mLocation.back().mUtcReported = s.mUtcReported; + } + else { + mCache.mLocation.push_back(s); + if (mCache.mLocation.size() > maxLocation) { + mCache.mLocation.erase(mCache.mLocation.begin()); + } + } + LOC_LOGV("eventPosition - lat=%f lon=%f alt=%f speed=%f", + s.mLocation.gpsLocation.latitude, + s.mLocation.gpsLocation.longitude, + s.mLocation.gpsLocation.altitude, + s.mLocation.gpsLocation.speed); + return true; +} + +/****************************************************************************** +@brief API to set report DataItem event into internal buffer + +@param[In] DataItem + +@return true when successfully done +******************************************************************************/ +bool SystemStatus::eventDataItemNotify(IDataItemCore* dataitem) +{ + pthread_mutex_lock(&mMutexSystemStatus); + switch(dataitem->getId()) + { + case NETWORKINFO_DATA_ITEM_ID: + setNetworkInfo(dataitem); + break; + } + pthread_mutex_unlock(&mMutexSystemStatus); + return true; +} + +/****************************************************************************** +@brief API to get report data into a given buffer + +@param[In] reference to report buffer +@param[In] bool flag to identify latest only or entire buffer + +@return true when successfully done +******************************************************************************/ +bool SystemStatus::getReport(SystemStatusReports& report, bool isLatestOnly) const +{ + pthread_mutex_lock(&mMutexSystemStatus); + + if (isLatestOnly) { + // push back only the latest report and return it + report.mLocation.clear(); + if (mCache.mLocation.size() >= 1) { + report.mLocation.push_back(mCache.mLocation.back()); + report.mLocation.back().dump(); + } + + report.mTimeAndClock.clear(); + if (mCache.mTimeAndClock.size() >= 1) { + report.mTimeAndClock.push_back(mCache.mTimeAndClock.back()); + report.mTimeAndClock.back().dump(); + } + report.mXoState.clear(); + if (mCache.mXoState.size() >= 1) { + report.mXoState.push_back(mCache.mXoState.back()); + report.mXoState.back().dump(); + } + report.mRfAndParams.clear(); + if (mCache.mRfAndParams.size() >= 1) { + report.mRfAndParams.push_back(mCache.mRfAndParams.back()); + report.mRfAndParams.back().dump(); + } + report.mErrRecovery.clear(); + if (mCache.mErrRecovery.size() >= 1) { + report.mErrRecovery.push_back(mCache.mErrRecovery.back()); + report.mErrRecovery.back().dump(); + } + + report.mInjectedPosition.clear(); + if (mCache.mInjectedPosition.size() >= 1) { + report.mInjectedPosition.push_back(mCache.mInjectedPosition.back()); + report.mInjectedPosition.back().dump(); + } + report.mBestPosition.clear(); + if (mCache.mBestPosition.size() >= 1) { + report.mBestPosition.push_back(mCache.mBestPosition.back()); + report.mBestPosition.back().dump(); + } + report.mXtra.clear(); + if (mCache.mXtra.size() >= 1) { + report.mXtra.push_back(mCache.mXtra.back()); + report.mXtra.back().dump(); + } + report.mEphemeris.clear(); + if (mCache.mEphemeris.size() >= 1) { + report.mEphemeris.push_back(mCache.mEphemeris.back()); + report.mEphemeris.back().dump(); + } + report.mSvHealth.clear(); + if (mCache.mSvHealth.size() >= 1) { + report.mSvHealth.push_back(mCache.mSvHealth.back()); + report.mSvHealth.back().dump(); + } + report.mPdr.clear(); + if (mCache.mPdr.size() >= 1) { + report.mPdr.push_back(mCache.mPdr.back()); + report.mPdr.back().dump(); + } + report.mNavData.clear(); + if (mCache.mNavData.size() >= 1) { + report.mNavData.push_back(mCache.mNavData.back()); + report.mNavData.back().dump(); + } + + report.mPositionFailure.clear(); + if (mCache.mPositionFailure.size() >= 1) { + report.mPositionFailure.push_back(mCache.mPositionFailure.back()); + report.mPositionFailure.back().dump(); + } + } + else { + // copy entire reports and return them + report.mLocation.clear(); + + report.mTimeAndClock.clear(); + report.mXoState.clear(); + report.mRfAndParams.clear(); + report.mErrRecovery.clear(); + + report.mInjectedPosition.clear(); + report.mBestPosition.clear(); + report.mXtra.clear(); + report.mEphemeris.clear(); + report.mSvHealth.clear(); + report.mPdr.clear(); + report.mNavData.clear(); + + report.mPositionFailure.clear(); + report = mCache; + } + + pthread_mutex_unlock(&mMutexSystemStatus); + return true; +} + +/****************************************************************************** +@brief API to set default report data + +@param[In] none + +@return true when successfully done +******************************************************************************/ +bool SystemStatus::setDefaultReport(void) +{ + pthread_mutex_lock(&mMutexSystemStatus); + + mCache.mLocation.push_back(SystemStatusLocation()); + if (mCache.mLocation.size() > maxLocation) { + mCache.mLocation.erase(mCache.mLocation.begin()); + } + + mCache.mTimeAndClock.push_back(SystemStatusTimeAndClock()); + if (mCache.mTimeAndClock.size() > maxTimeAndClock) { + mCache.mTimeAndClock.erase(mCache.mTimeAndClock.begin()); + } + mCache.mXoState.push_back(SystemStatusXoState()); + if (mCache.mXoState.size() > maxXoState) { + mCache.mXoState.erase(mCache.mXoState.begin()); + } + mCache.mRfAndParams.push_back(SystemStatusRfAndParams()); + if (mCache.mRfAndParams.size() > maxRfAndParams) { + mCache.mRfAndParams.erase(mCache.mRfAndParams.begin()); + } + mCache.mErrRecovery.push_back(SystemStatusErrRecovery()); + if (mCache.mErrRecovery.size() > maxErrRecovery) { + mCache.mErrRecovery.erase(mCache.mErrRecovery.begin()); + } + + mCache.mInjectedPosition.push_back(SystemStatusInjectedPosition()); + if (mCache.mInjectedPosition.size() > maxInjectedPosition) { + mCache.mInjectedPosition.erase(mCache.mInjectedPosition.begin()); + } + mCache.mBestPosition.push_back(SystemStatusBestPosition()); + if (mCache.mBestPosition.size() > maxBestPosition) { + mCache.mBestPosition.erase(mCache.mBestPosition.begin()); + } + mCache.mXtra.push_back(SystemStatusXtra()); + if (mCache.mXtra.size() > maxXtra) { + mCache.mXtra.erase(mCache.mXtra.begin()); + } + mCache.mEphemeris.push_back(SystemStatusEphemeris()); + if (mCache.mEphemeris.size() > maxEphemeris) { + mCache.mEphemeris.erase(mCache.mEphemeris.begin()); + } + mCache.mSvHealth.push_back(SystemStatusSvHealth()); + if (mCache.mSvHealth.size() > maxSvHealth) { + mCache.mSvHealth.erase(mCache.mSvHealth.begin()); + } + mCache.mPdr.push_back(SystemStatusPdr()); + if (mCache.mPdr.size() > maxPdr) { + mCache.mPdr.erase(mCache.mPdr.begin()); + } + mCache.mNavData.push_back(SystemStatusNavData()); + if (mCache.mNavData.size() > maxNavData) { + mCache.mNavData.erase(mCache.mNavData.begin()); + } + + mCache.mPositionFailure.push_back(SystemStatusPositionFailure()); + if (mCache.mPositionFailure.size() > maxPositionFailure) { + mCache.mPositionFailure.erase(mCache.mPositionFailure.begin()); + } + + pthread_mutex_unlock(&mMutexSystemStatus); + return true; +} + +/****************************************************************************** +@brief API to handle connection status update event from GnssRil + +@param[In] Connection status + +@return true when successfully done +******************************************************************************/ +bool SystemStatus::eventConnectionStatus(bool connected, uint8_t type) +{ + if (connected != mConnected) { + mConnected = connected; + + // send networkinof dataitem to systemstatus observer clients + SystemStatusNetworkInfo s(type, "", "", false, connected, false); + IDataItemCore *networkinfo = + DataItemsFactoryProxy::createNewDataItem(NETWORKINFO_DATA_ITEM_ID); + if (nullptr == networkinfo) { + LOC_LOGE("Unable to create dataitemd"); + return false; + } + networkinfo->copy(&s); + list dl(0); + dl.push_back(networkinfo); + mSysStatusObsvr.notify(dl); + } + return true; +} + +} // namespace loc_core + diff --git a/gps/core/SystemStatus.h b/gps/core/SystemStatus.h new file mode 100644 index 0000000..5dc2d9f --- /dev/null +++ b/gps/core/SystemStatus.h @@ -0,0 +1,644 @@ +/* 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 __SYSTEM_STATUS__ +#define __SYSTEM_STATUS__ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define GPS_MIN (1) //1-32 +#define SBAS_MIN (33) +#define GLO_MIN (65) //65-88 +#define QZSS_MIN (193) //193-197 +#define BDS_MIN (201) //201-237 +#define GAL_MIN (301) //301-336 + +#define GPS_NUM (32) +#define SBAS_NUM (32) +#define GLO_NUM (24) +#define QZSS_NUM (5) +#define BDS_NUM (37) +#define GAL_NUM (36) +#define SV_ALL_NUM (GPS_NUM+GLO_NUM+QZSS_NUM+BDS_NUM+GAL_NUM) //=134 + +namespace loc_core +{ + +/****************************************************************************** + SystemStatus report data structure +******************************************************************************/ +class SystemStatusItemBase +{ +public: + timespec mUtcTime; // UTC timestamp when this info was last updated + timespec mUtcReported; // UTC timestamp when this info was reported + + SystemStatusItemBase() { + timeval tv; + gettimeofday(&tv, NULL); + mUtcTime.tv_sec = tv.tv_sec; + mUtcTime.tv_nsec = tv.tv_usec *1000ULL; + mUtcReported = mUtcTime; + }; + virtual ~SystemStatusItemBase() { }; + virtual void dump(void) { }; +}; + +class SystemStatusLocation : public SystemStatusItemBase +{ +public: + bool mValid; + UlpLocation mLocation; + GpsLocationExtended mLocationEx; + inline SystemStatusLocation() : + mValid(false) {} + inline SystemStatusLocation(const UlpLocation& location, + const GpsLocationExtended& locationEx) : + mValid(true), + mLocation(location), + mLocationEx(locationEx) { } + bool equals(SystemStatusLocation& peer); + void dump(void); +}; + +class SystemStatusPQWM1; +class SystemStatusTimeAndClock : public SystemStatusItemBase +{ +public: + uint16_t mGpsWeek; + uint32_t mGpsTowMs; + uint8_t mTimeValid; + uint8_t mTimeSource; + int32_t mTimeUnc; + int32_t mClockFreqBias; + int32_t mClockFreqBiasUnc; + int32_t mLeapSeconds; + int32_t mLeapSecUnc; + inline SystemStatusTimeAndClock() : + mGpsWeek(0), + mGpsTowMs(0), + mTimeValid(0), + mTimeSource(0), + mTimeUnc(0), + mClockFreqBias(0), + mClockFreqBiasUnc(0), + mLeapSeconds(0), + mLeapSecUnc(0) {} + inline SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea); + bool equals(SystemStatusTimeAndClock& peer); + void dump(void); +}; + +class SystemStatusXoState : public SystemStatusItemBase +{ +public: + uint8_t mXoState; + inline SystemStatusXoState() : + mXoState(0) {} + inline SystemStatusXoState(const SystemStatusPQWM1& nmea); + bool equals(SystemStatusXoState& peer); + void dump(void); +}; + +class SystemStatusRfAndParams : public SystemStatusItemBase +{ +public: + int32_t mPgaGain; + uint32_t mGpsBpAmpI; + uint32_t mGpsBpAmpQ; + uint32_t mAdcI; + uint32_t mAdcQ; + uint32_t mJammerGps; + uint32_t mJammerGlo; + uint32_t mJammerBds; + uint32_t mJammerGal; + double mAgcGps; + double mAgcGlo; + double mAgcBds; + double mAgcGal; + inline SystemStatusRfAndParams() : + mPgaGain(0), + mGpsBpAmpI(0), + mGpsBpAmpQ(0), + mAdcI(0), + mAdcQ(0), + mJammerGps(0), + mJammerGlo(0), + mJammerBds(0), + mJammerGal(0), + mAgcGps(0), + mAgcGlo(0), + mAgcBds(0), + mAgcGal(0) {} + inline SystemStatusRfAndParams(const SystemStatusPQWM1& nmea); + bool equals(SystemStatusRfAndParams& peer); + void dump(void); +}; + +class SystemStatusErrRecovery : public SystemStatusItemBase +{ +public: + uint32_t mRecErrorRecovery; + inline SystemStatusErrRecovery() : + mRecErrorRecovery(0) {}; + inline SystemStatusErrRecovery(const SystemStatusPQWM1& nmea); + bool equals(SystemStatusErrRecovery& peer); + void dump(void); +}; + +class SystemStatusPQWP1; +class SystemStatusInjectedPosition : public SystemStatusItemBase +{ +public: + uint8_t mEpiValidity; + float mEpiLat; + float mEpiLon; + float mEpiAlt; + float mEpiHepe; + float mEpiAltUnc; + uint8_t mEpiSrc; + inline SystemStatusInjectedPosition() : + mEpiValidity(0), + mEpiLat(0), + mEpiLon(0), + mEpiAlt(0), + mEpiHepe(0), + mEpiAltUnc(0), + mEpiSrc(0) {} + inline SystemStatusInjectedPosition(const SystemStatusPQWP1& nmea); + bool equals(SystemStatusInjectedPosition& peer); + void dump(void); +}; + +class SystemStatusPQWP2; +class SystemStatusBestPosition : public SystemStatusItemBase +{ +public: + bool mValid; + float mBestLat; + float mBestLon; + float mBestAlt; + float mBestHepe; + float mBestAltUnc; + inline SystemStatusBestPosition() : + mValid(false), + mBestLat(0), + mBestLon(0), + mBestAlt(0), + mBestHepe(0), + mBestAltUnc(0) {} + inline SystemStatusBestPosition(const SystemStatusPQWP2& nmea); + bool equals(SystemStatusBestPosition& peer); + void dump(void); +}; + +class SystemStatusPQWP3; +class SystemStatusXtra : public SystemStatusItemBase +{ +public: + uint8_t mXtraValidMask; + uint32_t mGpsXtraAge; + uint32_t mGloXtraAge; + uint32_t mBdsXtraAge; + uint32_t mGalXtraAge; + uint32_t mQzssXtraAge; + uint32_t mGpsXtraValid; + uint32_t mGloXtraValid; + uint64_t mBdsXtraValid; + uint64_t mGalXtraValid; + uint8_t mQzssXtraValid; + inline SystemStatusXtra() : + mXtraValidMask(0), + mGpsXtraAge(0), + mGloXtraAge(0), + mBdsXtraAge(0), + mGalXtraAge(0), + mQzssXtraAge(0), + mGpsXtraValid(0), + mGloXtraValid(0), + mBdsXtraValid(0ULL), + mGalXtraValid(0ULL), + mQzssXtraValid(0) {} + inline SystemStatusXtra(const SystemStatusPQWP3& nmea); + bool equals(SystemStatusXtra& peer); + void dump(void); +}; + +class SystemStatusPQWP4; +class SystemStatusEphemeris : public SystemStatusItemBase +{ +public: + uint32_t mGpsEpheValid; + uint32_t mGloEpheValid; + uint64_t mBdsEpheValid; + uint64_t mGalEpheValid; + uint8_t mQzssEpheValid; + inline SystemStatusEphemeris() : + mGpsEpheValid(0), + mGloEpheValid(0), + mBdsEpheValid(0ULL), + mGalEpheValid(0ULL), + mQzssEpheValid(0) {} + inline SystemStatusEphemeris(const SystemStatusPQWP4& nmea); + bool equals(SystemStatusEphemeris& peer); + void dump(void); +}; + +class SystemStatusPQWP5; +class SystemStatusSvHealth : public SystemStatusItemBase +{ +public: + uint32_t mGpsUnknownMask; + uint32_t mGloUnknownMask; + uint64_t mBdsUnknownMask; + uint64_t mGalUnknownMask; + uint8_t mQzssUnknownMask; + uint32_t mGpsGoodMask; + uint32_t mGloGoodMask; + uint64_t mBdsGoodMask; + uint64_t mGalGoodMask; + uint8_t mQzssGoodMask; + uint32_t mGpsBadMask; + uint32_t mGloBadMask; + uint64_t mBdsBadMask; + uint64_t mGalBadMask; + uint8_t mQzssBadMask; + inline SystemStatusSvHealth() : + mGpsUnknownMask(0), + mGloUnknownMask(0), + mBdsUnknownMask(0ULL), + mGalUnknownMask(0ULL), + mQzssUnknownMask(0), + mGpsGoodMask(0), + mGloGoodMask(0), + mBdsGoodMask(0ULL), + mGalGoodMask(0ULL), + mQzssGoodMask(0), + mGpsBadMask(0), + mGloBadMask(0), + mBdsBadMask(0ULL), + mGalBadMask(0ULL), + mQzssBadMask(0) {} + inline SystemStatusSvHealth(const SystemStatusPQWP5& nmea); + bool equals(SystemStatusSvHealth& peer); + void dump(void); +}; + +class SystemStatusPQWP6; +class SystemStatusPdr : public SystemStatusItemBase +{ +public: + uint32_t mFixInfoMask; + inline SystemStatusPdr() : + mFixInfoMask(0) {} + inline SystemStatusPdr(const SystemStatusPQWP6& nmea); + bool equals(SystemStatusPdr& peer); + void dump(void); +}; + +class SystemStatusPQWP7; +struct SystemStatusNav +{ + GnssEphemerisType mType; + GnssEphemerisSource mSource; + int32_t mAgeSec; +}; + +class SystemStatusNavData : public SystemStatusItemBase +{ +public: + SystemStatusNav mNav[SV_ALL_NUM]; + inline SystemStatusNavData() { + for (uint32_t i=0; i(src); + mEnabled = gpsstate->mEnabled; + if (dataItemCopied) { + *dataItemCopied = true; + } + return 1; + } +}; + +class SystemStatusNetworkInfo : public SystemStatusItemBase, public IDataItemCore +{ +public: + inline SystemStatusNetworkInfo() : + mType(0), + mTypeName(""), + mSubTypeName(""), + mAvailable(false), + mConnected(false), + mRoaming(false) {} + inline SystemStatusNetworkInfo( + uint32_t type, + std::string typeName, + std::string subTypeName, + bool available, + bool connected, + bool roaming) : + mType(type), + mTypeName(typeName), + mSubTypeName(subTypeName), + mAvailable(available), + mConnected(connected), + mRoaming(roaming) {} + + uint32_t mType; + std::string mTypeName; + std::string mSubTypeName; + bool mAvailable; + bool mConnected; + bool mRoaming; + + inline bool equals(SystemStatusNetworkInfo& peer) { + if ((mType != peer.mType) || + (mTypeName != peer.mTypeName) || + (mSubTypeName != peer.mSubTypeName) || + (mAvailable != peer.mAvailable) || + (mConnected != peer.mConnected) || + (mRoaming != peer.mRoaming)) { + return false; + } + return true; + } + inline void dump(void) { + LOC_LOGD("NetworkInfo: type=%u connected=%u", mType, mConnected); + } + inline DataItemId getId() { + return NETWORKINFO_DATA_ITEM_ID; + } + inline void stringify(string& /*valueStr*/) { } + inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) { + SystemStatusNetworkInfo* networkinfo = static_cast(src); + mType = networkinfo->mType; + mTypeName = networkinfo->mTypeName; + mSubTypeName = networkinfo->mSubTypeName; + mAvailable = networkinfo->mAvailable; + mConnected = networkinfo->mConnected; + mRoaming = networkinfo->mRoaming; + if (dataItemCopied) { + *dataItemCopied = true; + } + return 1; + } +}; + +class SystemStatusTac : public SystemStatusItemBase, public IDataItemCore +{ +public: + inline SystemStatusTac() : + mValue("") {} + inline SystemStatusTac(std::string value) : + mValue(value) {} + + std::string mValue; + + inline bool equals(SystemStatusTac& peer) { + return (mValue == peer.mValue); + } + inline void dump(void) { + LOC_LOGD("Tac: value=%s", mValue.c_str()); + } + inline DataItemId getId() { + return TAC_DATA_ITEM_ID; + } + inline void stringify(string& /*valueStr*/) { } + inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) { + SystemStatusTac* tac = static_cast(src); + mValue = tac->mValue; + if (dataItemCopied) { + *dataItemCopied = true; + } + return 1; + } +}; + +class SystemStatusMccMnc : public SystemStatusItemBase, public IDataItemCore +{ +public: + inline SystemStatusMccMnc() : + mValue("") {} + inline SystemStatusMccMnc(std::string value) : + mValue(value) {} + + std::string mValue; + + inline bool equals(SystemStatusMccMnc& peer) { + return (mValue == peer.mValue); + } + inline void dump(void) { + LOC_LOGD("TacMccMnc value=%s", mValue.c_str()); + } + inline DataItemId getId() { + return MCCMNC_DATA_ITEM_ID; + } + inline void stringify(string& /*valueStr*/) { } + inline int32_t copy(IDataItemCore* src, bool* dataItemCopied = nullptr) { + SystemStatusMccMnc* mccmnc = static_cast(src); + mValue = mccmnc->mValue; + if (dataItemCopied) { + *dataItemCopied = true; + } + return 1; + } +}; + +/****************************************************************************** + SystemStatusReports +******************************************************************************/ +class SystemStatusReports +{ +public: + // from QMI_LOC indication + std::vector mLocation; + + // from ME debug NMEA + std::vector mTimeAndClock; + std::vector mXoState; + std::vector mRfAndParams; + std::vector mErrRecovery; + + // from PE debug NMEA + std::vector mInjectedPosition; + std::vector mBestPosition; + std::vector mXtra; + std::vector mEphemeris; + std::vector mSvHealth; + std::vector mPdr; + std::vector mNavData; + + // from SM debug NMEA + std::vector mPositionFailure; + + // from dataitems observer + std::vector mGpsState; + std::vector mNetworkInfo; + std::vector mTac; + std::vector mMccMnc; +}; + +/****************************************************************************** + SystemStatus +******************************************************************************/ +class SystemStatus +{ +private: + static SystemStatus *mInstance; + SystemStatusOsObserver mSysStatusObsvr; + // ctor + SystemStatus(const MsgTask* msgTask); + // dtor + inline ~SystemStatus() {} + + // Data members + static pthread_mutex_t mMutexSystemStatus; + + static const uint32_t maxLocation = 5; + + static const uint32_t maxTimeAndClock = 5; + static const uint32_t maxXoState = 5; + static const uint32_t maxRfAndParams = 5; + static const uint32_t maxErrRecovery = 5; + + static const uint32_t maxInjectedPosition = 5; + static const uint32_t maxBestPosition = 5; + static const uint32_t maxXtra = 5; + static const uint32_t maxEphemeris = 5; + static const uint32_t maxSvHealth = 5; + static const uint32_t maxPdr = 5; + static const uint32_t maxNavData = 5; + + static const uint32_t maxPositionFailure = 5; + + static const uint32_t maxGpsState = 5; + static const uint32_t maxNetworkInfo = 5; + static const uint32_t maxTac = 5; + static const uint32_t maxMccMnc = 5; + + SystemStatusReports mCache; + bool mConnected; + + bool setLocation(const UlpLocation& location); + + bool setTimeAndCLock(const SystemStatusPQWM1& nmea); + bool setXoState(const SystemStatusPQWM1& nmea); + bool setRfAndParams(const SystemStatusPQWM1& nmea); + bool setErrRecovery(const SystemStatusPQWM1& nmea); + + bool setInjectedPosition(const SystemStatusPQWP1& nmea); + bool setBestPosition(const SystemStatusPQWP2& nmea); + bool setXtra(const SystemStatusPQWP3& nmea); + bool setEphemeris(const SystemStatusPQWP4& nmea); + bool setSvHealth(const SystemStatusPQWP5& nmea); + bool setPdr(const SystemStatusPQWP6& nmea); + bool setNavData(const SystemStatusPQWP7& nmea); + + bool setPositionFailure(const SystemStatusPQWS1& nmea); + + bool setNetworkInfo(IDataItemCore* dataitem); + +public: + // Static methods + static SystemStatus* getInstance(const MsgTask* msgTask); + static void destroyInstance(); + IOsObserver* getOsObserver(); + + // Helpers + bool eventPosition(const UlpLocation& location,const GpsLocationExtended& locationEx); + bool eventDataItemNotify(IDataItemCore* dataitem); + bool setNmeaString(const char *data, uint32_t len); + bool getReport(SystemStatusReports& reports, bool isLatestonly = false) const; + bool setDefaultReport(void); + bool eventConnectionStatus(bool connected, uint8_t type); +}; + +} // namespace loc_core + +#endif //__SYSTEM_STATUS__ + diff --git a/gps/core/SystemStatusOsObserver.cpp b/gps/core/SystemStatusOsObserver.cpp new file mode 100644 index 0000000..319f1d7 --- /dev/null +++ b/gps/core/SystemStatusOsObserver.cpp @@ -0,0 +1,593 @@ +/* Copyright (c) 2015-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_SystemStatusOsObserver" + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace loc_core +{ +SystemStatusOsObserver::SystemStatusOsObserver(const MsgTask* msgTask) : + mAddress("SystemStatusOsObserver"), + mClientIndex(IndexFactory :: createClientIndex()), + mDataItemIndex(IndexFactory :: createDataItemIndex()) +{ + mContext.mMsgTask = msgTask; +} + +SystemStatusOsObserver::~SystemStatusOsObserver() +{ + // Close data-item library handle + DataItemsFactoryProxy::closeDataItemLibraryHandle(); + + // Destroy cache + for (auto each : mDataItemCache) { + if (nullptr != each.second) { + delete each.second; + } + } + + mDataItemCache.clear(); + delete mClientIndex; + delete mDataItemIndex; +} + +void SystemStatusOsObserver::setSubscriptionObj(IDataItemSubscription* subscriptionObj) +{ + mContext.mSubscriptionObj = subscriptionObj; + + LOC_LOGD("Request cache size - Subscribe:%zu RequestData:%zu", + mSubscribeReqCache.size(), mReqDataCache.size()); + + // we have received the subscription object. process cached requests + // process - subscribe request cache + for (auto each : mSubscribeReqCache) { + subscribe(each.second, each.first); + } + // process - requestData request cache + for (auto each : mReqDataCache) { + requestData(each.second, each.first); + } +} + +// Helper to cache requests subscribe and requestData till subscription obj is obtained +void SystemStatusOsObserver::cacheObserverRequest(ObserverReqCache& reqCache, + const list& l, IDataItemObserver* client) +{ + ObserverReqCache::iterator dicIter = reqCache.find(client); + if (dicIter != reqCache.end()) { + // found + list difference(0); + set_difference(l.begin(), l.end(), + dicIter->second.begin(), dicIter->second.end(), + inserter(difference, difference.begin())); + if (!difference.empty()) { + difference.sort(); + dicIter->second.merge(difference); + dicIter->second.unique(); + } + } + else { + // not found + reqCache[client] = l; + } +} + +/****************************************************************************** + IDataItemSubscription Overrides +******************************************************************************/ +void SystemStatusOsObserver::subscribe( + const list& l, IDataItemObserver* client) +{ + if (nullptr == mContext.mSubscriptionObj) { + LOC_LOGD("%s]: Subscription object is NULL. Caching requests", __func__); + cacheObserverRequest(mSubscribeReqCache, l, client); + return; + } + + struct HandleSubscribeReq : public LocMsg { + HandleSubscribeReq(SystemStatusOsObserver* parent, + const list& l, IDataItemObserver* client) : + mParent(parent), mClient(client), mDataItemList(l) {} + virtual ~HandleSubscribeReq() {} + void proc() const { + + if (mDataItemList.empty()) { + LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); + return; + } + + // Handle First Response + list pendingFirstResponseList(0); + mParent->mClientIndex->add(mClient, mDataItemList, pendingFirstResponseList); + + // Do not send first response for only pendingFirstResponseList, + // instead send for all the data items (present in the cache) that + // have been subscribed for each time. + mParent->sendFirstResponse(mDataItemList, mClient); + + list yetToSubscribeDataItemsList(0); + mParent->mDataItemIndex->add(mClient, mDataItemList, yetToSubscribeDataItemsList); + + // Send subscription list to framework + if (!yetToSubscribeDataItemsList.empty()) { + mParent->mContext.mSubscriptionObj->subscribe(yetToSubscribeDataItemsList, mParent); + LOC_LOGD("Subscribe Request sent to framework for the following"); + mParent->logMe(yetToSubscribeDataItemsList); + } + } + SystemStatusOsObserver* mParent; + IDataItemObserver* mClient; + const list mDataItemList; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleSubscribeReq(this, l, client)); +} + +void SystemStatusOsObserver::updateSubscription( + const list& l, IDataItemObserver* client) +{ + if (nullptr == mContext.mSubscriptionObj) { + LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); + return; + } + + struct HandleUpdateSubscriptionReq : public LocMsg { + HandleUpdateSubscriptionReq(SystemStatusOsObserver* parent, + const list& l, IDataItemObserver* client) : + mParent(parent), mClient(client), mDataItemList(l) {} + virtual ~HandleUpdateSubscriptionReq() {} + void proc() const { + if (mDataItemList.empty()) { + LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); + return; + } + + list currentlySubscribedList(0); + mParent->mClientIndex->getSubscribedList(mClient, currentlySubscribedList); + + list removeDataItemList(0); + set_difference(currentlySubscribedList.begin(), currentlySubscribedList.end(), + mDataItemList.begin(), mDataItemList.end(), + inserter(removeDataItemList,removeDataItemList.begin())); + + // Handle First Response + list pendingFirstResponseList(0); + mParent->mClientIndex->add(mClient, mDataItemList, pendingFirstResponseList); + + // Send First Response + mParent->sendFirstResponse(pendingFirstResponseList, mClient); + + list yetToSubscribeDataItemsList(0); + mParent->mDataItemIndex->add( + mClient, mDataItemList, yetToSubscribeDataItemsList); + + // Send subscription list to framework + if (!yetToSubscribeDataItemsList.empty()) { + mParent->mContext.mSubscriptionObj->subscribe( + yetToSubscribeDataItemsList, mParent); + LOC_LOGD("Subscribe Request sent to framework for the following"); + mParent->logMe(yetToSubscribeDataItemsList); + } + + list unsubscribeList(0); + list unused(0); + mParent->mClientIndex->remove(mClient, removeDataItemList, unused); + + if (!mParent->mClientIndex->isSubscribedClient(mClient)) { + mParent->mDataItemIndex->remove( + list (1,mClient), unsubscribeList); + } + if (!unsubscribeList.empty()) { + // Send unsubscribe to framework + mParent->mContext.mSubscriptionObj->unsubscribe(unsubscribeList, mParent); + LOC_LOGD("Unsubscribe Request sent to framework for the following"); + mParent->logMe(unsubscribeList); + } + } + SystemStatusOsObserver* mParent; + IDataItemObserver* mClient; + const list mDataItemList; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleUpdateSubscriptionReq(this, l, client)); +} + +void SystemStatusOsObserver::requestData( + const list& l, IDataItemObserver* client) +{ + if (nullptr == mContext.mSubscriptionObj) { + LOC_LOGD("%s]: Subscription object is NULL. Caching requests", __func__); + cacheObserverRequest(mReqDataCache, l, client); + return; + } + + struct HandleRequestData : public LocMsg { + HandleRequestData(SystemStatusOsObserver* parent, + const list& l, IDataItemObserver* client) : + mParent(parent), mClient(client), mDataItemList(l) {} + virtual ~HandleRequestData() {} + void proc() const { + if (mDataItemList.empty()) { + LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); + return; + } + + list yetToSubscribeDataItemsList(0); + mParent->mClientIndex->add( + mClient, mDataItemList, yetToSubscribeDataItemsList); + mParent->mDataItemIndex->add( + mClient, mDataItemList, yetToSubscribeDataItemsList); + + // Send subscription list to framework + if (!mDataItemList.empty()) { + mParent->mContext.mSubscriptionObj->requestData(mDataItemList, mParent); + LOC_LOGD("Subscribe Request sent to framework for the following"); + mParent->logMe(yetToSubscribeDataItemsList); + } + } + SystemStatusOsObserver* mParent; + IDataItemObserver* mClient; + const list mDataItemList; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleRequestData(this, l, client)); +} + +void SystemStatusOsObserver::unsubscribe( + const list& l, IDataItemObserver* client) +{ + if (nullptr == mContext.mSubscriptionObj) { + LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); + return; + } + struct HandleUnsubscribeReq : public LocMsg { + HandleUnsubscribeReq(SystemStatusOsObserver* parent, + const list& l, IDataItemObserver* client) : + mParent(parent), mClient(client), mDataItemList(l) {} + virtual ~HandleUnsubscribeReq() {} + void proc() const { + if (mDataItemList.empty()) { + LOC_LOGV("mDataItemList is empty. Nothing to do. Exiting"); + return; + } + + list unsubscribeList(0); + list unused(0); + mParent->mClientIndex->remove(mClient, mDataItemList, unused); + + for (auto each : mDataItemList) { + list clientListSubs(0); + list clientListOut(0); + mParent->mDataItemIndex->remove( + each, list (1,mClient), clientListOut); + // check if there are any other subscribed client for this data item id + mParent->mDataItemIndex->getListOfSubscribedClients(each, clientListSubs); + if (clientListSubs.empty()) + { + LOC_LOGD("Client list subscribed is empty for dataitem - %d", each); + unsubscribeList.push_back(each); + } + } + + if (!unsubscribeList.empty()) { + // Send unsubscribe to framework + mParent->mContext.mSubscriptionObj->unsubscribe(unsubscribeList, mParent); + LOC_LOGD("Unsubscribe Request sent to framework for the following data items"); + mParent->logMe(unsubscribeList); + } + } + SystemStatusOsObserver* mParent; + IDataItemObserver* mClient; + const list mDataItemList; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleUnsubscribeReq(this, l, client)); +} + +void SystemStatusOsObserver::unsubscribeAll(IDataItemObserver* client) +{ + if (nullptr == mContext.mSubscriptionObj) { + LOC_LOGE("%s:%d]: Subscription object is NULL", __func__, __LINE__); + return; + } + + struct HandleUnsubscribeAllReq : public LocMsg { + HandleUnsubscribeAllReq(SystemStatusOsObserver* parent, + IDataItemObserver* client) : + mParent(parent), mClient(client) {} + virtual ~HandleUnsubscribeAllReq() {} + void proc() const { + list clients(1, mClient); + list unsubscribeList(0); + if(0 == mParent->mClientIndex->remove(mClient)) { + return; + } + mParent->mDataItemIndex->remove(clients, unsubscribeList); + + if (!unsubscribeList.empty()) { + // Send unsubscribe to framework + mParent->mContext.mSubscriptionObj->unsubscribe(unsubscribeList, mParent); + LOC_LOGD("Unsubscribe Request sent to framework for the following data items"); + mParent->logMe(unsubscribeList); + } + } + SystemStatusOsObserver* mParent; + IDataItemObserver* mClient; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleUnsubscribeAllReq(this, client)); +} + +/****************************************************************************** + IDataItemObserver Overrides +******************************************************************************/ +void SystemStatusOsObserver::notify(const list& dlist) +{ + list dataItemList(0); + + for (auto each : dlist) { + string dv; + each->stringify(dv); + LOC_LOGD("notify: DataItem In Value:%s", dv.c_str()); + + IDataItemCore* di = DataItemsFactoryProxy::createNewDataItem(each->getId()); + if (nullptr == di) { + LOC_LOGE("Unable to create dataitem:%d", each->getId()); + return; + } + + // Copy contents into the newly created data item + di->copy(each); + dataItemList.push_back(di); + // Request systemstatus to record this dataitem in its cache + SystemStatus* systemstatus = SystemStatus::getInstance(mContext.mMsgTask); + if(nullptr != systemstatus) { + systemstatus->eventDataItemNotify(di); + } + } + + struct HandleNotify : public LocMsg { + HandleNotify(SystemStatusOsObserver* parent, const list& l) : + mParent(parent), mDList(l) {} + virtual ~HandleNotify() { + for (auto each : mDList) { + delete each; + } + } + void proc() const { + // Update Cache with received data items and prepare + // list of data items to be sent. + list dataItemIdsToBeSent(0); + for (auto item : mDList) { + bool dataItemUpdated = false; + mParent->updateCache(item, dataItemUpdated); + if (dataItemUpdated) { + dataItemIdsToBeSent.push_back(item->getId()); + } + } + + // Send data item to all subscribed clients + list clientList(0); + for (auto each : dataItemIdsToBeSent) { + list clients(0); + mParent->mDataItemIndex->getListOfSubscribedClients(each, clients); + for (auto each_cient: clients) { + clientList.push_back(each_cient); + } + } + clientList.unique(); + + for (auto client : clientList) { + list dataItemIdsSubscribedByThisClient(0); + list dataItemIdsToBeSentForThisClient(0); + mParent->mClientIndex->getSubscribedList( + client, dataItemIdsSubscribedByThisClient); + dataItemIdsSubscribedByThisClient.sort(); + dataItemIdsToBeSent.sort(); + + set_intersection(dataItemIdsToBeSent.begin(), + dataItemIdsToBeSent.end(), + dataItemIdsSubscribedByThisClient.begin(), + dataItemIdsSubscribedByThisClient.end(), + inserter(dataItemIdsToBeSentForThisClient, + dataItemIdsToBeSentForThisClient.begin())); + + mParent->sendCachedDataItems(dataItemIdsToBeSentForThisClient, client); + dataItemIdsSubscribedByThisClient.clear(); + dataItemIdsToBeSentForThisClient.clear(); + } + } + SystemStatusOsObserver* mParent; + const list mDList; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleNotify(this, dataItemList)); +} + +/****************************************************************************** + IFrameworkActionReq Overrides +******************************************************************************/ +void SystemStatusOsObserver::turnOn(DataItemId dit, int timeOut) +{ + if (nullptr == mContext.mFrameworkActionReqObj) { + LOC_LOGE("%s:%d]: Framework action request object is NULL", __func__, __LINE__); + return; + } + + // Check if data item exists in mActiveRequestCount + map::iterator citer = mActiveRequestCount.find(dit); + if (citer == mActiveRequestCount.end()) { + // Data item not found in map + // Add reference count as 1 and add dataitem to map + pair cpair(dit, 1); + mActiveRequestCount.insert(cpair); + LOC_LOGD("Sending turnOn request"); + + // Send action turn on to framework + struct HandleTurnOnMsg : public LocMsg { + HandleTurnOnMsg(IFrameworkActionReq* framework, + DataItemId dit, int timeOut) : + mFrameworkActionReqObj(framework), mDataItemId(dit), mTimeOut(timeOut) {} + virtual ~HandleTurnOnMsg() {} + void proc() const { + mFrameworkActionReqObj->turnOn(mDataItemId, mTimeOut); + } + IFrameworkActionReq* mFrameworkActionReqObj; + DataItemId mDataItemId; + int mTimeOut; + }; + mContext.mMsgTask->sendMsg(new (nothrow) HandleTurnOnMsg(this, dit, timeOut)); + } + else { + // Found in map, update reference count + citer->second++; + LOC_LOGD("turnOn - Data item:%d Num_refs:%d", dit, citer->second); + } +} + +void SystemStatusOsObserver::turnOff(DataItemId dit) +{ + if (nullptr == mContext.mFrameworkActionReqObj) { + LOC_LOGE("%s:%d]: Framework action request object is NULL", __func__, __LINE__); + return; + } + + // Check if data item exists in mActiveRequestCount + map::iterator citer = mActiveRequestCount.find(dit); + if (citer != mActiveRequestCount.end()) { + // found + citer->second--; + LOC_LOGD("turnOff - Data item:%d Remaining:%d", dit, citer->second); + if(citer->second == 0) { + // if this was last reference, remove item from map and turn off module + mActiveRequestCount.erase(citer); + + // Send action turn off to framework + struct HandleTurnOffMsg : public LocMsg { + HandleTurnOffMsg(IFrameworkActionReq* framework, DataItemId dit) : + mFrameworkActionReqObj(framework), mDataItemId(dit) {} + virtual ~HandleTurnOffMsg() {} + void proc() const { + mFrameworkActionReqObj->turnOff(mDataItemId); + } + IFrameworkActionReq* mFrameworkActionReqObj; + DataItemId mDataItemId; + }; + mContext.mMsgTask->sendMsg( + new (nothrow) HandleTurnOffMsg(mContext.mFrameworkActionReqObj, dit)); + } + } +} + +/****************************************************************************** + Helpers +******************************************************************************/ +void SystemStatusOsObserver::sendFirstResponse( + const list& l, IDataItemObserver* to) +{ + if (l.empty()) { + LOC_LOGV("list is empty. Nothing to do. Exiting"); + return; + } + + string clientName; + to->getName(clientName); + list dataItems(0); + + for (auto each : l) { + map::const_iterator citer = mDataItemCache.find(each); + if (citer != mDataItemCache.end()) { + string dv; + citer->second->stringify(dv); + LOC_LOGI("DataItem: %s >> %s", dv.c_str(), clientName.c_str()); + dataItems.push_back(citer->second); + } + } + if (dataItems.empty()) { + LOC_LOGV("No items to notify. Nothing to do. Exiting"); + return; + } + to->notify(dataItems); +} + +void SystemStatusOsObserver::sendCachedDataItems( + const list& l, IDataItemObserver* to) +{ + string clientName; + to->getName(clientName); + list dataItems(0); + + for (auto each : l) { + string dv; + IDataItemCore* di = mDataItemCache[each]; + di->stringify(dv); + LOC_LOGI("DataItem: %s >> %s", dv.c_str(), clientName.c_str()); + dataItems.push_back(di); + } + to->notify(dataItems); +} + +void SystemStatusOsObserver::updateCache(IDataItemCore* d, bool& dataItemUpdated) +{ + if (nullptr == d) { + return; + } + + // Check if data item exists in cache + map::iterator citer = + mDataItemCache.find(d->getId()); + if (citer == mDataItemCache.end()) { + // New data item; not found in cache + IDataItemCore* dataitem = DataItemsFactoryProxy::createNewDataItem(d->getId()); + if (nullptr == dataitem) { + return; + } + + // Copy the contents of the data item + dataitem->copy(d); + pair cpair(d->getId(), dataitem); + // Insert in mDataItemCache + mDataItemCache.insert(cpair); + dataItemUpdated = true; + } + else { + // Found in cache; Update cache if necessary + if(0 == citer->second->copy(d, &dataItemUpdated)) { + return; + } + } + + if (dataItemUpdated) { + LOC_LOGV("DataItem:%d updated:%d", d->getId(), dataItemUpdated); + } +} + +} // namespace loc_core + diff --git a/gps/core/SystemStatusOsObserver.h b/gps/core/SystemStatusOsObserver.h new file mode 100644 index 0000000..985e5c9 --- /dev/null +++ b/gps/core/SystemStatusOsObserver.h @@ -0,0 +1,135 @@ +/* Copyright (c) 2015-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 __SYSTEM_STATUS_OSOBSERVER__ +#define __SYSTEM_STATUS_OSOBSERVER__ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace loc_core +{ +/****************************************************************************** + SystemStatusOsObserver +******************************************************************************/ +using namespace std; + +// Forward Declarations +class IDataItemCore; +template class IClientIndex; +template class IDataItemIndex; + +struct SystemContext { + IDataItemSubscription* mSubscriptionObj; + IFrameworkActionReq* mFrameworkActionReqObj; + const MsgTask* mMsgTask; + + inline SystemContext() : + mSubscriptionObj(NULL), + mFrameworkActionReqObj(NULL), + mMsgTask(NULL) {} +}; + +typedef map> ObserverReqCache; + +// Clients wanting to get data from OS/Framework would need to +// subscribe with OSObserver using IDataItemSubscription interface. +// Such clients would need to implement IDataItemObserver interface +// to receive data when it becomes available. +class SystemStatusOsObserver : public IOsObserver { + +public: + // ctor + SystemStatusOsObserver(const MsgTask* msgTask); + + // dtor + ~SystemStatusOsObserver(); + + // To set the subscription object + virtual void setSubscriptionObj(IDataItemSubscription* subscriptionObj); + + // To set the framework action request object + inline void setFrameworkActionReqObj(IFrameworkActionReq* frameworkActionReqObj) { + mContext.mFrameworkActionReqObj = frameworkActionReqObj; + } + + // IDataItemSubscription Overrides + virtual void subscribe(const list& l, IDataItemObserver* client); + virtual void updateSubscription(const list& l, IDataItemObserver* client); + virtual void requestData(const list& l, IDataItemObserver* client); + virtual void unsubscribe(const list& l, IDataItemObserver* client); + virtual void unsubscribeAll(IDataItemObserver* client); + + // IDataItemObserver Overrides + virtual void notify(const list& dlist); + inline virtual void getName(string& name) { + name = mAddress; + } + + // IFrameworkActionReq Overrides + virtual void turnOn(DataItemId dit, int timeOut = 0); + virtual void turnOff(DataItemId dit); + +private: + SystemContext mContext; + const string mAddress; + IClientIndex* mClientIndex; + IDataItemIndex* mDataItemIndex; + map mDataItemCache; + map mActiveRequestCount; + + // Cache the subscribe and requestData till subscription obj is obtained + ObserverReqCache mSubscribeReqCache; + ObserverReqCache mReqDataCache; + void cacheObserverRequest(ObserverReqCache& reqCache, + const list& l, IDataItemObserver* client); + + // Helpers + void sendFirstResponse(const list& l, IDataItemObserver* to); + void sendCachedDataItems(const list& l, IDataItemObserver* to); + void updateCache(IDataItemCore* d, bool& dataItemUpdated); + inline void logMe(const list& l) { + for (auto id : l) { + LOC_LOGD("DataItem %d", id); + } + } +}; + +} // namespace loc_core + +#endif //__SYSTEM_STATUS__ + diff --git a/gps/core/UlpProxyBase.h b/gps/core/UlpProxyBase.h index 2e92bed..8863b66 100644 --- a/gps/core/UlpProxyBase.h +++ b/gps/core/UlpProxyBase.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2016, The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-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 @@ -30,9 +30,7 @@ #define ULP_PROXY_BASE_H #include - -struct FlpExtLocation_s; -struct FlpExtBatchOptions; +#include namespace loc_core { @@ -54,24 +52,18 @@ public: return false; } - inline virtual bool reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, + inline virtual bool reportPosition(const UlpLocation &location, + const GpsLocationExtended &locationExtended, enum loc_sess_status status, LocPosTechMask loc_technology_mask) { (void)location; (void)locationExtended; - (void)locationExt; (void)status; (void)loc_technology_mask; return false; } - inline virtual bool reportSv(GnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt) { - (void)svStatus; - (void)locationExtended; - (void)svExt; + inline virtual bool reportSv(const GnssSvNotification& svNotify) { + (void)svNotify; return false; } inline virtual bool reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet) { @@ -84,7 +76,7 @@ public: (void)svPolynomial; return false; } - inline virtual bool reportStatus(GpsStatusValue status) { + inline virtual bool reportStatus(LocGpsStatusValue status) { (void)status; return false; @@ -97,24 +89,34 @@ public: (void)capabilities; } - inline virtual bool reportBatchingSession(FlpExtBatchOptions &options, - bool active) { - - (void)options; - (void)active; + inline virtual bool reportBatchingSession(const LocationOptions& options, bool active) + { + (void)options; + (void)active; + return false; + } + inline virtual bool reportPositions(const UlpLocation* ulpLocations, + const GpsLocationExtended* extendedLocations, + const uint32_t* techMasks, + const size_t count) + { + (void)ulpLocations; + (void)extendedLocations; + (void)techMasks; + (void)count; return false; } - inline virtual bool reportPositions(const struct FlpExtLocation_s* locations, - int32_t number_of_locations) { - (void)locations; - (void)number_of_locations; - return false; - } - inline virtual bool reportDeleteAidingData(GpsAidingData aidingData) + inline virtual bool reportDeleteAidingData(LocGpsAidingData aidingData) { (void)aidingData; return false; } + inline virtual bool reportNmea(const char* nmea, int length) + { + (void)nmea; + (void)length; + return false; + } }; } // namespace loc_core diff --git a/gps/core/data-items/DataItemId.h b/gps/core/data-items/DataItemId.h new file mode 100644 index 0000000..1bf132a --- /dev/null +++ b/gps/core/data-items/DataItemId.h @@ -0,0 +1,73 @@ +/* Copyright (c) 2015-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 __DATAITEMID_H__ +#define __DATAITEMID_H__ + +/** + * Enumeration of Data Item types + * When add/remove/update changes are made to Data Items, this file needs to be updated + * accordingly + */ +typedef enum e_DataItemId { + INVALID_DATA_ITEM_ID = -1, + // 0 - 4 + AIRPLANEMODE_DATA_ITEM_ID, + ENH_DATA_ITEM_ID, + GPSSTATE_DATA_ITEM_ID, + NLPSTATUS_DATA_ITEM_ID, + WIFIHARDWARESTATE_DATA_ITEM_ID, + // 5 - 9 + NETWORKINFO_DATA_ITEM_ID, + RILVERSION_DATA_ITEM_ID, + RILSERVICEINFO_DATA_ITEM_ID, + RILCELLINFO_DATA_ITEM_ID, + SERVICESTATUS_DATA_ITEM_ID, + // 10 - 14 + MODEL_DATA_ITEM_ID, + MANUFACTURER_DATA_ITEM_ID, + VOICECALL_DATA_ITEM, + ASSISTED_GPS_DATA_ITEM_ID, + SCREEN_STATE_DATA_ITEM_ID, + // 15 - 19 + POWER_CONNECTED_STATE_DATA_ITEM_ID, + TIMEZONE_CHANGE_DATA_ITEM_ID, + TIME_CHANGE_DATA_ITEM_ID, + WIFI_SUPPLICANT_STATUS_DATA_ITEM_ID, + SHUTDOWN_STATE_DATA_ITEM_ID, + // 20 - 24 + TAC_DATA_ITEM_ID, + MCCMNC_DATA_ITEM_ID, + BTLE_SCAN_DATA_ITEM_ID, + BT_SCAN_DATA_ITEM_ID, + OEM_GTP_UPLOAD_TRIGGER_READY_ITEM_ID, + MAX_DATA_ITEM_ID +} DataItemId; + +#endif // #ifndef __DATAITEMID_H__ diff --git a/gps/core/data-items/DataItemsFactoryProxy.cpp b/gps/core/data-items/DataItemsFactoryProxy.cpp new file mode 100644 index 0000000..130eecf --- /dev/null +++ b/gps/core/data-items/DataItemsFactoryProxy.cpp @@ -0,0 +1,99 @@ +/* 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 "DataItemsFactoryProxy" + +#include +#include +#include +#include +#include + +namespace loc_core +{ +void* DataItemsFactoryProxy::dataItemLibHandle = NULL; +get_concrete_data_item_fn* DataItemsFactoryProxy::getConcreteDIFunc = NULL; + +IDataItemCore* DataItemsFactoryProxy::createNewDataItem(DataItemId id) +{ + IDataItemCore *mydi = nullptr; + + if (NULL != getConcreteDIFunc) { + mydi = (*getConcreteDIFunc)(id); + } + else { + // first call to this function, symbol not yet loaded + if (NULL == dataItemLibHandle) { + LOC_LOGD("Loaded library %s",DATA_ITEMS_LIB_NAME); + dataItemLibHandle = dlopen(DATA_ITEMS_LIB_NAME, RTLD_NOW); + if (NULL == dataItemLibHandle) { + // dlopen failed. + const char * err = dlerror(); + if (NULL == err) + { + err = "Unknown"; + } + LOC_LOGE("%s:%d]: failed to load library %s; error=%s", + __func__, __LINE__, DATA_ITEMS_LIB_NAME, err); + } + } + + // load sym - if dlopen handle is obtained and symbol is not yet obtained + if (NULL != dataItemLibHandle) { + getConcreteDIFunc = (get_concrete_data_item_fn * ) + dlsym(dataItemLibHandle, DATA_ITEMS_GET_CONCRETE_DI); + if (NULL != getConcreteDIFunc) { + LOC_LOGD("Loaded function %s : %x",DATA_ITEMS_GET_CONCRETE_DI,getConcreteDIFunc); + mydi = (*getConcreteDIFunc)(id); + } + else { + // dlysm failed. + const char * err = dlerror(); + if (NULL == err) + { + err = "Unknown"; + } + LOC_LOGE("%s:%d]: failed to find symbol %s; error=%s", + __func__, __LINE__, DATA_ITEMS_GET_CONCRETE_DI, err); + } + } + } + return mydi; +} + +void DataItemsFactoryProxy::closeDataItemLibraryHandle() +{ + if (NULL != dataItemLibHandle) { + dlclose(dataItemLibHandle); + dataItemLibHandle = NULL; + } +} + +} // namespace loc_core + + diff --git a/gps/loc_api/libloc_api_50001/loc_eng_log.cpp b/gps/core/data-items/DataItemsFactoryProxy.h similarity index 69% rename from gps/loc_api/libloc_api_50001/loc_eng_log.cpp rename to gps/core/data-items/DataItemsFactoryProxy.h index 3a34167..cfd447d 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng_log.cpp +++ b/gps/core/data-items/DataItemsFactoryProxy.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved. +/* 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 @@ -27,9 +27,29 @@ * */ -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_eng" +#ifndef __DATAITEMFACTORYBASE__ +#define __DATAITEMFACTORYBASE__ -#include "loc_log.h" -#include "loc_eng_log.h" +#include +#include + +namespace loc_core +{ + +#define DATA_ITEMS_LIB_NAME "libdataitems.so" +#define DATA_ITEMS_GET_CONCRETE_DI "getConcreteDataItem" + +typedef IDataItemCore * (get_concrete_data_item_fn)(DataItemId); + +class DataItemsFactoryProxy { +public: + static IDataItemCore* createNewDataItem(DataItemId id); + static void closeDataItemLibraryHandle(); + static void *dataItemLibHandle; + static get_concrete_data_item_fn *getConcreteDIFunc; +}; + +} // namespace loc_core + +#endif //__DATAITEMFACTORYBASE__ diff --git a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn.h b/gps/core/data-items/IDataItemCore.h similarity index 56% rename from gps/loc_api/libloc_api_50001/loc_eng_dmn_conn.h rename to gps/core/data-items/IDataItemCore.h index 1d8c142..6084c92 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn.h +++ b/gps/core/data-items/IDataItemCore.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved. +/* Copyright (c) 2015, 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 @@ -26,34 +26,57 @@ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ -#ifndef LOC_ENG_DATA_SERVER_H -#define LOC_ENG_DATA_SERVER_H -#include "loc_eng_dmn_conn_thread_helper.h" +#ifndef __IDATAITEMCORE_H__ +#define __IDATAITEMCORE_H__ -#ifdef _ANDROID_ +#include +#include -#define GPSONE_LOC_API_Q_PATH "/data/misc/location/gpsone_d/gpsone_loc_api_q" -#define GPSONE_LOC_API_RESP_Q_PATH "/data/misc/location/gpsone_d/gpsone_loc_api_resp_q" -#define QUIPC_CTRL_Q_PATH "/data/misc/location/gpsone_d/quipc_ctrl_q" -#define MSAPM_CTRL_Q_PATH "/data/misc/location/gpsone_d/msapm_ctrl_q" -#define MSAPU_CTRL_Q_PATH "/data/misc/location/gpsone_d/msapu_ctrl_q" +namespace loc_core { -#else +using namespace std; -#define GPSONE_LOC_API_Q_PATH "/tmp/gpsone_loc_api_q" -#define GPSONE_LOC_API_RESP_Q_PATH "/tmp/gpsone_loc_api_resp_q" -#define QUIPC_CTRL_Q_PATH "/tmp/quipc_ctrl_q" -#define MSAPM_CTRL_Q_PATH "/tmp/msapm_ctrl_q" -#define MSAPU_CTRL_Q_PATH "/tmp/msapu_ctrl_q" +/** + * @brief IDataItemCore interface. + * @details IDataItemCore interface. + * + */ +class IDataItemCore { +public: + /** + * @brief Gets Data item id. + * @details Gets Data item id. + * @return Data item id. + */ + virtual DataItemId getId () = 0; -#endif + /** + * @brief Stringify. + * @details Stringify. + * + * @param valueStr Reference to string. + */ + virtual void stringify (string & valueStr) = 0; -int loc_eng_dmn_conn_loc_api_server_launch(thelper_create_thread create_thread_cb, - const char * loc_api_q_path, const char * ctrl_q_path, void *agps_handle); -int loc_eng_dmn_conn_loc_api_server_unblock(void); -int loc_eng_dmn_conn_loc_api_server_join(void); -int loc_eng_dmn_conn_loc_api_server_data_conn(int, int); + /** + * @brief copy. + * @details copy. + * + * @param src Where to copy from. + * @param dataItemCopied Boolean flag indicated whether or not copied. + * + * @return Zero for success or non zero for failure. + */ + virtual int32_t copy (IDataItemCore * src, bool *dataItemCopied = nullptr) = 0; -#endif /* LOC_ENG_DATA_SERVER_H */ + /** + * @brief Destructor. + * @details Destructor. + */ + virtual ~IDataItemCore () {} +}; +} // namespace loc_core + +#endif // __IDATAITEMCORE_H__ diff --git a/gps/core/data-items/common/ClientIndex.cpp b/gps/core/data-items/common/ClientIndex.cpp new file mode 100644 index 0000000..ffb5e1d --- /dev/null +++ b/gps/core/data-items/common/ClientIndex.cpp @@ -0,0 +1,171 @@ +/* Copyright (c) 2015, 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. + * + */ +#include +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace loc_core; + +template +inline ClientIndex :: ClientIndex () {} + +template +inline ClientIndex :: ~ClientIndex () {} + +template +bool ClientIndex :: isSubscribedClient (CT client) { + bool result = false; + ENTRY_LOG (); + typename map < CT, list > :: iterator it = + mDataItemsPerClientMap.find (client); + if (it != mDataItemsPerClientMap.end ()) { + result = true; + } + EXIT_LOG_WITH_ERROR ("%d",result); + return result; +} + +template +void ClientIndex :: getSubscribedList (CT client, list & out) { + ENTRY_LOG (); + typename map < CT, list > :: iterator it = + mDataItemsPerClientMap.find (client); + if (it != mDataItemsPerClientMap.end ()) { + out = it->second; + } + EXIT_LOG_WITH_ERROR ("%d",0); +} + +template +int ClientIndex :: remove (CT client) { + int result = 0; + ENTRY_LOG (); + mDataItemsPerClientMap.erase (client); + EXIT_LOG_WITH_ERROR ("%d",result); + return result; +} + +template +void ClientIndex :: remove (const list & r, list & out) { + ENTRY_LOG (); + typename map < CT, list > :: iterator dicIter = + mDataItemsPerClientMap.begin (); + while (dicIter != mDataItemsPerClientMap.end()) { + typename list :: const_iterator it = r.begin (); + for (; it != r.end (); ++it) { + typename list :: iterator iter = + find (dicIter->second.begin (), dicIter->second.end (), *it); + if (iter != dicIter->second.end ()) { + dicIter->second.erase (iter); + } + } + if (dicIter->second.empty ()) { + out.push_back (dicIter->first); + // Post-increment operator increases the iterator but returns the + // prevous one that will be invalidated by erase() + mDataItemsPerClientMap.erase (dicIter++); + } else { + ++dicIter; + } + } + EXIT_LOG_WITH_ERROR ("%d",0); +} + +template +void ClientIndex :: remove +( + CT client, + const list & r, + list & out +) +{ + ENTRY_LOG (); + typename map < CT, list > :: iterator dicIter = + mDataItemsPerClientMap.find (client); + if (dicIter != mDataItemsPerClientMap.end ()) { + set_intersection (dicIter->second.begin (), dicIter->second.end (), + r.begin (), r.end (), + inserter (out,out.begin ())); + if (!out.empty ()) { + typename list :: iterator it = out.begin (); + for (; it != out.end (); ++it) { + dicIter->second.erase (find (dicIter->second.begin (), + dicIter->second.end (), + *it)); + } + } + if (dicIter->second.empty ()) { + mDataItemsPerClientMap.erase (dicIter); + EXIT_LOG_WITH_ERROR ("%d",0); + } + } + EXIT_LOG_WITH_ERROR ("%d",0); +} + +template +void ClientIndex :: add +( + CT client, + const list & l, + list & out +) +{ + ENTRY_LOG (); + list difference; + typename map < CT, list > :: iterator dicIter = + mDataItemsPerClientMap.find (client); + if (dicIter != mDataItemsPerClientMap.end ()) { + set_difference (l.begin (), l.end (), + dicIter->second.begin (), dicIter->second.end (), + inserter (difference,difference.begin ())); + if (!difference.empty ()) { + difference.sort (); + out = difference; + dicIter->second.merge (difference); + dicIter->second.unique (); + } + } else { + out = l; + pair < CT, list > dicnpair (client, out); + mDataItemsPerClientMap.insert (dicnpair); + } + EXIT_LOG_WITH_ERROR ("%d",0); +} + +// Explicit instantiation must occur in same namespace where class is defined +namespace loc_core +{ + template class ClientIndex ; + template class ClientIndex ; +} diff --git a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h b/gps/core/data-items/common/ClientIndex.h similarity index 59% rename from gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h rename to gps/core/data-items/common/ClientIndex.h index d685c87..feccb05 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.h +++ b/gps/core/data-items/common/ClientIndex.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011, The Linux Foundation. All rights reserved. +/* Copyright (c) 2015, 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 @@ -9,7 +9,7 @@ * 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 + * * 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. * @@ -26,26 +26,45 @@ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ -#ifndef LOC_ENG_DMN_CONN_GLUE_MSG_H -#define LOC_ENG_DMN_CONN_GLUE_MSG_H +#ifndef __CLIENTINDEX_H__ +#define __CLIENTINDEX_H__ -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ +#include +#include +#include +using loc_core::IClientIndex; -#include -#include "loc_eng_dmn_conn_glue_pipe.h" +namespace loc_core +{ -int loc_eng_dmn_conn_glue_msgget(const char * q_path, int mode); -int loc_eng_dmn_conn_glue_msgremove(const char * q_path, int msgqid); -int loc_eng_dmn_conn_glue_msgsnd(int msgqid, const void * msgp, size_t msgsz); -int loc_eng_dmn_conn_glue_msgrcv(int msgqid, void *msgp, size_t msgsz); -int loc_eng_dmn_conn_glue_msgflush(int msgqid); -int loc_eng_dmn_conn_glue_msgunblock(int msgqid); +template -#ifdef __cplusplus -} -#endif /* __cplusplus */ +class ClientIndex : public IClientIndex { -#endif /* LOC_ENG_DMN_CONN_GLUE_MSG_H */ +public: + + ClientIndex (); + + ~ClientIndex (); + + bool isSubscribedClient (CT client); + + void getSubscribedList (CT client, std :: list & out); + + int remove (CT client); + + void remove (const std :: list & r, std :: list & out); + + void remove (CT client, const std :: list & r, std :: list & out); + + void add (CT client, const std :: list & l, std :: list & out); + +private: + //Data members + std :: map < CT , std :: list > mDataItemsPerClientMap; +}; + +} // namespace loc_core + +#endif // #ifndef __CLIENTINDEX_H__ diff --git a/gps/core/data-items/common/DataItemIndex.cpp b/gps/core/data-items/common/DataItemIndex.cpp new file mode 100644 index 0000000..7869b43 --- /dev/null +++ b/gps/core/data-items/common/DataItemIndex.cpp @@ -0,0 +1,202 @@ +/* Copyright (c) 2015, 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. + * + */ + +#include +#include +#include +#include +#include +#include +#include + +using namespace std; +using namespace loc_core; + +template +inline DataItemIndex :: DataItemIndex () {} + +template +inline DataItemIndex :: ~DataItemIndex () {} + +template +void DataItemIndex :: getListOfSubscribedClients + ( + DIT id, + list & out +) +{ + typename map < DIT, list > :: iterator cdiIter = + mClientsPerDataItemMap.find (id); + if (cdiIter != mClientsPerDataItemMap.end ()) { + out = cdiIter->second; + } +} + + +template +int DataItemIndex :: remove (DIT id) { + int result = 0; + ENTRY_LOG (); + mClientsPerDataItemMap.erase (id); + EXIT_LOG_WITH_ERROR ("%d",result); + return result; +} + +template +void DataItemIndex :: remove (const list & r, list & out) { + ENTRY_LOG (); + typename map < DIT, list > :: iterator cdiIter = + mClientsPerDataItemMap.begin (); + while (cdiIter != mClientsPerDataItemMap.end()) { + typename list :: const_iterator it = r.begin (); + for (; it != r.end (); ++it) { + typename list :: iterator iter = + find + ( + cdiIter->second.begin (), + cdiIter->second.end (), + *it + ); + if (iter != cdiIter->second.end ()) { + cdiIter->second.erase (iter); + } + } + + if (cdiIter->second.empty ()) { + out.push_back (cdiIter->first); + // Post-increment operator increases the iterator but returns the + // prevous one that will be invalidated by erase() + mClientsPerDataItemMap.erase (cdiIter++); + } else { + ++cdiIter; + } + } + EXIT_LOG_WITH_ERROR ("%d",0); +} + +template +void DataItemIndex :: remove +( + DIT id, + const list & r, + list & out +) +{ + ENTRY_LOG (); + + typename map < DIT, list > :: iterator cdiIter = + mClientsPerDataItemMap.find (id); + if (cdiIter != mClientsPerDataItemMap.end ()) { + set_intersection (cdiIter->second.begin (), cdiIter->second.end (), + r.begin (), r.end (), + inserter (out, out.begin ())); + if (!out.empty ()) { + typename list :: iterator it = out.begin (); + for (; it != out.end (); ++it) { + cdiIter->second.erase (find (cdiIter->second.begin (), + cdiIter->second.end (), + *it)); + } + } + if (cdiIter->second.empty ()) { + mClientsPerDataItemMap.erase (cdiIter); + EXIT_LOG_WITH_ERROR ("%d",0); + } + } + EXIT_LOG_WITH_ERROR ("%d",0); +} + +template +void DataItemIndex :: add +( + DIT id, + const list & l, + list & out +) +{ + ENTRY_LOG (); + list difference; + typename map < DIT, list > :: iterator cdiIter = + mClientsPerDataItemMap.find (id); + if (cdiIter != mClientsPerDataItemMap.end ()) { + set_difference (l.begin (), l.end (), + cdiIter->second.begin (), cdiIter->second.end (), + inserter (difference, difference.begin ())); + if (!difference.empty ()) { + difference.sort (); + out = difference; + cdiIter->second.merge (difference); + } + } else { + out = l; + pair < DIT, list > cndipair (id, out); + mClientsPerDataItemMap.insert (cndipair); + } + EXIT_LOG_WITH_ERROR ("%d",0); +} + +template +void DataItemIndex :: add +( + CT client, + const list & l, + list & out +) +{ + ENTRY_LOG (); + typename map < DIT, list > :: iterator cdiIter; + typename list :: const_iterator it = l.begin (); + for (; it != l.end (); ++it) { + cdiIter = mClientsPerDataItemMap.find (*it); + if (cdiIter == mClientsPerDataItemMap.end ()) { + out.push_back (*it); + pair < DIT, list > cndiPair (*it, list (1, client)); + mClientsPerDataItemMap.insert (cndiPair); + } else { + typename list :: iterator clientIter = + find + ( + cdiIter->second.begin (), + cdiIter->second.end (), + client + ); + if (clientIter == cdiIter->second.end()) { + cdiIter->second.push_back (client); + } + } + } + EXIT_LOG_WITH_ERROR ("%d",0); +} + +// Explicit instantiation must occur in same namespace where class is defined +namespace loc_core +{ + template class DataItemIndex ; + template class DataItemIndex ; +} diff --git a/gps/core/data-items/common/DataItemIndex.h b/gps/core/data-items/common/DataItemIndex.h new file mode 100644 index 0000000..d72e89e --- /dev/null +++ b/gps/core/data-items/common/DataItemIndex.h @@ -0,0 +1,70 @@ +/* Copyright (c) 2015, 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 __DATAITEMINDEX_H__ +#define __DATAITEMINDEX_H__ + +#include +#include +#include + +using loc_core::IDataItemIndex; + +namespace loc_core +{ + +template + +class DataItemIndex : public IDataItemIndex { + +public: + + DataItemIndex (); + + ~DataItemIndex (); + + void getListOfSubscribedClients (DIT id, std :: list & out); + + int remove (DIT id); + + void remove (const std :: list & r, std :: list & out); + + void remove (DIT id, const std :: list & r, std :: list & out); + + void add (DIT id, const std :: list & l, std :: list & out); + + void add (CT client, const std :: list & l, std :: list & out); + +private: + std :: map < DIT, std :: list > mClientsPerDataItemMap; +}; + +} // namespace loc_core + +#endif // #ifndef __DATAITEMINDEX_H__ diff --git a/gps/core/data-items/common/IClientIndex.h b/gps/core/data-items/common/IClientIndex.h new file mode 100644 index 0000000..0272e7b --- /dev/null +++ b/gps/core/data-items/common/IClientIndex.h @@ -0,0 +1,83 @@ +/* Copyright (c) 2015, 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 __ICLIENTINDEX_H__ +#define __ICLIENTINDEX_H__ + +#include + +namespace loc_core +{ + +template + +class IClientIndex { +public: + + // Checks if client is subscribed + virtual bool isSubscribedClient (CT client) = 0; + + // gets subscription list + virtual void getSubscribedList (CT client, std :: list & out) = 0; + + // removes an entry + virtual int remove (CT client) = 0; + + // removes std :: list of data items and returns a list of clients + // removed if any. + virtual void remove + ( + const std :: list & r, + std :: list & out + ) = 0; + + // removes list of data items indexed by client and returns list + // of data items removed if any. + virtual void remove + ( + CT client, + const std :: list & r, + std :: list & out + ) = 0; + + // adds/modifies entry in map and returns new data items added. + virtual void add + ( + CT client, + const std :: list & l, + std :: list & out + ) = 0; + + // dtor + virtual ~IClientIndex () {} +}; + +} // namespace loc_core + +#endif // #ifndef __ICLIENTINDEX_H__ diff --git a/gps/core/data-items/common/IDataItemIndex.h b/gps/core/data-items/common/IDataItemIndex.h new file mode 100644 index 0000000..9185582 --- /dev/null +++ b/gps/core/data-items/common/IDataItemIndex.h @@ -0,0 +1,94 @@ +/* Copyright (c) 2015, 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 __IDATAITEMINDEX_H__ +#define __IDATAITEMINDEX_H__ + +#include + +namespace loc_core +{ + +template + +class IDataItemIndex { + +public: + + // gets std :: list of subscribed clients + virtual void getListOfSubscribedClients + ( + DIT id, + std :: list & out + ) = 0; + + // removes an entry from + virtual int remove (DIT id) = 0; + + // removes list of clients and returns a list of data items + // removed if any. + virtual void remove + ( + const std :: list & r, + std :: list & out + ) = 0; + + // removes list of clients indexed by data item and returns list of + // clients removed if any. + virtual void remove + ( + DIT id, + const std :: list & r, + std :: list & out + ) = 0; + + // adds/modifies entry and returns new clients added + virtual void add + ( + DIT id, + const std :: list & l, + std :: list & out + ) = 0; + + // adds/modifies entry and returns yet to subscribe list of data items + virtual void add + ( + CT client, + const std :: list & l, + std :: list & out + ) = 0; + + // dtor + virtual ~IDataItemIndex () {} +}; + +} // namespace loc_core + +#endif // #ifndef __IDATAITEMINDEX_H__ + diff --git a/gps/loc_api/libloc_api_50001/loc.h b/gps/core/data-items/common/IndexFactory.cpp similarity index 58% rename from gps/loc_api/libloc_api_50001/loc.h rename to gps/core/data-items/common/IndexFactory.cpp index 8cf77fc..cf49475 100644 --- a/gps/loc_api/libloc_api_50001/loc.h +++ b/gps/core/data-items/common/IndexFactory.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011,2014 The Linux Foundation. All rights reserved. +/* Copyright (c) 2015, 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 @@ -27,41 +27,38 @@ * */ -#ifndef __LOC_H__ -#define __LOC_H__ +#include +#include +#include +#include +#include +#include +#include +#include -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ +using namespace std; +using loc_core::IClientIndex; +using loc_core::IDataItemIndex; +using loc_core::IDataItemObserver; +using namespace loc_core; -#include -#include -#include - -#define XTRA_DATA_MAX_SIZE 100000 /*bytes*/ - -typedef void (*loc_location_cb_ext) (UlpLocation* location, void* locExt); -typedef void (*loc_sv_status_cb_ext) (GpsSvStatus* sv_status, void* svExt); -typedef void* (*loc_ext_parser)(void* data); - -typedef struct { - loc_location_cb_ext location_cb; - gps_status_callback status_cb; - loc_sv_status_cb_ext sv_status_cb; - gps_nmea_callback nmea_cb; - gps_set_capabilities set_capabilities_cb; - gps_acquire_wakelock acquire_wakelock_cb; - gps_release_wakelock release_wakelock_cb; - gps_create_thread create_thread_cb; - loc_ext_parser location_ext_parser; - loc_ext_parser sv_ext_parser; - gps_request_utc_time request_utc_time_cb; - gnss_set_system_info set_system_info_cb; - gnss_sv_status_callback gnss_sv_status_cb; -} LocCallbacks; - -#ifdef __cplusplus +template +inline IClientIndex * IndexFactory :: createClientIndex +() +{ + return new (nothrow) ClientIndex (); } -#endif /* __cplusplus */ -#endif //__LOC_H__ +template +inline IDataItemIndex * IndexFactory :: createDataItemIndex +() +{ + return new (nothrow) DataItemIndex (); +} + +// Explicit instantiation must occur in same namespace where class is defined +namespace loc_core +{ + template class IndexFactory ; + template class IndexFactory ; +} diff --git a/gps/loc_api/libloc_api_50001/loc_eng_log.h b/gps/core/data-items/common/IndexFactory.h similarity index 77% rename from gps/loc_api/libloc_api_50001/loc_eng_log.h rename to gps/core/data-items/common/IndexFactory.h index a68bd84..9a2070e 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng_log.h +++ b/gps/core/data-items/common/IndexFactory.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved. +/* Copyright (c) 2015, 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 @@ -27,18 +27,22 @@ * */ -#ifndef LOC_ENG_LOG_H -#define LOC_ENG_LOG_H +#ifndef __INDEXFACTORY_H__ +#define __INDEXFACTORY_H__ -#ifdef __cplusplus -extern "C" +#include +#include + +namespace loc_core { -#endif +template +class IndexFactory { -#include +public: + static IClientIndex * createClientIndex (); + static IDataItemIndex * createDataItemIndex (); +}; -#ifdef __cplusplus -} -#endif +} // namespace loc_core -#endif /* LOC_ENG_LOG_H */ +#endif // #ifndef __INDEXFACTORY_H__ diff --git a/gps/core/loc_core_log.cpp b/gps/core/loc_core_log.cpp index 4556fae..5a627dd 100644 --- a/gps/core/loc_core_log.cpp +++ b/gps/core/loc_core_log.cpp @@ -27,7 +27,7 @@ * */ -#define LOG_NDDEBUG 0 +#define LOG_NDEBUG 0 #define LOG_TAG "LocSvc_core_log" #include @@ -51,16 +51,16 @@ void LocPosMode::logv() const /* GPS status names */ static const loc_name_val_s_type gps_status_name[] = { - NAME_VAL( GPS_STATUS_NONE ), - NAME_VAL( GPS_STATUS_SESSION_BEGIN ), - NAME_VAL( GPS_STATUS_SESSION_END ), - NAME_VAL( GPS_STATUS_ENGINE_ON ), - NAME_VAL( GPS_STATUS_ENGINE_OFF ), + NAME_VAL( LOC_GPS_STATUS_NONE ), + NAME_VAL( LOC_GPS_STATUS_SESSION_BEGIN ), + NAME_VAL( LOC_GPS_STATUS_SESSION_END ), + NAME_VAL( LOC_GPS_STATUS_ENGINE_ON ), + NAME_VAL( LOC_GPS_STATUS_ENGINE_OFF ), }; static const int gps_status_num = sizeof(gps_status_name) / sizeof(loc_name_val_s_type); /* Find Android GPS status name */ -const char* loc_get_gps_status_name(GpsStatusValue gps_status) +const char* loc_get_gps_status_name(LocGpsStatusValue gps_status) { return loc_get_name_from_val(gps_status_name, gps_status_num, (long) gps_status); @@ -81,7 +81,7 @@ static const loc_name_val_s_type loc_eng_position_modes[] = }; static const int loc_eng_position_mode_num = sizeof(loc_eng_position_modes) / sizeof(loc_name_val_s_type); -const char* loc_get_position_mode_name(GpsPositionMode mode) +const char* loc_get_position_mode_name(LocGpsPositionMode mode) { return loc_get_name_from_val(loc_eng_position_modes, loc_eng_position_mode_num, (long) mode); } @@ -90,12 +90,12 @@ const char* loc_get_position_mode_name(GpsPositionMode mode) static const loc_name_val_s_type loc_eng_position_recurrences[] = { - NAME_VAL( GPS_POSITION_RECURRENCE_PERIODIC ), - NAME_VAL( GPS_POSITION_RECURRENCE_SINGLE ) + NAME_VAL( LOC_GPS_POSITION_RECURRENCE_PERIODIC ), + NAME_VAL( LOC_GPS_POSITION_RECURRENCE_SINGLE ) }; static const int loc_eng_position_recurrence_num = sizeof(loc_eng_position_recurrences) / sizeof(loc_name_val_s_type); -const char* loc_get_position_recurrence_name(GpsPositionRecurrence recur) +const char* loc_get_position_recurrence_name(LocGpsPositionRecurrence recur) { return loc_get_name_from_val(loc_eng_position_recurrences, loc_eng_position_recurrence_num, (long) recur); } @@ -104,23 +104,23 @@ const char* loc_get_position_recurrence_name(GpsPositionRecurrence recur) static const loc_name_val_s_type loc_eng_aiding_data_bits[] = { - NAME_VAL( GPS_DELETE_EPHEMERIS ), - NAME_VAL( GPS_DELETE_ALMANAC ), - NAME_VAL( GPS_DELETE_POSITION ), - NAME_VAL( GPS_DELETE_TIME ), - NAME_VAL( GPS_DELETE_IONO ), - NAME_VAL( GPS_DELETE_UTC ), - NAME_VAL( GPS_DELETE_HEALTH ), - NAME_VAL( GPS_DELETE_SVDIR ), - NAME_VAL( GPS_DELETE_SVSTEER ), - NAME_VAL( GPS_DELETE_SADATA ), - NAME_VAL( GPS_DELETE_RTI ), - NAME_VAL( GPS_DELETE_CELLDB_INFO ), - NAME_VAL( GPS_DELETE_ALL) + NAME_VAL( LOC_GPS_DELETE_EPHEMERIS ), + NAME_VAL( LOC_GPS_DELETE_ALMANAC ), + NAME_VAL( LOC_GPS_DELETE_POSITION ), + NAME_VAL( LOC_GPS_DELETE_TIME ), + NAME_VAL( LOC_GPS_DELETE_IONO ), + NAME_VAL( LOC_GPS_DELETE_UTC ), + NAME_VAL( LOC_GPS_DELETE_HEALTH ), + NAME_VAL( LOC_GPS_DELETE_SVDIR ), + NAME_VAL( LOC_GPS_DELETE_SVSTEER ), + NAME_VAL( LOC_GPS_DELETE_SADATA ), + NAME_VAL( LOC_GPS_DELETE_RTI ), + NAME_VAL( LOC_GPS_DELETE_CELLDB_INFO ), + NAME_VAL( LOC_GPS_DELETE_ALL) }; static const int loc_eng_aiding_data_bit_num = sizeof(loc_eng_aiding_data_bits) / sizeof(loc_name_val_s_type); -const char* loc_get_aiding_data_mask_names(GpsAidingData data) +const char* loc_get_aiding_data_mask_names(LocGpsAidingData /*data*/) { return NULL; } @@ -128,15 +128,15 @@ const char* loc_get_aiding_data_mask_names(GpsAidingData data) static const loc_name_val_s_type loc_eng_agps_types[] = { - NAME_VAL( AGPS_TYPE_INVALID ), - NAME_VAL( AGPS_TYPE_ANY ), - NAME_VAL( AGPS_TYPE_SUPL ), - NAME_VAL( AGPS_TYPE_C2K ), - NAME_VAL( AGPS_TYPE_WWAN_ANY ) + NAME_VAL( LOC_AGPS_TYPE_INVALID ), + NAME_VAL( LOC_AGPS_TYPE_ANY ), + NAME_VAL( LOC_AGPS_TYPE_SUPL ), + NAME_VAL( LOC_AGPS_TYPE_C2K ), + NAME_VAL( LOC_AGPS_TYPE_WWAN_ANY ) }; static const int loc_eng_agps_type_num = sizeof(loc_eng_agps_types) / sizeof(loc_name_val_s_type); -const char* loc_get_agps_type_name(AGpsType type) +const char* loc_get_agps_type_name(LocAGpsType type) { return loc_get_name_from_val(loc_eng_agps_types, loc_eng_agps_type_num, (long) type); } @@ -144,14 +144,14 @@ const char* loc_get_agps_type_name(AGpsType type) static const loc_name_val_s_type loc_eng_ni_types[] = { - NAME_VAL( GPS_NI_TYPE_VOICE ), - NAME_VAL( GPS_NI_TYPE_UMTS_SUPL ), - NAME_VAL( GPS_NI_TYPE_UMTS_CTRL_PLANE ), - NAME_VAL( GPS_NI_TYPE_EMERGENCY_SUPL ) + NAME_VAL( LOC_GPS_NI_TYPE_VOICE ), + NAME_VAL( LOC_GPS_NI_TYPE_UMTS_SUPL ), + NAME_VAL( LOC_GPS_NI_TYPE_UMTS_CTRL_PLANE ), + NAME_VAL( LOC_GPS_NI_TYPE_EMERGENCY_SUPL ) }; static const int loc_eng_ni_type_num = sizeof(loc_eng_ni_types) / sizeof(loc_name_val_s_type); -const char* loc_get_ni_type_name(GpsNiType type) +const char* loc_get_ni_type_name(LocGpsNiType type) { return loc_get_name_from_val(loc_eng_ni_types, loc_eng_ni_type_num, (long) type); } @@ -159,13 +159,13 @@ const char* loc_get_ni_type_name(GpsNiType type) static const loc_name_val_s_type loc_eng_ni_responses[] = { - NAME_VAL( GPS_NI_RESPONSE_ACCEPT ), - NAME_VAL( GPS_NI_RESPONSE_DENY ), - NAME_VAL( GPS_NI_RESPONSE_DENY ) + NAME_VAL( LOC_GPS_NI_RESPONSE_ACCEPT ), + NAME_VAL( LOC_GPS_NI_RESPONSE_DENY ), + NAME_VAL( LOC_GPS_NI_RESPONSE_DENY ) }; static const int loc_eng_ni_reponse_num = sizeof(loc_eng_ni_responses) / sizeof(loc_name_val_s_type); -const char* loc_get_ni_response_name(GpsUserResponseType response) +const char* loc_get_ni_response_name(LocGpsUserResponseType response) { return loc_get_name_from_val(loc_eng_ni_responses, loc_eng_ni_reponse_num, (long) response); } @@ -173,15 +173,15 @@ const char* loc_get_ni_response_name(GpsUserResponseType response) static const loc_name_val_s_type loc_eng_ni_encodings[] = { - NAME_VAL( GPS_ENC_NONE ), - NAME_VAL( GPS_ENC_SUPL_GSM_DEFAULT ), - NAME_VAL( GPS_ENC_SUPL_UTF8 ), - NAME_VAL( GPS_ENC_SUPL_UCS2 ), - NAME_VAL( GPS_ENC_UNKNOWN ) + NAME_VAL( LOC_GPS_ENC_NONE ), + NAME_VAL( LOC_GPS_ENC_SUPL_GSM_DEFAULT ), + NAME_VAL( LOC_GPS_ENC_SUPL_UTF8 ), + NAME_VAL( LOC_GPS_ENC_SUPL_UCS2 ), + NAME_VAL( LOC_GPS_ENC_UNKNOWN ) }; static const int loc_eng_ni_encoding_num = sizeof(loc_eng_ni_encodings) / sizeof(loc_name_val_s_type); -const char* loc_get_ni_encoding_name(GpsNiEncodingType encoding) +const char* loc_get_ni_encoding_name(LocGpsNiEncodingType encoding) { return loc_get_name_from_val(loc_eng_ni_encodings, loc_eng_ni_encoding_num, (long) encoding); } @@ -229,15 +229,15 @@ const char* loc_get_position_sess_status_name(enum loc_sess_status status) static const loc_name_val_s_type loc_eng_agps_status_names[] = { - NAME_VAL( GPS_REQUEST_AGPS_DATA_CONN ), - NAME_VAL( GPS_RELEASE_AGPS_DATA_CONN ), - NAME_VAL( GPS_AGPS_DATA_CONNECTED ), - NAME_VAL( GPS_AGPS_DATA_CONN_DONE ), - NAME_VAL( GPS_AGPS_DATA_CONN_FAILED ) + NAME_VAL( LOC_GPS_REQUEST_AGPS_DATA_CONN ), + NAME_VAL( LOC_GPS_RELEASE_AGPS_DATA_CONN ), + NAME_VAL( LOC_GPS_AGPS_DATA_CONNECTED ), + NAME_VAL( LOC_GPS_AGPS_DATA_CONN_DONE ), + NAME_VAL( LOC_GPS_AGPS_DATA_CONN_FAILED ) }; static const int loc_eng_agps_status_num = sizeof(loc_eng_agps_status_names) / sizeof(loc_name_val_s_type); -const char* loc_get_agps_status_name(AGpsStatusValue status) +const char* loc_get_agps_status_name(LocAGpsStatusValue status) { return loc_get_name_from_val(loc_eng_agps_status_names, loc_eng_agps_status_num, (long) status); } diff --git a/gps/core/loc_core_log.h b/gps/core/loc_core_log.h index 8a1825a..2beb687 100644 --- a/gps/core/loc_core_log.h +++ b/gps/core/loc_core_log.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2013, The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2013, 2016-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 @@ -30,26 +30,26 @@ #ifndef LOC_CORE_LOG_H #define LOC_CORE_LOG_H +#include +#include + #ifdef __cplusplus extern "C" { #endif -#include -#include - -const char* loc_get_gps_status_name(GpsStatusValue gps_status); -const char* loc_get_position_mode_name(GpsPositionMode mode); -const char* loc_get_position_recurrence_name(GpsPositionRecurrence recur); -const char* loc_get_aiding_data_mask_names(GpsAidingData data); -const char* loc_get_agps_type_name(AGpsType type); -const char* loc_get_ni_type_name(GpsNiType type); -const char* loc_get_ni_response_name(GpsUserResponseType response); -const char* loc_get_ni_encoding_name(GpsNiEncodingType encoding); +const char* loc_get_gps_status_name(LocGpsStatusValue gps_status); +const char* loc_get_position_mode_name(LocGpsPositionMode mode); +const char* loc_get_position_recurrence_name(LocGpsPositionRecurrence recur); +const char* loc_get_aiding_data_mask_names(LocGpsAidingData data); +const char* loc_get_agps_type_name(LocAGpsType type); +const char* loc_get_ni_type_name(LocGpsNiType type); +const char* loc_get_ni_response_name(LocGpsUserResponseType response); +const char* loc_get_ni_encoding_name(LocGpsNiEncodingType encoding); const char* loc_get_agps_bear_name(AGpsBearerType bear); const char* loc_get_server_type_name(LocServerType type); const char* loc_get_position_sess_status_name(enum loc_sess_status status); -const char* loc_get_agps_status_name(AGpsStatusValue status); +const char* loc_get_agps_status_name(LocAGpsStatusValue status); #ifdef __cplusplus } diff --git a/gps/core/observer/IDataItemObserver.h b/gps/core/observer/IDataItemObserver.h new file mode 100644 index 0000000..7954d85 --- /dev/null +++ b/gps/core/observer/IDataItemObserver.h @@ -0,0 +1,76 @@ +/* Copyright (c) 2015, 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 __IDATAITEMOBSERVER_H__ +#define __IDATAITEMOBSERVER_H__ + +#include +#include + +using namespace std; + +namespace loc_core +{ +class IDataItemCore; + +/** + * @brief IDataItemObserver interface + * @details IDataItemObserver interface; + * In OS dependent code this type serves as a handle to an OS independent instance of this interface. + */ +class IDataItemObserver { + +public: + + /** + * @brief Gets name of Data Item Observer + * @details Gets name of Data Item Observer + * + * @param name reference to name of Data Item Observer + */ + virtual void getName (string & name) = 0; + + /** + * @brief Notify updated values of Data Items + * @details Notifys updated values of Data items + * + * @param dlist List of updated data items + */ + virtual void notify (const std :: list & dlist) = 0; + + /** + * @brief Destructor + * @details Destructor + */ + virtual ~IDataItemObserver () {} +}; + +} // namespace loc_core + +#endif // #ifndef __IDATAITEMOBSERVER_H__ diff --git a/gps/core/observer/IDataItemSubscription.h b/gps/core/observer/IDataItemSubscription.h new file mode 100644 index 0000000..7e8b8c8 --- /dev/null +++ b/gps/core/observer/IDataItemSubscription.h @@ -0,0 +1,129 @@ +/* Copyright (c) 2015, 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 __IDATAITEMSUBSCRIPTION_H__ +#define __IDATAITEMSUBSCRIPTION_H__ + +#include +#include + +namespace loc_core +{ +class IDataItemObserver; + +/** + * @brief IDataItemSubscription interface + * @details IDataItemSubscription interface; + * Defines an interface for operations such as subscribe, + * unsubscribe data items by their IDs. + * Must be implemented by OS dependent code. + */ +class IDataItemSubscription { + +public: + /** + * @brief Subscribe for data items by their IDs + * @details Subscribe for data items by their IDs; + * An IDataItemObserver implementer invokes this method to subscribe + * for a list of DataItems by passing in their Ids. + * A symbolic invocation of this method in the following order + * subscribe ( {1,2,3}, &obj), subscribe ( {2,3,4,5}, &obj) + * where the numbers enclosed in braces indicate a list of data item Ids + * will cause this class implementer to update its subscription list for + * &obj to only contain the following Data Item Ids 1,2,3,4,5. + * + * @param l List of DataItemId + * @param o Pointer to an instance of IDataItemObserver + */ + virtual void subscribe (const std :: list & l, IDataItemObserver * o = NULL) = 0; + + /** + * @brief Update subscription for Data items + * @details Update subscription for Data items; + * An IDataItemObserver implementer invokes this method to update their + * subscription for a list of DataItems by passing in their Ids + * A symbolic invocation of this method in the following order + * updateSubscription ( {1,2,3}, &obj),updateSubscription ( {2,3,4,5}, &obj) + * where the numbers enclosed in braces indicate a list of data item Ids + * will cause this class implementer to update its subscription list for + * &obj to only contain the following Data Item Ids 2,3,4,5. + * Note that this method may or may not be called. + * + * @param l List of DataItemId + * @param o Pointer to an instance of IDataItemObserver + */ + virtual void updateSubscription (const std :: list & l, IDataItemObserver * o = NULL) = 0; + + /** + * @brief Request Data + * @details Request Data + * + * @param l List of DataItemId + * @param o Pointer to an instance of IDataItemObserver + */ + virtual void requestData (const std :: list & l, IDataItemObserver * o = NULL) = 0; + + /** + * @brief Unsubscribe Data items + * @details Unsubscrbe Data items; + * An IDataItemObserver implementer invokes this method to unsubscribe their + * subscription for a list of DataItems by passing in their Ids + * Suppose this class implementor has a currently active subscription list + * containing 1,2,3,4,5,6,7 for &obj then a symbolic invocation of this + * method in the following order + * unsubscribe ( {1,2,3}, &obj), unsubscribe ( {1,2,3,4}, &obj), + * unsubscribe ( {7}, &obj) + * where the numbers enclosed in braces indicate a list of data item Ids + * will cause this class implementer to update its subscription list for + * &obj to only contain the following data item id 5,6. + * + * @param l List of DataItemId + * @param o Pointer to an instance of IDataItemObserver + */ + virtual void unsubscribe (const std :: list & l, IDataItemObserver * o = NULL) = 0; + + /** + * @brief Unsubscribe all data items + * @details Unsubscribe all data items + * + * @param o Pointer to an instance of IDataItemObserver + */ + virtual void unsubscribeAll (IDataItemObserver * o = NULL) = 0; + + /** + * @brief Destructor + * @details Destructor + */ + virtual ~IDataItemSubscription () {} +}; + +} // namespace loc_core + +#endif // #ifndef __IDATAITEMSUBSCRIPTION_H__ + diff --git a/gps/core/observer/IFrameworkActionReq.h b/gps/core/observer/IFrameworkActionReq.h new file mode 100644 index 0000000..c7b3ebd --- /dev/null +++ b/gps/core/observer/IFrameworkActionReq.h @@ -0,0 +1,83 @@ +/* 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 __IFRAMEWORKACTIONREQ_H__ +#define __IFRAMEWORKACTIONREQ_H__ + +#include + +namespace loc_core +{ + +/** + * @brief IFrameworkActionReq interface + * @details IFrameworkActionReq interface; + * Defines an interface for operations such as turnOn, turnOff a + * framework module described by the data item. Framework module + * could be bluetooth, wifi etc. + * Must be implemented by OS dependent code. + * + */ +class IFrameworkActionReq { + +public: + /** + * @brief Turn on the framework module described by the data item. + * @details Turn on the framework module described by the data item; + * An IFrameworkActionReq implementer invokes this method to + * turn on the framework module described by the data item. + * Framework module could be bluetooth, wifi etc. + * + * @param dit DataItemId + * @param timeout Timeout after which to turn off the framework module. + */ + virtual void turnOn (DataItemId dit, int timeOut = 0) = 0; + + /** + * @brief Turn off the framework module described by the data item. + * @details Turn off the framework module described by the data item; + * An IFrameworkActionReq implementer invokes this method to + * turn off the framework module described by the data item. + * Framework module could be bluetooth, wifi etc. + * + * @param dit DataItemId + */ + virtual void turnOff (DataItemId dit) = 0; + + /** + * @brief Destructor + * @details Destructor + */ + virtual ~IFrameworkActionReq () {} +}; + +} // namespace loc_core + +#endif // #ifndef __IFRAMEWORKACTIONREQ_H__ + diff --git a/gps/core/observer/IOsObserver.h b/gps/core/observer/IOsObserver.h new file mode 100644 index 0000000..3db8a85 --- /dev/null +++ b/gps/core/observer/IOsObserver.h @@ -0,0 +1,103 @@ +/* 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 __IOSOBSERVER_H__ +#define __IOSOBSERVER_H__ + +#include +#include +#include +#include +#include + +using namespace std; + +namespace loc_core +{ + +/** + * @brief IOsObserver interface + * @details IOsObserver interface; + * In OS dependent code this type serves as a handle to + * an OS independent instance of this interface. + */ +class IOsObserver : + public IDataItemObserver, + public IDataItemSubscription, + public IFrameworkActionReq { + +public: + + // To set the subscription object + virtual void setSubscriptionObj(IDataItemSubscription *subscriptionObj) = 0; + + // To set the framework action request object + virtual void setFrameworkActionReqObj(IFrameworkActionReq *frameworkActionReqObj) = 0; + + // IDataItemObserver Overrides + inline virtual void getName (string & /*name*/) {} + inline virtual void notify (const std::list & /*dlist*/) {} + + // IDataItemSubscription Overrides + inline virtual void subscribe + ( + const std :: list & /*l*/, + IDataItemObserver * /*client*/ + ){} + inline virtual void updateSubscription + ( + const std :: list & /*l*/, + IDataItemObserver * /*client*/ + ){} + inline virtual void requestData + ( + const std :: list & /*l*/, + IDataItemObserver * /*client*/ + ){} + inline virtual void unsubscribe + ( + const std :: list & /*l*/, + IDataItemObserver * /*client*/ + ){} + inline virtual void unsubscribeAll (IDataItemObserver * /*client*/){} + + // IFrameworkActionReq Overrides + inline virtual void turnOn (DataItemId /*dit*/, int /*timeOut*/){} + inline virtual void turnOff (DataItemId /*dit*/) {} + + /** + * @brief Destructor + * @details Destructor + */ + virtual ~IOsObserver () {} +}; + +} // namespace loc_core + +#endif // #ifndef __IOSOBSERVER_H__ diff --git a/gps/gnss/Agps.cpp b/gps/gnss/Agps.cpp new file mode 100644 index 0000000..72ce293 --- /dev/null +++ b/gps/gnss/Agps.cpp @@ -0,0 +1,912 @@ +/* Copyright (c) 2012-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_Agps" + +#include +#include +#include +#include + +/* -------------------------------------------------------------------- + * AGPS State Machine Methods + * -------------------------------------------------------------------*/ +void AgpsStateMachine::processAgpsEvent(AgpsEvent event){ + + LOC_LOGD("processAgpsEvent(): SM %p, Event %d, State %d", + this, event, mState); + + switch (event) { + + case AGPS_EVENT_SUBSCRIBE: + processAgpsEventSubscribe(); + break; + + case AGPS_EVENT_UNSUBSCRIBE: + processAgpsEventUnsubscribe(); + break; + + case AGPS_EVENT_GRANTED: + processAgpsEventGranted(); + break; + + case AGPS_EVENT_RELEASED: + processAgpsEventReleased(); + break; + + case AGPS_EVENT_DENIED: + processAgpsEventDenied(); + break; + + default: + LOC_LOGE("Invalid Loc Agps Event"); + } +} + +void AgpsStateMachine::processAgpsEventSubscribe(){ + + switch (mState) { + + case AGPS_STATE_RELEASED: + /* Add subscriber to list + * No notifications until we get RSRC_GRANTED */ + addSubscriber(mCurrentSubscriber); + + /* Send data request + * The if condition below is added so that if the data call setup + * fails for DS State Machine, we want to retry in released state. + * for Agps State Machine, sendRsrcRequest() will always return + * success. */ + if (requestOrReleaseDataConn(true) == 0) { + // If data request successful, move to pending state + transitionState(AGPS_STATE_PENDING); + } + break; + + case AGPS_STATE_PENDING: + /* Already requested for data connection, + * do nothing until we get RSRC_GRANTED event; + * Just add this subscriber to the list, for notifications */ + addSubscriber(mCurrentSubscriber); + break; + + case AGPS_STATE_ACQUIRED: + /* We already have the data connection setup, + * Notify current subscriber with GRANTED event, + * And add it to the subscriber list for further notifications. */ + notifyEventToSubscriber(AGPS_EVENT_GRANTED, mCurrentSubscriber, false); + addSubscriber(mCurrentSubscriber); + break; + + case AGPS_STATE_RELEASING: + addSubscriber(mCurrentSubscriber); + break; + + default: + LOC_LOGE("Invalid state: %d", mState); + } +} + +void AgpsStateMachine::processAgpsEventUnsubscribe(){ + + switch (mState) { + + case AGPS_STATE_RELEASED: + notifyEventToSubscriber( + AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false); + break; + + case AGPS_STATE_PENDING: + case AGPS_STATE_ACQUIRED: + /* If the subscriber wishes to wait for connection close, + * before being removed from list, move to inactive state + * and notify */ + if (mCurrentSubscriber->mWaitForCloseComplete) { + mCurrentSubscriber->mIsInactive = true; + } + else { + /* Notify only current subscriber and then delete it from + * subscriberList */ + notifyEventToSubscriber( + AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, true); + } + + /* If no subscribers in list, release data connection */ + if (mSubscriberList.empty()) { + transitionState(AGPS_STATE_RELEASED); + requestOrReleaseDataConn(false); + } + /* Some subscribers in list, but all inactive; + * Release data connection */ + else if(!anyActiveSubscribers()) { + transitionState(AGPS_STATE_RELEASING); + requestOrReleaseDataConn(false); + } + break; + + case AGPS_STATE_RELEASING: + /* If the subscriber wishes to wait for connection close, + * before being removed from list, move to inactive state + * and notify */ + if (mCurrentSubscriber->mWaitForCloseComplete) { + mCurrentSubscriber->mIsInactive = true; + } + else { + /* Notify only current subscriber and then delete it from + * subscriberList */ + notifyEventToSubscriber( + AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, true); + } + + /* If no subscribers in list, just move the state. + * Request for releasing data connection should already have been + * sent */ + if (mSubscriberList.empty()) { + transitionState(AGPS_STATE_RELEASED); + } + break; + + default: + LOC_LOGE("Invalid state: %d", mState); + } +} + +void AgpsStateMachine::processAgpsEventGranted(){ + + switch (mState) { + + case AGPS_STATE_RELEASED: + case AGPS_STATE_ACQUIRED: + case AGPS_STATE_RELEASING: + LOC_LOGE("Unexpected event GRANTED in state %d", mState); + break; + + case AGPS_STATE_PENDING: + // Move to acquired state + transitionState(AGPS_STATE_ACQUIRED); + notifyAllSubscribers( + AGPS_EVENT_GRANTED, false, + AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS); + break; + + default: + LOC_LOGE("Invalid state: %d", mState); + } +} + +void AgpsStateMachine::processAgpsEventReleased(){ + + switch (mState) { + + case AGPS_STATE_RELEASED: + /* Subscriber list should be empty if we are in released state */ + if (!mSubscriberList.empty()) { + LOC_LOGE("Unexpected event RELEASED in RELEASED state"); + } + break; + + case AGPS_STATE_ACQUIRED: + /* Force release received */ + LOC_LOGW("Force RELEASED event in ACQUIRED state"); + transitionState(AGPS_STATE_RELEASED); + notifyAllSubscribers( + AGPS_EVENT_RELEASED, true, + AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS); + break; + + case AGPS_STATE_RELEASING: + /* Notify all inactive subscribers about the event */ + notifyAllSubscribers( + AGPS_EVENT_RELEASED, true, + AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS); + + /* If we have active subscribers now, they must be waiting for + * data conn setup */ + if (anyActiveSubscribers()) { + transitionState(AGPS_STATE_PENDING); + requestOrReleaseDataConn(true); + } + /* No active subscribers, move to released state */ + else { + transitionState(AGPS_STATE_RELEASED); + } + break; + + case AGPS_STATE_PENDING: + /* NOOP */ + break; + + default: + LOC_LOGE("Invalid state: %d", mState); + } +} + +void AgpsStateMachine::processAgpsEventDenied(){ + + switch (mState) { + + case AGPS_STATE_RELEASED: + LOC_LOGE("Unexpected event DENIED in state %d", mState); + break; + + case AGPS_STATE_ACQUIRED: + /* NOOP */ + break; + + case AGPS_STATE_RELEASING: + /* Notify all inactive subscribers about the event */ + notifyAllSubscribers( + AGPS_EVENT_RELEASED, true, + AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS); + + /* If we have active subscribers now, they must be waiting for + * data conn setup */ + if (anyActiveSubscribers()) { + transitionState(AGPS_STATE_PENDING); + requestOrReleaseDataConn(true); + } + /* No active subscribers, move to released state */ + else { + transitionState(AGPS_STATE_RELEASED); + } + break; + + case AGPS_STATE_PENDING: + transitionState(AGPS_STATE_RELEASED); + notifyAllSubscribers( + AGPS_EVENT_DENIED, true, + AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS); + break; + + default: + LOC_LOGE("Invalid state: %d", mState); + } +} + +/* Request or Release data connection + * bool request : + * true = Request data connection + * false = Release data connection */ +int AgpsStateMachine::requestOrReleaseDataConn(bool request){ + + AGnssExtStatusIpV4 nifRequest; + memset(&nifRequest, 0, sizeof(nifRequest)); + + nifRequest.type = mAgpsType; + + if (request) { + LOC_LOGD("AGPS Data Conn Request"); + nifRequest.status = LOC_GPS_REQUEST_AGPS_DATA_CONN; + } + else{ + LOC_LOGD("AGPS Data Conn Release"); + nifRequest.status = LOC_GPS_RELEASE_AGPS_DATA_CONN; + } + + mAgpsManager->mFrameworkStatusV4Cb(nifRequest); + return 0; +} + +void AgpsStateMachine::notifyAllSubscribers( + AgpsEvent event, bool deleteSubscriberPostNotify, + AgpsNotificationType notificationType){ + + LOC_LOGD("notifyAllSubscribers(): " + "SM %p, Event %d Delete %d Notification Type %d", + this, event, deleteSubscriberPostNotify, notificationType); + + std::list::const_iterator it = mSubscriberList.begin(); + while ( it != mSubscriberList.end() ) { + + AgpsSubscriber* subscriber = *it; + + if (notificationType == AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS || + (notificationType == AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS && + subscriber->mIsInactive) || + (notificationType == AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS && + !subscriber->mIsInactive)) { + + /* Deleting via this call would require another traversal + * through subscriber list, inefficient; hence pass in false*/ + notifyEventToSubscriber(event, subscriber, false); + + if (deleteSubscriberPostNotify) { + it = mSubscriberList.erase(it); + delete subscriber; + } else { + it++; + } + } else { + it++; + } + } +} + +void AgpsStateMachine::notifyEventToSubscriber( + AgpsEvent event, AgpsSubscriber* subscriberToNotify, + bool deleteSubscriberPostNotify) { + + LOC_LOGD("notifyEventToSubscriber(): " + "SM %p, Event %d Subscriber %p Delete %d", + this, event, subscriberToNotify, deleteSubscriberPostNotify); + + switch (event) { + + case AGPS_EVENT_GRANTED: + mAgpsManager->mAtlOpenStatusCb( + subscriberToNotify->mConnHandle, 1, getAPN(), + getBearer(), mAgpsType); + break; + + case AGPS_EVENT_DENIED: + mAgpsManager->mAtlOpenStatusCb( + subscriberToNotify->mConnHandle, 0, getAPN(), + getBearer(), mAgpsType); + break; + + case AGPS_EVENT_UNSUBSCRIBE: + case AGPS_EVENT_RELEASED: + mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1); + break; + + default: + LOC_LOGE("Invalid event %d", event); + } + + /* Search this subscriber in list and delete */ + if (deleteSubscriberPostNotify) { + deleteSubscriber(subscriberToNotify); + } +} + +void AgpsStateMachine::transitionState(AgpsState newState){ + + LOC_LOGD("transitionState(): SM %p, old %d, new %d", + this, mState, newState); + + mState = newState; + + // notify state transitions to all subscribers ? +} + +void AgpsStateMachine::addSubscriber(AgpsSubscriber* subscriberToAdd){ + + LOC_LOGD("addSubscriber(): SM %p, Subscriber %p", + this, subscriberToAdd); + + // Check if subscriber is already present in the current list + // If not, then add + std::list::const_iterator it = mSubscriberList.begin(); + for (; it != mSubscriberList.end(); it++) { + AgpsSubscriber* subscriber = *it; + if (subscriber->equals(subscriberToAdd)) { + LOC_LOGE("Subscriber already in list"); + return; + } + } + + AgpsSubscriber* cloned = subscriberToAdd->clone(); + LOC_LOGD("addSubscriber(): cloned subscriber: %p", cloned); + mSubscriberList.push_back(cloned); +} + +void AgpsStateMachine::deleteSubscriber(AgpsSubscriber* subscriberToDelete){ + + LOC_LOGD("deleteSubscriber(): SM %p, Subscriber %p", + this, subscriberToDelete); + + std::list::const_iterator it = mSubscriberList.begin(); + while ( it != mSubscriberList.end() ) { + + AgpsSubscriber* subscriber = *it; + if (subscriber && subscriber->equals(subscriberToDelete)) { + + it = mSubscriberList.erase(it); + delete subscriber; + } else { + it++; + } + } +} + +bool AgpsStateMachine::anyActiveSubscribers(){ + + std::list::const_iterator it = mSubscriberList.begin(); + for (; it != mSubscriberList.end(); it++) { + AgpsSubscriber* subscriber = *it; + if (!subscriber->mIsInactive) { + return true; + } + } + return false; +} + +void AgpsStateMachine::setAPN(char* apn, unsigned int len){ + + if (NULL != mAPN) { + delete mAPN; + } + + if (apn == NULL || len <= 0) { + LOC_LOGD("Invalid apn len (%d) or null apn", len); + mAPN = NULL; + mAPNLen = 0; + } + + if (NULL != apn) { + mAPN = new char[len+1]; + if (NULL != mAPN) { + memcpy(mAPN, apn, len); + mAPN[len] = '\0'; + mAPNLen = len; + } + } +} + +AgpsSubscriber* AgpsStateMachine::getSubscriber(int connHandle){ + + /* Go over the subscriber list */ + std::list::const_iterator it = mSubscriberList.begin(); + for (; it != mSubscriberList.end(); it++) { + AgpsSubscriber* subscriber = *it; + if (subscriber->mConnHandle == connHandle) { + return subscriber; + } + } + + /* Not found, return NULL */ + return NULL; +} + +AgpsSubscriber* AgpsStateMachine::getFirstSubscriber(bool isInactive){ + + /* Go over the subscriber list */ + std::list::const_iterator it = mSubscriberList.begin(); + for (; it != mSubscriberList.end(); it++) { + AgpsSubscriber* subscriber = *it; + if(subscriber->mIsInactive == isInactive) { + return subscriber; + } + } + + /* Not found, return NULL */ + return NULL; +} + +void AgpsStateMachine::dropAllSubscribers(){ + + LOC_LOGD("dropAllSubscribers(): SM %p", this); + + /* Go over the subscriber list */ + std::list::const_iterator it = mSubscriberList.begin(); + while ( it != mSubscriberList.end() ) { + AgpsSubscriber* subscriber = *it; + it = mSubscriberList.erase(it); + delete subscriber; + } +} + +/* -------------------------------------------------------------------- + * DS State Machine Methods + * -------------------------------------------------------------------*/ +const int DSStateMachine::MAX_START_DATA_CALL_RETRIES = 4; +const int DSStateMachine::DATA_CALL_RETRY_DELAY_MSEC = 500; + +/* Overridden method + * DS SM needs to handle one scenario differently */ +void DSStateMachine::processAgpsEvent(AgpsEvent event) { + + LOC_LOGD("DSStateMachine::processAgpsEvent() %d", event); + + /* DS Client call setup APIs don't return failure/closure separately. + * Hence we receive RELEASED event in both cases. + * If we are in pending, we should consider RELEASED as DENIED */ + if (event == AGPS_EVENT_RELEASED && mState == AGPS_STATE_PENDING) { + + LOC_LOGD("Translating RELEASED to DENIED event"); + event = AGPS_EVENT_DENIED; + } + + /* Redirect process to base class */ + AgpsStateMachine::processAgpsEvent(event); +} + +/* Timer Callback + * For the retry timer started in case of DS Client call setup failure */ +void delay_callback(void *callbackData, int result) +{ + LOC_LOGD("delay_callback(): cbData %p", callbackData); + + (void)result; + + if (callbackData == NULL) { + LOC_LOGE("delay_callback(): NULL argument received !"); + return; + } + DSStateMachine* dsStateMachine = (DSStateMachine *)callbackData; + dsStateMachine->retryCallback(); +} + +/* Invoked from Timer Callback + * For the retry timer started in case of DS Client call setup failure */ +void DSStateMachine :: retryCallback() +{ + LOC_LOGD("DSStateMachine::retryCallback()"); + + /* Request SUPL ES + * There must be at least one active subscriber in list */ + AgpsSubscriber* subscriber = getFirstSubscriber(false); + if (subscriber == NULL) { + + LOC_LOGE("No active subscriber for DS Client call setup"); + return; + } + + /* Send message to retry */ + mAgpsManager->mSendMsgToAdapterQueueFn( + new AgpsMsgRequestATL( + mAgpsManager, subscriber->mConnHandle, + LOC_AGPS_TYPE_SUPL_ES)); +} + +/* Overridden method + * Request or Release data connection + * bool request : + * true = Request data connection + * false = Release data connection */ +int DSStateMachine::requestOrReleaseDataConn(bool request){ + + LOC_LOGD("DSStateMachine::requestOrReleaseDataConn(): " + "request %d", request); + + /* Release data connection required ? */ + if (!request && mAgpsManager->mDSClientStopDataCallFn) { + + mAgpsManager->mDSClientStopDataCallFn(); + LOC_LOGD("DS Client release data call request sent !"); + return 0; + } + + /* Setup data connection request + * There must be at least one active subscriber in list */ + AgpsSubscriber* subscriber = getFirstSubscriber(false); + if (subscriber == NULL) { + + LOC_LOGE("No active subscriber for DS Client call setup"); + return -1; + } + + /* DS Client Fn registered ? */ + if (!mAgpsManager->mDSClientOpenAndStartDataCallFn) { + + LOC_LOGE("DS Client start fn not registered, fallback to SUPL ATL"); + notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false); + return -1; + } + + /* Setup the call */ + int ret = mAgpsManager->mDSClientOpenAndStartDataCallFn(); + + /* Check if data call start failed */ + switch (ret) { + + case LOC_API_ADAPTER_ERR_ENGINE_BUSY: + LOC_LOGE("DS Client open call failed, err: %d", ret); + mRetries++; + if (mRetries > MAX_START_DATA_CALL_RETRIES) { + + LOC_LOGE("DS Client call retries exhausted, " + "falling back to normal SUPL ATL"); + notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false); + } + /* Retry DS Client call setup after some delay */ + else if(loc_timer_start( + DATA_CALL_RETRY_DELAY_MSEC, delay_callback, this)) { + LOC_LOGE("Error: Could not start delay thread\n"); + return -1; + } + break; + + case LOC_API_ADAPTER_ERR_UNSUPPORTED: + LOC_LOGE("No emergency profile found. Fall back to normal SUPL ATL"); + notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false); + break; + + case LOC_API_ADAPTER_ERR_SUCCESS: + LOC_LOGD("Request to start data call sent"); + break; + + default: + LOC_LOGE("Unrecognized return value: %d", ret); + } + + return ret; +} + +void DSStateMachine::notifyEventToSubscriber( + AgpsEvent event, AgpsSubscriber* subscriberToNotify, + bool deleteSubscriberPostNotify) { + + LOC_LOGD("DSStateMachine::notifyEventToSubscriber(): " + "SM %p, Event %d Subscriber %p Delete %d", + this, event, subscriberToNotify, deleteSubscriberPostNotify); + + switch (event) { + + case AGPS_EVENT_GRANTED: + mAgpsManager->mAtlOpenStatusCb( + subscriberToNotify->mConnHandle, 1, NULL, + AGPS_APN_BEARER_INVALID, LOC_AGPS_TYPE_SUPL_ES); + break; + + case AGPS_EVENT_DENIED: + /* Now try with regular SUPL + * We need to send request via message queue */ + mRetries = 0; + mAgpsManager->mSendMsgToAdapterQueueFn( + new AgpsMsgRequestATL( + mAgpsManager, subscriberToNotify->mConnHandle, + LOC_AGPS_TYPE_SUPL)); + break; + + case AGPS_EVENT_UNSUBSCRIBE: + mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1); + break; + + case AGPS_EVENT_RELEASED: + mAgpsManager->mDSClientCloseDataCallFn(); + mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1); + break; + + default: + LOC_LOGE("Invalid event %d", event); + } + + /* Search this subscriber in list and delete */ + if (deleteSubscriberPostNotify) { + deleteSubscriber(subscriberToNotify); + } +} + +/* -------------------------------------------------------------------- + * Loc AGPS Manager Methods + * -------------------------------------------------------------------*/ + +/* CREATE AGPS STATE MACHINES + * Must be invoked in Msg Handler context */ +void AgpsManager::createAgpsStateMachines() { + + LOC_LOGD("AgpsManager::createAgpsStateMachines"); + + bool agpsCapable = + ((loc_core::ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSA) || + (loc_core::ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSB)); + + if (NULL == mInternetNif) { + mInternetNif = new AgpsStateMachine(this, LOC_AGPS_TYPE_WWAN_ANY); + LOC_LOGD("Internet NIF: %p", mInternetNif); + } + if (agpsCapable) { + if (NULL == mAgnssNif) { + mAgnssNif = new AgpsStateMachine(this, LOC_AGPS_TYPE_SUPL); + LOC_LOGD("AGNSS NIF: %p", mAgnssNif); + } + if (NULL == mDsNif && + loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { + + if(!mDSClientInitFn){ + + LOC_LOGE("DS Client Init Fn not registered !"); + return; + } + if (mDSClientInitFn(false) != 0) { + + LOC_LOGE("Failed to init data service client"); + return; + } + mDsNif = new DSStateMachine(this); + LOC_LOGD("DS NIF: %p", mDsNif); + } + } +} + +AgpsStateMachine* AgpsManager::getAgpsStateMachine(AGpsExtType agpsType) { + + LOC_LOGD("AgpsManager::getAgpsStateMachine(): agpsType %d", agpsType); + + switch (agpsType) { + + case LOC_AGPS_TYPE_INVALID: + case LOC_AGPS_TYPE_SUPL: + if (mAgnssNif == NULL) { + LOC_LOGE("NULL AGNSS NIF !"); + } + return mAgnssNif; + + case LOC_AGPS_TYPE_SUPL_ES: + if (loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { + if (mDsNif == NULL) { + createAgpsStateMachines(); + } + return mDsNif; + } else { + return mAgnssNif; + } + + default: + return mInternetNif; + } + + LOC_LOGE("No SM found !"); + return NULL; +} + +void AgpsManager::requestATL(int connHandle, AGpsExtType agpsType){ + + LOC_LOGD("AgpsManager::requestATL(): connHandle %d, agpsType %d", + connHandle, agpsType); + + AgpsStateMachine* sm = getAgpsStateMachine(agpsType); + + if (sm == NULL) { + + LOC_LOGE("No AGPS State Machine for agpsType: %d", agpsType); + mAtlOpenStatusCb( + connHandle, 0, NULL, AGPS_APN_BEARER_INVALID, agpsType); + return; + } + + /* Invoke AGPS SM processing */ + AgpsSubscriber subscriber(connHandle, false, false); + sm->setCurrentSubscriber(&subscriber); + + /* If DS State Machine, wait for close complete */ + if (agpsType == LOC_AGPS_TYPE_SUPL_ES) { + subscriber.mWaitForCloseComplete = true; + } + + /* Send subscriber event */ + sm->processAgpsEvent(AGPS_EVENT_SUBSCRIBE); +} + +void AgpsManager::releaseATL(int connHandle){ + + LOC_LOGD("AgpsManager::releaseATL(): connHandle %d", connHandle); + + /* First find the subscriber with specified handle. + * We need to search in all state machines. */ + AgpsStateMachine* sm = NULL; + AgpsSubscriber* subscriber = NULL; + + if (mAgnssNif && + (subscriber = mAgnssNif->getSubscriber(connHandle)) != NULL) { + sm = mAgnssNif; + } + else if (mInternetNif && + (subscriber = mInternetNif->getSubscriber(connHandle)) != NULL) { + sm = mInternetNif; + } + else if (mDsNif && + (subscriber = mDsNif->getSubscriber(connHandle)) != NULL) { + sm = mDsNif; + } + + if (sm == NULL) { + LOC_LOGE("Subscriber with connHandle %d not found in any SM", + connHandle); + mAtlCloseStatusCb(connHandle, 0); + return; + } + + /* Now send unsubscribe event */ + sm->setCurrentSubscriber(subscriber); + sm->processAgpsEvent(AGPS_EVENT_UNSUBSCRIBE); +} + +void AgpsManager::reportDataCallOpened(){ + + LOC_LOGD("AgpsManager::reportDataCallOpened"); + + if (mDsNif) { + mDsNif->processAgpsEvent(AGPS_EVENT_GRANTED); + } +} + +void AgpsManager::reportDataCallClosed(){ + + LOC_LOGD("AgpsManager::reportDataCallClosed"); + + if (mDsNif) { + mDsNif->processAgpsEvent(AGPS_EVENT_RELEASED); + } +} + +void AgpsManager::reportAtlOpenSuccess( + AGpsExtType agpsType, char* apnName, int apnLen, + AGpsBearerType bearerType){ + + LOC_LOGD("AgpsManager::reportAtlOpenSuccess(): " + "AgpsType %d, APN [%s], Len %d, BearerType %d", + agpsType, apnName, apnLen, bearerType); + + /* Find the state machine instance */ + AgpsStateMachine* sm = getAgpsStateMachine(agpsType); + + /* Set bearer and apn info in state machine instance */ + sm->setBearer(bearerType); + sm->setAPN(apnName, apnLen); + + /* Send GRANTED event to state machine */ + sm->processAgpsEvent(AGPS_EVENT_GRANTED); +} + +void AgpsManager::reportAtlOpenFailed(AGpsExtType agpsType){ + + LOC_LOGD("AgpsManager::reportAtlOpenFailed(): AgpsType %d", agpsType); + + /* Fetch SM and send DENIED event */ + AgpsStateMachine* sm = getAgpsStateMachine(agpsType); + sm->processAgpsEvent(AGPS_EVENT_DENIED); +} + +void AgpsManager::reportAtlClosed(AGpsExtType agpsType){ + + LOC_LOGD("AgpsManager::reportAtlClosed(): AgpsType %d", agpsType); + + /* Fetch SM and send RELEASED event */ + AgpsStateMachine* sm = getAgpsStateMachine(agpsType); + sm->processAgpsEvent(AGPS_EVENT_RELEASED); +} + +void AgpsManager::handleModemSSR(){ + + LOC_LOGD("AgpsManager::handleModemSSR"); + + /* Drop subscribers from all state machines */ + if (mAgnssNif) { + mAgnssNif->dropAllSubscribers(); + } + if (mInternetNif) { + mInternetNif->dropAllSubscribers(); + } + if (mDsNif) { + mDsNif->dropAllSubscribers(); + } + + // reinitialize DS client in SSR mode + if (loc_core::ContextBase::mGps_conf. + USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { + + mDSClientStopDataCallFn(); + mDSClientCloseDataCallFn(); + mDSClientReleaseFn(); + + mDSClientInitFn(true); + } +} diff --git a/gps/gnss/Agps.h b/gps/gnss/Agps.h new file mode 100644 index 0000000..2f89c8c --- /dev/null +++ b/gps/gnss/Agps.h @@ -0,0 +1,383 @@ +/* Copyright (c) 2012-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 AGPS_H +#define AGPS_H + +#include +#include +#include +#include +#include + +/* ATL callback function pointers + * Passed in by Adapter to AgpsManager */ +typedef std::function AgpsAtlOpenStatusCb; + +typedef std::function AgpsAtlCloseStatusCb; + +/* DS Client control APIs + * Passed in by Adapter to AgpsManager */ +typedef std::function AgpsDSClientInitFn; +typedef std::function AgpsDSClientOpenAndStartDataCallFn; +typedef std::function AgpsDSClientStopDataCallFn; +typedef std::function AgpsDSClientCloseDataCallFn; +typedef std::function AgpsDSClientReleaseFn; + +/* Post message to adapter's message queue */ +typedef std::function SendMsgToAdapterMsgQueueFn; + +/* AGPS States */ +typedef enum { + AGPS_STATE_INVALID = 0, + AGPS_STATE_RELEASED, + AGPS_STATE_PENDING, + AGPS_STATE_ACQUIRED, + AGPS_STATE_RELEASING +} AgpsState; + +typedef enum { + AGPS_EVENT_INVALID = 0, + AGPS_EVENT_SUBSCRIBE, + AGPS_EVENT_UNSUBSCRIBE, + AGPS_EVENT_GRANTED, + AGPS_EVENT_RELEASED, + AGPS_EVENT_DENIED +} AgpsEvent; + +/* Notification Types sent to subscribers */ +typedef enum { + AGPS_NOTIFICATION_TYPE_INVALID = 0, + + /* Meant for all subscribers, either active or inactive */ + AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS, + + /* Meant for only inactive subscribers */ + AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS, + + /* Meant for only active subscribers */ + AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS +} AgpsNotificationType; + +/* Classes in this header */ +class AgpsSubscriber; +class AgpsManager; +class AgpsStateMachine; +class DSStateMachine; + + +/* SUBSCRIBER + * Each Subscriber instance corresponds to one AGPS request, + * received by the AGPS state machine */ +class AgpsSubscriber { + +public: + int mConnHandle; + + /* Does this subscriber wait for data call close complete, + * before being notified ATL close ? + * While waiting for data call close, subscriber will be in + * inactive state. */ + bool mWaitForCloseComplete; + bool mIsInactive; + + inline AgpsSubscriber( + int connHandle, bool waitForCloseComplete, bool isInactive) : + mConnHandle(connHandle), + mWaitForCloseComplete(waitForCloseComplete), + mIsInactive(isInactive) {} + inline virtual ~AgpsSubscriber() {} + + inline virtual bool equals(const AgpsSubscriber *s) const + { return (mConnHandle == s->mConnHandle); } + + inline virtual AgpsSubscriber* clone() + { return new AgpsSubscriber( + mConnHandle, mWaitForCloseComplete, mIsInactive); } +}; + +/* AGPS STATE MACHINE */ +class AgpsStateMachine { +protected: + /* AGPS Manager instance, from where this state machine is created */ + AgpsManager* mAgpsManager; + + /* List of all subscribers for this State Machine. + * Once a subscriber is notified for ATL open/close status, + * it is deleted */ + std::list mSubscriberList; + + /* Current subscriber, whose request this State Machine is + * currently processing */ + AgpsSubscriber* mCurrentSubscriber; + + /* Current state for this state machine */ + AgpsState mState; + +private: + /* AGPS Type for this state machine + LOC_AGPS_TYPE_ANY 0 + LOC_AGPS_TYPE_SUPL 1 + LOC_AGPS_TYPE_WWAN_ANY 3 + LOC_AGPS_TYPE_SUPL_ES 5 */ + AGpsExtType mAgpsType; + + /* APN and IP Type info for AGPS Call */ + char* mAPN; + unsigned int mAPNLen; + AGpsBearerType mBearer; + +public: + /* CONSTRUCTOR */ + AgpsStateMachine(AgpsManager* agpsManager, AGpsExtType agpsType): + mAgpsManager(agpsManager), mSubscriberList(), + mCurrentSubscriber(NULL), mState(AGPS_STATE_RELEASED), + mAgpsType(agpsType), mAPN(NULL), mAPNLen(0), + mBearer(AGPS_APN_BEARER_INVALID) {}; + + virtual ~AgpsStateMachine() { if(NULL != mAPN) delete[] mAPN; }; + + /* Getter/Setter methods */ + void setAPN(char* apn, unsigned int len); + inline char* getAPN() const { return (char*)mAPN; } + inline void setBearer(AGpsBearerType bearer) { mBearer = bearer; } + inline AGpsBearerType getBearer() const { return mBearer; } + inline AGpsExtType getType() const { return mAgpsType; } + inline void setCurrentSubscriber(AgpsSubscriber* subscriber) + { mCurrentSubscriber = subscriber; } + + /* Fetch subscriber with specified handle */ + AgpsSubscriber* getSubscriber(int connHandle); + + /* Fetch first active or inactive subscriber in list + * isInactive = true : fetch first inactive subscriber + * isInactive = false : fetch first active subscriber */ + AgpsSubscriber* getFirstSubscriber(bool isInactive); + + /* Process LOC AGPS Event being passed in + * onRsrcEvent */ + virtual void processAgpsEvent(AgpsEvent event); + + /* Drop all subscribers, in case of Modem SSR */ + void dropAllSubscribers(); + +protected: + /* Remove the specified subscriber from list if present. + * Also delete the subscriber instance. */ + void deleteSubscriber(AgpsSubscriber* subscriber); + +private: + /* Send call setup request to framework + * sendRsrcRequest(LOC_GPS_REQUEST_AGPS_DATA_CONN) + * sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN) */ + virtual int requestOrReleaseDataConn(bool request); + + /* Individual event processing methods */ + void processAgpsEventSubscribe(); + void processAgpsEventUnsubscribe(); + void processAgpsEventGranted(); + void processAgpsEventReleased(); + void processAgpsEventDenied(); + + /* Clone the passed in subscriber and add to the subscriber list + * if not already present */ + void addSubscriber(AgpsSubscriber* subscriber); + + /* Notify subscribers about AGPS events */ + void notifyAllSubscribers( + AgpsEvent event, bool deleteSubscriberPostNotify, + AgpsNotificationType notificationType); + virtual void notifyEventToSubscriber( + AgpsEvent event, AgpsSubscriber* subscriber, + bool deleteSubscriberPostNotify); + + /* Do we have any subscribers in active state */ + bool anyActiveSubscribers(); + + /* Transition state */ + void transitionState(AgpsState newState); +}; + +/* DS STATE MACHINE */ +class DSStateMachine : public AgpsStateMachine { + +private: + static const int MAX_START_DATA_CALL_RETRIES; + static const int DATA_CALL_RETRY_DELAY_MSEC; + + int mRetries; + +public: + /* CONSTRUCTOR */ + DSStateMachine(AgpsManager* agpsManager): + AgpsStateMachine(agpsManager, LOC_AGPS_TYPE_SUPL_ES), mRetries(0) {} + + /* Overridden method + * DS SM needs to handle one event differently */ + void processAgpsEvent(AgpsEvent event); + + /* Retry callback, used in case call failure */ + void retryCallback(); + +private: + /* Overridden method, different functionality for DS SM + * Send call setup request to framework + * sendRsrcRequest(LOC_GPS_REQUEST_AGPS_DATA_CONN) + * sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN) */ + int requestOrReleaseDataConn(bool request); + + /* Overridden method, different functionality for DS SM */ + void notifyEventToSubscriber( + AgpsEvent event, AgpsSubscriber* subscriber, + bool deleteSubscriberPostNotify); +}; + +/* LOC AGPS MANAGER */ +class AgpsManager { + + friend class AgpsStateMachine; + friend class DSStateMachine; + +public: + /* CONSTRUCTOR */ + AgpsManager(): + mFrameworkStatusV4Cb(NULL), + mAtlOpenStatusCb(), mAtlCloseStatusCb(), + mDSClientInitFn(), mDSClientOpenAndStartDataCallFn(), + mDSClientStopDataCallFn(), mDSClientCloseDataCallFn(), mDSClientReleaseFn(), + mSendMsgToAdapterQueueFn(), + mAgnssNif(NULL), mInternetNif(NULL), mDsNif(NULL) {} + + /* Register callbacks */ + void registerCallbacks( + AgnssStatusIpV4Cb frameworkStatusV4Cb, + + AgpsAtlOpenStatusCb atlOpenStatusCb, + AgpsAtlCloseStatusCb atlCloseStatusCb, + + AgpsDSClientInitFn dsClientInitFn, + AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn, + AgpsDSClientStopDataCallFn dsClientStopDataCallFn, + AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn, + AgpsDSClientReleaseFn dsClientReleaseFn, + + SendMsgToAdapterMsgQueueFn sendMsgToAdapterQueueFn ){ + + mFrameworkStatusV4Cb = frameworkStatusV4Cb; + + mAtlOpenStatusCb = atlOpenStatusCb; + mAtlCloseStatusCb = atlCloseStatusCb; + + mDSClientInitFn = dsClientInitFn; + mDSClientOpenAndStartDataCallFn = dsClientOpenAndStartDataCallFn; + mDSClientStopDataCallFn = dsClientStopDataCallFn; + mDSClientCloseDataCallFn = dsClientCloseDataCallFn; + mDSClientReleaseFn = dsClientReleaseFn; + + mSendMsgToAdapterQueueFn = sendMsgToAdapterQueueFn; + } + + /* Create all AGPS state machines */ + void createAgpsStateMachines(); + + /* Process incoming ATL requests */ + void requestATL(int connHandle, AGpsExtType agpsType); + void releaseATL(int connHandle); + + /* Process incoming DS Client data call events */ + void reportDataCallOpened(); + void reportDataCallClosed(); + + /* Process incoming framework data call events */ + void reportAtlOpenSuccess(AGpsExtType agpsType, char* apnName, int apnLen, + AGpsBearerType bearerType); + void reportAtlOpenFailed(AGpsExtType agpsType); + void reportAtlClosed(AGpsExtType agpsType); + + /* Handle Modem SSR */ + void handleModemSSR(); + +protected: + AgnssStatusIpV4Cb mFrameworkStatusV4Cb; + + AgpsAtlOpenStatusCb mAtlOpenStatusCb; + AgpsAtlCloseStatusCb mAtlCloseStatusCb; + + AgpsDSClientInitFn mDSClientInitFn; + AgpsDSClientOpenAndStartDataCallFn mDSClientOpenAndStartDataCallFn; + AgpsDSClientStopDataCallFn mDSClientStopDataCallFn; + AgpsDSClientCloseDataCallFn mDSClientCloseDataCallFn; + AgpsDSClientReleaseFn mDSClientReleaseFn; + + SendMsgToAdapterMsgQueueFn mSendMsgToAdapterQueueFn; + + AgpsStateMachine* mAgnssNif; + AgpsStateMachine* mInternetNif; + AgpsStateMachine* mDsNif; + +private: + /* Fetch state machine for handling request ATL call */ + AgpsStateMachine* getAgpsStateMachine(AGpsExtType agpsType); +}; + +/* Request SUPL/INTERNET/SUPL_ES ATL + * This LocMsg is defined in this header since it has to be used from more + * than one place, other Agps LocMsg are restricted to GnssAdapter and + * declared inline */ +struct AgpsMsgRequestATL: public LocMsg { + + AgpsManager* mAgpsManager; + int mConnHandle; + AGpsExtType mAgpsType; + + inline AgpsMsgRequestATL(AgpsManager* agpsManager, int connHandle, + AGpsExtType agpsType) : + LocMsg(), mAgpsManager(agpsManager), mConnHandle(connHandle), mAgpsType( + agpsType) { + + LOC_LOGV("AgpsMsgRequestATL"); + } + + inline virtual void proc() const { + + LOC_LOGV("AgpsMsgRequestATL::proc()"); + mAgpsManager->requestATL(mConnHandle, mAgpsType); + } +}; + +namespace AgpsUtils { + +AGpsBearerType ipTypeToBearerType(LocApnIpType ipType); +LocApnIpType bearerTypeToIpType(AGpsBearerType bearerType); + +} + +#endif /* AGPS_H */ diff --git a/gps/gnss/Android.mk b/gps/gnss/Android.mk new file mode 100644 index 0000000..4d738bd --- /dev/null +++ b/gps/gnss/Android.mk @@ -0,0 +1,47 @@ +ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) +ifneq ($(BUILD_TINY_ANDROID),true) + +LOCAL_PATH := $(call my-dir) + +include $(CLEAR_VARS) + +LOCAL_MODULE := libgnss +LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib +LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64 +LOCAL_MODULE_TAGS := optional + +LOCAL_SHARED_LIBRARIES := \ + libutils \ + libcutils \ + libdl \ + liblog \ + libloc_core \ + libgps.utils + +LOCAL_SRC_FILES += \ + location_gnss.cpp \ + GnssAdapter.cpp \ + Agps.cpp \ + XtraSystemStatusObserver.cpp + +LOCAL_CFLAGS += \ + -fno-short-enums \ + +ifeq ($(TARGET_BUILD_VARIANT),user) + LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER +endif + +LOCAL_HEADER_LIBRARIES := \ + libgps.utils_headers \ + libloc_core_headers \ + libloc_pla_headers \ + liblocation_api_headers + +LOCAL_CFLAGS += $(GNSS_CFLAGS) + +LOCAL_PRELINK_MODULE := false + +include $(BUILD_SHARED_LIBRARY) + +endif # not BUILD_TINY_ANDROID +endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE diff --git a/gps/gnss/GnssAdapter.cpp b/gps/gnss/GnssAdapter.cpp new file mode 100644 index 0000000..cdda01d --- /dev/null +++ b/gps/gnss/GnssAdapter.cpp @@ -0,0 +1,3131 @@ +/* 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_GnssAdapter" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define RAD2DEG (180.0 / M_PI) + +using namespace loc_core; + +/* Method to fetch status cb from loc_net_iface library */ +typedef AgpsCbInfo& (*LocAgpsGetAgpsCbInfo)(LocAgpsOpenResultCb openResultCb, + LocAgpsCloseResultCb closeResultCb, void* userDataPtr); + +static void agpsOpenResultCb (bool isSuccess, AGpsExtType agpsType, const char* apn, + AGpsBearerType bearerType, void* userDataPtr); +static void agpsCloseResultCb (bool isSuccess, AGpsExtType agpsType, void* userDataPtr); + +GnssAdapter::GnssAdapter() : + LocAdapterBase(0, + LocDualContext::getLocFgContext(NULL, + NULL, + LocDualContext::mLocationHalName, + false)), + mUlpProxy(new UlpProxyBase()), + mUlpPositionMode(), + mGnssSvIdUsedInPosition(), + mGnssSvIdUsedInPosAvail(false), + mControlCallbacks(), + mPowerVoteId(0), + mNmeaMask(0), + mNiData(), + mAgpsManager(), + mAgpsCbInfo(), + mSystemStatus(SystemStatus::getInstance(mMsgTask)), + mServerUrl(""), + mXtraObserver(mSystemStatus->getOsObserver(), mMsgTask) +{ + LOC_LOGD("%s]: Constructor %p", __func__, this); + mUlpPositionMode.mode = LOC_POSITION_MODE_INVALID; + readConfigCommand(); + setConfigCommand(); + initDefaultAgpsCommand(); +} + +void +GnssAdapter::setControlCallbacksCommand(LocationControlCallbacks& controlCallbacks) +{ + struct MsgSetControlCallbacks : public LocMsg { + GnssAdapter& mAdapter; + const LocationControlCallbacks mControlCallbacks; + inline MsgSetControlCallbacks(GnssAdapter& adapter, + LocationControlCallbacks& controlCallbacks) : + LocMsg(), + mAdapter(adapter), + mControlCallbacks(controlCallbacks) {} + inline virtual void proc() const { + mAdapter.setControlCallbacks(mControlCallbacks); + } + }; + + sendMsg(new MsgSetControlCallbacks(*this, controlCallbacks)); +} + +void +GnssAdapter::convertOptions(LocPosMode& out, const LocationOptions& options) +{ + LocPosMode locPosMode = {}; + switch (options.mode) { + case GNSS_SUPL_MODE_MSB: + out.mode = LOC_POSITION_MODE_MS_BASED; + break; + case GNSS_SUPL_MODE_MSA: + out.mode = LOC_POSITION_MODE_MS_ASSISTED; + break; + default: + out.mode = LOC_POSITION_MODE_STANDALONE; + break; + } + out.share_position = true; + out.min_interval = options.minInterval; +} + +void +GnssAdapter::convertLocation(Location& out, const LocGpsLocation& locGpsLocation, + const GpsLocationExtended& locationExtended, + const LocPosTechMask techMask) +{ + memset(&out, 0, sizeof(Location)); + out.size = sizeof(Location); + if (LOC_GPS_LOCATION_HAS_LAT_LONG & locGpsLocation.flags) { + out.flags |= LOCATION_HAS_LAT_LONG_BIT; + out.latitude = locGpsLocation.latitude; + out.longitude = locGpsLocation.longitude; + } + if (LOC_GPS_LOCATION_HAS_ALTITUDE & locGpsLocation.flags) { + out.flags |= LOCATION_HAS_ALTITUDE_BIT; + out.altitude = locGpsLocation.altitude; + } + if (LOC_GPS_LOCATION_HAS_SPEED & locGpsLocation.flags) { + out.flags |= LOCATION_HAS_SPEED_BIT; + out.speed = locGpsLocation.speed; + } + if (LOC_GPS_LOCATION_HAS_BEARING & locGpsLocation.flags) { + out.flags |= LOCATION_HAS_BEARING_BIT; + out.bearing = locGpsLocation.bearing; + } + if (LOC_GPS_LOCATION_HAS_ACCURACY & locGpsLocation.flags) { + out.flags |= LOCATION_HAS_ACCURACY_BIT; + out.accuracy = locGpsLocation.accuracy; + } + if (GPS_LOCATION_EXTENDED_HAS_VERT_UNC & locationExtended.flags) { + out.flags |= LOCATION_HAS_VERTICAL_ACCURACY_BIT; + out.verticalAccuracy = locationExtended.vert_unc; + } + if (GPS_LOCATION_EXTENDED_HAS_SPEED_UNC & locationExtended.flags) { + out.flags |= LOCATION_HAS_SPEED_ACCURACY_BIT; + out.speedAccuracy = locationExtended.speed_unc; + } + if (GPS_LOCATION_EXTENDED_HAS_BEARING_UNC & locationExtended.flags) { + out.flags |= LOCATION_HAS_BEARING_ACCURACY_BIT; + out.bearingAccuracy = locationExtended.bearing_unc; + } + out.timestamp = locGpsLocation.timestamp; + if (LOC_POS_TECH_MASK_SATELLITE & techMask) { + out.techMask |= LOCATION_TECHNOLOGY_GNSS_BIT; + } + if (LOC_POS_TECH_MASK_CELLID & techMask) { + out.techMask |= LOCATION_TECHNOLOGY_CELL_BIT; + } + if (LOC_POS_TECH_MASK_WIFI & techMask) { + out.techMask |= LOCATION_TECHNOLOGY_WIFI_BIT; + } + if (LOC_POS_TECH_MASK_SENSORS & techMask) { + out.techMask |= LOCATION_TECHNOLOGY_SENSORS_BIT; + } +} + +void +GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out, + const GpsLocationExtended& locationExtended) +{ + out.size = sizeof(GnssLocationInfoNotification); + if (GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT; + out.altitudeMeanSeaLevel = locationExtended.altitudeMeanSeaLevel; + } + if (GPS_LOCATION_EXTENDED_HAS_DOP & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_DOP_BIT; + out.pdop = locationExtended.pdop; + out.hdop = locationExtended.hdop; + out.vdop = locationExtended.vdop; + } + if (GPS_LOCATION_EXTENDED_HAS_MAG_DEV & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT; + out.magneticDeviation = locationExtended.magneticDeviation; + } + if (GPS_LOCATION_EXTENDED_HAS_HOR_RELIABILITY & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_HOR_RELIABILITY_BIT; + switch (locationExtended.horizontal_reliability) { + case LOC_RELIABILITY_VERY_LOW: + out.horReliability = LOCATION_RELIABILITY_VERY_LOW; + break; + case LOC_RELIABILITY_LOW: + out.horReliability = LOCATION_RELIABILITY_LOW; + break; + case LOC_RELIABILITY_MEDIUM: + out.horReliability = LOCATION_RELIABILITY_MEDIUM; + break; + case LOC_RELIABILITY_HIGH: + out.horReliability = LOCATION_RELIABILITY_HIGH; + break; + default: + out.horReliability = LOCATION_RELIABILITY_NOT_SET; + break; + } + } + if (GPS_LOCATION_EXTENDED_HAS_VERT_RELIABILITY & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_VER_RELIABILITY_BIT; + switch (locationExtended.vertical_reliability) { + case LOC_RELIABILITY_VERY_LOW: + out.verReliability = LOCATION_RELIABILITY_VERY_LOW; + break; + case LOC_RELIABILITY_LOW: + out.verReliability = LOCATION_RELIABILITY_LOW; + break; + case LOC_RELIABILITY_MEDIUM: + out.verReliability = LOCATION_RELIABILITY_MEDIUM; + break; + case LOC_RELIABILITY_HIGH: + out.verReliability = LOCATION_RELIABILITY_HIGH; + break; + default: + out.verReliability = LOCATION_RELIABILITY_NOT_SET; + break; + } + } + if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MAJOR & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MAJOR_BIT; + out.horUncEllipseSemiMajor = locationExtended.horUncEllipseSemiMajor; + } + if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MINOR & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MINOR_BIT; + out.horUncEllipseSemiMinor = locationExtended.horUncEllipseSemiMinor; + } + if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_AZIMUTH & locationExtended.flags) { + out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT; + out.horUncEllipseOrientAzimuth = locationExtended.horUncEllipseOrientAzimuth; + } +} + +inline uint32_t +GnssAdapter::convertGpsLock(const GnssConfigGpsLock gpsLock) +{ + switch (gpsLock) { + case GNSS_CONFIG_GPS_LOCK_MO: + return 1; + case GNSS_CONFIG_GPS_LOCK_NI: + return 2; + case GNSS_CONFIG_GPS_LOCK_MO_AND_NI: + return 3; + case GNSS_CONFIG_GPS_LOCK_NONE: + default: + return 0; + } +} + +inline GnssConfigGpsLock +GnssAdapter::convertGpsLock(const uint32_t gpsLock) +{ + switch (gpsLock) { + case 1: + return GNSS_CONFIG_GPS_LOCK_MO; + case 2: + return GNSS_CONFIG_GPS_LOCK_NI; + case 3: + return GNSS_CONFIG_GPS_LOCK_MO_AND_NI; + case 0: + default: + return GNSS_CONFIG_GPS_LOCK_NONE; + } +} + +inline uint32_t +GnssAdapter::convertSuplVersion(const GnssConfigSuplVersion suplVersion) +{ + switch (suplVersion) { + case GNSS_CONFIG_SUPL_VERSION_2_0_0: + return 0x00020000; + case GNSS_CONFIG_SUPL_VERSION_2_0_2: + return 0x00020002; + case GNSS_CONFIG_SUPL_VERSION_1_0_0: + default: + return 0x00010000; + } +} + +inline GnssConfigSuplVersion +GnssAdapter::convertSuplVersion(const uint32_t suplVersion) +{ + switch (suplVersion) { + case 0x00020000: + return GNSS_CONFIG_SUPL_VERSION_2_0_0; + case 0x00020002: + return GNSS_CONFIG_SUPL_VERSION_2_0_2; + case 0x00010000: + default: + return GNSS_CONFIG_SUPL_VERSION_1_0_0; + } +} + +inline uint32_t +GnssAdapter::convertLppProfile(const GnssConfigLppProfile lppProfile) +{ + switch (lppProfile) { + case GNSS_CONFIG_LPP_PROFILE_USER_PLANE: + return 1; + case GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE: + return 2; + case GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE: + return 3; + case GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE: + default: + return 0; + } +} + +inline GnssConfigLppProfile +GnssAdapter::convertLppProfile(const uint32_t lppProfile) +{ + switch (lppProfile) { + case 1: + return GNSS_CONFIG_LPP_PROFILE_USER_PLANE; + case 2: + return GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE; + case 3: + return GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE; + case 0: + default: + return GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE; + } +} + +uint32_t +GnssAdapter::convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlaneMask) +{ + uint32_t mask = 0; + if (GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT & lppeControlPlaneMask) { + mask |= (1<<0); + } + if (GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT & lppeControlPlaneMask) { + mask |= (1<<1); + } + if (GNSS_CONFIG_LPPE_CONTROL_PLANE_SRN_AP_MEASUREMENTS_BIT & lppeControlPlaneMask) { + mask |= (1<<2); + } + if (GNSS_CONFIG_LPPE_CONTROL_PLANE_SENSOR_BARO_MEASUREMENTS_BIT & lppeControlPlaneMask) { + mask |= (1<<3); + } + return mask; +} + +GnssConfigLppeControlPlaneMask +GnssAdapter::convertLppeCp(const uint32_t lppeControlPlaneMask) +{ + GnssConfigLppeControlPlaneMask mask = 0; + if ((1<<0) & lppeControlPlaneMask) { + mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT; + } + if ((1<<1) & lppeControlPlaneMask) { + mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT; + } + if ((1<<2) & lppeControlPlaneMask) { + mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_SRN_AP_MEASUREMENTS_BIT; + } + if ((1<<3) & lppeControlPlaneMask) { + mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_SENSOR_BARO_MEASUREMENTS_BIT; + } + return mask; +} + + +uint32_t +GnssAdapter::convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask) +{ + uint32_t mask = 0; + if (GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT & lppeUserPlaneMask) { + mask |= (1<<0); + } + if (GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT & lppeUserPlaneMask) { + mask |= (1<<1); + } + if (GNSS_CONFIG_LPPE_USER_PLANE_SRN_AP_MEASUREMENTS_BIT & lppeUserPlaneMask) { + mask |= (1<<2); + } + if (GNSS_CONFIG_LPPE_USER_PLANE_SENSOR_BARO_MEASUREMENTS_BIT & lppeUserPlaneMask) { + mask |= (1<<3); + } + return mask; +} + +GnssConfigLppeUserPlaneMask +GnssAdapter::convertLppeUp(const uint32_t lppeUserPlaneMask) +{ + GnssConfigLppeUserPlaneMask mask = 0; + if ((1<<0) & lppeUserPlaneMask) { + mask |= GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT; + } + if ((1<<1) & lppeUserPlaneMask) { + mask |= GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT; + } + if ((1<<2) & lppeUserPlaneMask) { + mask |= GNSS_CONFIG_LPPE_USER_PLANE_SRN_AP_MEASUREMENTS_BIT; + } + if ((1<<3) & lppeUserPlaneMask) { + mask |= GNSS_CONFIG_LPPE_USER_PLANE_SENSOR_BARO_MEASUREMENTS_BIT; + } + return mask; +} + +uint32_t +GnssAdapter::convertAGloProt(const GnssConfigAGlonassPositionProtocolMask aGloPositionProtocolMask) +{ + uint32_t mask = 0; + if (GNSS_CONFIG_RRC_CONTROL_PLANE_BIT & aGloPositionProtocolMask) { + mask |= (1<<0); + } + if (GNSS_CONFIG_RRLP_USER_PLANE_BIT & aGloPositionProtocolMask) { + mask |= (1<<1); + } + if (GNSS_CONFIG_LLP_USER_PLANE_BIT & aGloPositionProtocolMask) { + mask |= (1<<2); + } + if (GNSS_CONFIG_LLP_CONTROL_PLANE_BIT & aGloPositionProtocolMask) { + mask |= (1<<3); + } + return mask; +} + +uint32_t +GnssAdapter::convertEP4ES(const GnssConfigEmergencyPdnForEmergencySupl emergencyPdnForEmergencySupl) +{ + switch (emergencyPdnForEmergencySupl) { + case GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES: + return 1; + case GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO: + default: + return 0; + } +} + +uint32_t +GnssAdapter::convertSuplEs(const GnssConfigSuplEmergencyServices suplEmergencyServices) +{ + switch (suplEmergencyServices) { + case GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES: + return 1; + case GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO: + default: + return 0; + } +} + +uint32_t +GnssAdapter::convertSuplMode(const GnssConfigSuplModeMask suplModeMask) +{ + uint32_t mask = 0; + if (GNSS_CONFIG_SUPL_MODE_MSB_BIT & suplModeMask) { + mask |= (1<<0); + } + if (GNSS_CONFIG_SUPL_MODE_MSA_BIT & suplModeMask) { + mask |= (1<<1); + } + return mask; +} + +bool +GnssAdapter::resolveInAddress(const char* hostAddress, struct in_addr* inAddress) +{ + bool ret = true; + + struct hostent* hp; + hp = gethostbyname(hostAddress); + if (hp != NULL) { /* DNS OK */ + memcpy(inAddress, hp->h_addr_list[0], hp->h_length); + } else { + /* Try IP representation */ + if (inet_aton(hostAddress, inAddress) == 0) { + /* IP not valid */ + LOC_LOGE("%s]: DNS query on '%s' failed", __func__, hostAddress); + ret = false; + } + } + + return ret; +} + +void +GnssAdapter::readConfigCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgReadConfig : public LocMsg { + GnssAdapter* mAdapter; + ContextBase& mContext; + inline MsgReadConfig(GnssAdapter* adapter, + ContextBase& context) : + LocMsg(), + mAdapter(adapter), + mContext(context) {} + inline virtual void proc() const { + // reads config into mContext->mGps_conf + mContext.readConfig(); + mContext.requestUlp((LocAdapterBase*)mAdapter, mContext.getCarrierCapabilities()); + } + }; + + if (mContext != NULL) { + sendMsg(new MsgReadConfig(this, *mContext)); + } +} + +void +GnssAdapter::setConfigCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgSetConfig : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + inline MsgSetConfig(GnssAdapter& adapter, + LocApiBase& api) : + LocMsg(), + mAdapter(adapter), + mApi(api) {} + inline virtual void proc() const { + if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + mApi.setSUPLVersion(mAdapter.convertSuplVersion(ContextBase::mGps_conf.SUPL_VER)); + mApi.setLPPConfig(mAdapter.convertLppProfile(ContextBase::mGps_conf.LPP_PROFILE)); + mApi.setAGLONASSProtocol(ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT); + } + mApi.setSensorControlConfig(ContextBase::mSap_conf.SENSOR_USAGE, + ContextBase::mSap_conf.SENSOR_PROVIDER); + mApi.setLPPeProtocolCp( + mAdapter.convertLppeCp(ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY)); + mApi.setLPPeProtocolUp( + mAdapter.convertLppeUp(ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY)); + + // set nmea mask type + uint32_t mask = 0; + if (NMEA_PROVIDER_MP == ContextBase::mGps_conf.NMEA_PROVIDER) { + mask |= LOC_NMEA_ALL_GENERAL_SUPPORTED_MASK; + } + if (mApi.isFeatureSupported(LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02)) { + mask |= LOC_NMEA_MASK_DEBUG_V02; + } + if (mask != 0) { + mApi.setNMEATypes(mask); + } + mAdapter.mNmeaMask= mask; + + mApi.setXtraVersionCheck(ContextBase::mGps_conf.XTRA_VERSION_CHECK); + if (ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID || + ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID || + ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || + ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || + ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) { + mApi.setSensorProperties( + ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID, + ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK, + ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, + ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, + ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, + ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, + ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY); + } + mApi.setSensorPerfControlConfig( + ContextBase::mSap_conf.SENSOR_CONTROL_MODE, + ContextBase::mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, + ContextBase::mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, + ContextBase::mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, + ContextBase::mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC, + ContextBase::mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, + ContextBase::mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, + ContextBase::mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, + ContextBase::mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, + ContextBase::mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK); + } + }; + + sendMsg(new MsgSetConfig(*this, *mLocApi)); +} + +uint32_t* +GnssAdapter::gnssUpdateConfigCommand(GnssConfig config) +{ + // count the number of bits set + GnssConfigFlagsMask flagsCopy = config.flags; + size_t count = 0; + while (flagsCopy > 0) { + if (flagsCopy & 1) { + count++; + } + flagsCopy >>= 1; + } + std::string idsString = "["; + uint32_t* ids = NULL; + if (count > 0) { + ids = new uint32_t[count]; + if (ids == nullptr) { + LOC_LOGE("%s] new allocation failed, fatal error.", __func__); + return nullptr; + } + for (size_t i=0; i < count; ++i) { + ids[i] = generateSessionId(); + IF_LOC_LOGD { + idsString += std::to_string(ids[i]) + " "; + } + } + } + idsString += "]"; + + LOC_LOGD("%s]: ids %s flags 0x%X", __func__, idsString.c_str(), config.flags); + + struct MsgGnssUpdateConfig : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + GnssConfig mConfig; + uint32_t* mIds; + size_t mCount; + inline MsgGnssUpdateConfig(GnssAdapter& adapter, + LocApiBase& api, + GnssConfig config, + uint32_t* ids, + size_t count) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mConfig(config), + mIds(ids), + mCount(count) {} + inline virtual ~MsgGnssUpdateConfig() + { + delete[] mIds; + } + inline virtual void proc() const { + LocationError* errs = new LocationError[mCount]; + LocationError err = LOCATION_ERROR_SUCCESS; + uint32_t index = 0; + + if (errs == nullptr) { + LOC_LOGE("%s] new allocation failed, fatal error.", __func__); + return; + } + + if (mConfig.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) { + uint32_t newGpsLock = mAdapter.convertGpsLock(mConfig.gpsLock); + ContextBase::mGps_conf.GPS_LOCK = newGpsLock; + if (0 == mAdapter.getPowerVoteId()) { + err = mApi.setGpsLock(mConfig.gpsLock); + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) { + uint32_t newSuplVersion = mAdapter.convertSuplVersion(mConfig.suplVersion); + if (newSuplVersion != ContextBase::mGps_conf.SUPL_VER && + ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + ContextBase::mGps_conf.SUPL_VER = newSuplVersion; + err = mApi.setSUPLVersion(mConfig.suplVersion); + } else { + err = LOCATION_ERROR_SUCCESS; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) { + if (GNSS_ASSISTANCE_TYPE_SUPL == mConfig.assistanceServer.type) { + if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + char serverUrl[MAX_URL_LEN] = {}; + int32_t length = 0; + const char noHost[] = "NONE"; + if (NULL == mConfig.assistanceServer.hostName || + strncasecmp(noHost, + mConfig.assistanceServer.hostName, + sizeof(noHost)) == 0) { + err = LOCATION_ERROR_INVALID_PARAMETER; + } else { + length = snprintf(serverUrl, sizeof(serverUrl), "%s:%u", + mConfig.assistanceServer.hostName, + mConfig.assistanceServer.port); + } + + if (length > 0 && strncasecmp(mAdapter.getServerUrl().c_str(), + serverUrl, sizeof(serverUrl)) != 0) { + mAdapter.setServerUrl(serverUrl); + err = mApi.setServer(serverUrl, length); + } + + } else { + err = LOCATION_ERROR_SUCCESS; + } + } else if (GNSS_ASSISTANCE_TYPE_C2K == mConfig.assistanceServer.type) { + if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + struct in_addr addr; + if (!mAdapter.resolveInAddress(mConfig.assistanceServer.hostName, + &addr)) { + LOC_LOGE("%s]: hostName %s cannot be resolved", + __func__, mConfig.assistanceServer.hostName); + err = LOCATION_ERROR_INVALID_PARAMETER; + } else { + unsigned int ip = htonl(addr.s_addr); + err = mApi.setServer(ip, mConfig.assistanceServer.port, + LOC_AGPS_CDMA_PDE_SERVER); + } + } else { + err = LOCATION_ERROR_SUCCESS; + } + } else { + LOC_LOGE("%s]: Not a valid gnss assistance type %u", + __func__, mConfig.assistanceServer.type); + err = LOCATION_ERROR_INVALID_PARAMETER; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) { + uint32_t newLppProfile = mAdapter.convertLppProfile(mConfig.lppProfile); + if (newLppProfile != ContextBase::mGps_conf.LPP_PROFILE && + ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + ContextBase::mGps_conf.LPP_PROFILE = newLppProfile; + err = mApi.setLPPConfig(mConfig.lppProfile); + } else { + err = LOCATION_ERROR_SUCCESS; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) { + uint32_t newLppeControlPlaneMask = + mAdapter.convertLppeCp(mConfig.lppeControlPlaneMask); + if (newLppeControlPlaneMask != ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY) { + ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY = newLppeControlPlaneMask; + err = mApi.setLPPeProtocolCp(mConfig.lppeControlPlaneMask); + } else { + err = LOCATION_ERROR_SUCCESS; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) { + uint32_t newLppeUserPlaneMask = + mAdapter.convertLppeUp(mConfig.lppeUserPlaneMask); + if (newLppeUserPlaneMask != ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY) { + ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY = newLppeUserPlaneMask; + err = mApi.setLPPeProtocolUp(mConfig.lppeUserPlaneMask); + } else { + err = LOCATION_ERROR_SUCCESS; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) { + uint32_t newAGloProtMask = + mAdapter.convertAGloProt(mConfig.aGlonassPositionProtocolMask); + if (newAGloProtMask != ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT && + ContextBase::mGps_conf.AGPS_CONFIG_INJECT) { + ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT = newAGloProtMask; + err = mApi.setAGLONASSProtocol(mConfig.aGlonassPositionProtocolMask); + } else { + err = LOCATION_ERROR_SUCCESS; + } + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT) { + uint32_t newEP4ES = mAdapter.convertEP4ES(mConfig.emergencyPdnForEmergencySupl); + if (newEP4ES != ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { + ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = newEP4ES; + } + err = LOCATION_ERROR_SUCCESS; + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT) { + uint32_t newSuplEs = mAdapter.convertSuplEs(mConfig.suplEmergencyServices); + if (newSuplEs != ContextBase::mGps_conf.SUPL_ES) { + ContextBase::mGps_conf.SUPL_ES = newSuplEs; + } + err = LOCATION_ERROR_SUCCESS; + if (index < mCount) { + errs[index++] = err; + } + } + if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_MODE_BIT) { + uint32_t newSuplMode = mAdapter.convertSuplMode(mConfig.suplModeMask); + if (newSuplMode != ContextBase::mGps_conf.SUPL_MODE) { + ContextBase::mGps_conf.SUPL_MODE = newSuplMode; + mAdapter.getUlpProxy()->setCapabilities( + ContextBase::getCarrierCapabilities()); + mAdapter.broadcastCapabilities(mAdapter.getCapabilities()); + } + err = LOCATION_ERROR_SUCCESS; + if (index < mCount) { + errs[index++] = err; + } + } + + mAdapter.reportResponse(index, errs, mIds); + delete[] errs; + } + }; + + if (NULL != ids) { + sendMsg(new MsgGnssUpdateConfig(*this, *mLocApi, config, ids, count)); + } else { + LOC_LOGE("%s]: No GNSS config items to update", __func__); + } + + return ids; +} + +uint32_t +GnssAdapter::gnssDeleteAidingDataCommand(GnssAidingData& data) +{ + uint32_t sessionId = generateSessionId(); + LOC_LOGD("%s]: id %u", __func__, sessionId); + + struct MsgDeleteAidingData : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + uint32_t mSessionId; + GnssAidingData mData; + inline MsgDeleteAidingData(GnssAdapter& adapter, + LocApiBase& api, + uint32_t sessionId, + GnssAidingData& data) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mSessionId(sessionId), + mData(data) {} + inline virtual void proc() const { + LocationError err = LOCATION_ERROR_SUCCESS; + err = mApi.deleteAidingData(mData); + mAdapter.reportResponse(err, mSessionId); + SystemStatus* s = mAdapter.getSystemStatus(); + if ((nullptr != s) && (mData.deleteAll)) { + s->setDefaultReport(); + } + } + }; + + sendMsg(new MsgDeleteAidingData(*this, *mLocApi, sessionId, data)); + return sessionId; +} + +void +GnssAdapter::injectLocationCommand(double latitude, double longitude, float accuracy) +{ + LOC_LOGD("%s]: latitude %8.4f longitude %8.4f accuracy %8.4f", + __func__, latitude, longitude, accuracy); + + struct MsgInjectLocation : public LocMsg { + LocApiBase& mApi; + ContextBase& mContext; + double mLatitude; + double mLongitude; + float mAccuracy; + inline MsgInjectLocation(LocApiBase& api, + ContextBase& context, + double latitude, + double longitude, + float accuracy) : + LocMsg(), + mApi(api), + mContext(context), + mLatitude(latitude), + mLongitude(longitude), + mAccuracy(accuracy) {} + inline virtual void proc() const { + if (!mContext.hasCPIExtendedCapabilities()) { + mApi.injectPosition(mLatitude, mLongitude, mAccuracy); + } + } + }; + + sendMsg(new MsgInjectLocation(*mLocApi, *mContext, latitude, longitude, accuracy)); +} + +void +GnssAdapter::injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty) +{ + LOC_LOGD("%s]: time %lld timeReference %lld uncertainty %d", + __func__, (long long)time, (long long)timeReference, uncertainty); + + struct MsgInjectTime : public LocMsg { + LocApiBase& mApi; + ContextBase& mContext; + int64_t mTime; + int64_t mTimeReference; + int32_t mUncertainty; + inline MsgInjectTime(LocApiBase& api, + ContextBase& context, + int64_t time, + int64_t timeReference, + int32_t uncertainty) : + LocMsg(), + mApi(api), + mContext(context), + mTime(time), + mTimeReference(timeReference), + mUncertainty(uncertainty) {} + inline virtual void proc() const { + mApi.setTime(mTime, mTimeReference, mUncertainty); + } + }; + + sendMsg(new MsgInjectTime(*mLocApi, *mContext, time, timeReference, uncertainty)); +} + +void +GnssAdapter::setUlpProxyCommand(UlpProxyBase* ulp) +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgSetUlpProxy : public LocMsg { + GnssAdapter& mAdapter; + UlpProxyBase* mUlp; + inline MsgSetUlpProxy(GnssAdapter& adapter, + UlpProxyBase* ulp) : + LocMsg(), + mAdapter(adapter), + mUlp(ulp) {} + inline virtual void proc() const { + mAdapter.setUlpProxy(mUlp); + if (mUlp) { + mUlp->setCapabilities(ContextBase::getCarrierCapabilities()); + } + } + }; + + sendMsg(new MsgSetUlpProxy(*this, ulp)); +} + +void +GnssAdapter::setUlpProxy(UlpProxyBase* ulp) +{ + if (ulp == mUlpProxy) { + //This takes care of the case when double initalization happens + //and we get the same object back for UlpProxyBase . Do nothing + return; + } + + LOC_LOGV("%s]: %p", __func__, ulp); + if (NULL == ulp) { + LOC_LOGE("%s]: ulp pointer is NULL", __func__); + ulp = new UlpProxyBase(); + } + + if (LOC_POSITION_MODE_INVALID != mUlpProxy->mPosMode.mode) { + // need to send this mode and start msg to ULP + ulp->sendFixMode(mUlpProxy->mPosMode); + } + + if (mUlpProxy->mFixSet) { + ulp->sendStartFix(); + } + + delete mUlpProxy; + mUlpProxy = ulp; +} + +void +GnssAdapter::addClientCommand(LocationAPI* client, const LocationCallbacks& callbacks) +{ + LOC_LOGD("%s]: client %p", __func__, client); + + struct MsgAddClient : public LocMsg { + GnssAdapter& mAdapter; + LocationAPI* mClient; + const LocationCallbacks mCallbacks; + inline MsgAddClient(GnssAdapter& adapter, + LocationAPI* client, + const LocationCallbacks& callbacks) : + LocMsg(), + mAdapter(adapter), + mClient(client), + mCallbacks(callbacks) {} + inline virtual void proc() const { + mAdapter.saveClient(mClient, mCallbacks); + } + }; + + sendMsg(new MsgAddClient(*this, client, callbacks)); +} + +void +GnssAdapter::removeClientCommand(LocationAPI* client) +{ + LOC_LOGD("%s]: client %p", __func__, client); + + struct MsgRemoveClient : public LocMsg { + GnssAdapter& mAdapter; + LocationAPI* mClient; + inline MsgRemoveClient(GnssAdapter& adapter, + LocationAPI* client) : + LocMsg(), + mAdapter(adapter), + mClient(client) {} + inline virtual void proc() const { + mAdapter.stopClientSessions(mClient); + mAdapter.eraseClient(mClient); + } + }; + + sendMsg(new MsgRemoveClient(*this, client)); +} + +void +GnssAdapter::stopClientSessions(LocationAPI* client) +{ + LOC_LOGD("%s]: client %p", __func__, client); + for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end();) { + if (client == it->first.client) { + LocationError err = stopTrackingMultiplex(it->first.client, it->first.id); + if (LOCATION_ERROR_SUCCESS == err) { + it = mTrackingSessions.erase(it); + continue; + } + } + ++it; // increment only when not erasing an iterator + } + +} + +void +GnssAdapter::updateClientsEventMask() +{ + LOC_API_ADAPTER_EVENT_MASK_T mask = 0; + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (it->second.trackingCb != nullptr) { + mask |= LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT; + } + if (it->second.gnssNiCb != nullptr) { + mask |= LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST; + } + if (it->second.gnssSvCb != nullptr) { + mask |= LOC_API_ADAPTER_BIT_SATELLITE_REPORT; + } + if ((it->second.gnssNmeaCb != nullptr) && (mNmeaMask)) { + mask |= LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; + } + if (it->second.gnssMeasurementsCb != nullptr) { + mask |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; + } + } + + /* + ** For Automotive use cases we need to enable MEASUREMENT and POLY + ** when QDR is enabled + */ + if(1 == ContextBase::mGps_conf.EXTERNAL_DR_ENABLED) { + mask |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; + mask |= LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT; + + LOC_LOGD("%s]: Auto usecase, Enable MEAS/POLY - mask 0x%x", __func__, mask); + } + + updateEvtMask(mask, LOC_REGISTRATION_MASK_SET); +} + +void +GnssAdapter::handleEngineUpEvent() +{ + struct MsgRestartSessions : public LocMsg { + GnssAdapter& mAdapter; + inline MsgRestartSessions(GnssAdapter& adapter) : + LocMsg(), + mAdapter(adapter) {} + virtual void proc() const { + mAdapter.restartSessions(); + } + }; + + setConfigCommand(); + sendMsg(new MsgRestartSessions(*this)); +} + +void +GnssAdapter::restartSessions() +{ + LOC_LOGD("%s]: ", __func__); + + if (mTrackingSessions.empty()) { + return; + } + + // get the LocationOptions that has the smallest interval, which should be the active one + LocationOptions smallestIntervalOptions = {}; // size is zero until set for the first time + for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end(); ++it) { + if (0 == smallestIntervalOptions.size || //size of zero means we havent set it yet + it->second.minInterval < smallestIntervalOptions.minInterval) { + smallestIntervalOptions = it->second; + } + } + + LocPosMode locPosMode = {}; + convertOptions(locPosMode, smallestIntervalOptions); + mLocApi->startFix(locPosMode); +} + +void +GnssAdapter::requestCapabilitiesCommand(LocationAPI* client) +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgRequestCapabilities : public LocMsg { + GnssAdapter& mAdapter; + LocationAPI* mClient; + inline MsgRequestCapabilities(GnssAdapter& adapter, + LocationAPI* client) : + LocMsg(), + mAdapter(adapter), + mClient(client) {} + inline virtual void proc() const { + LocationCallbacks callbacks = mAdapter.getClientCallbacks(mClient); + if (callbacks.capabilitiesCb == nullptr) { + LOC_LOGE("%s]: capabilitiesCb is NULL", __func__); + return; + } + + LocationCapabilitiesMask mask = mAdapter.getCapabilities(); + callbacks.capabilitiesCb(mask); + } + }; + + sendMsg(new MsgRequestCapabilities(*this, client)); +} + +LocationCapabilitiesMask +GnssAdapter::getCapabilities() +{ + LocationCapabilitiesMask mask = 0; + uint32_t carrierCapabilities = ContextBase::getCarrierCapabilities(); + // time based tracking always supported + mask |= LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT; + // geofence always supported + mask |= LOCATION_CAPABILITIES_GEOFENCE_BIT; + if (carrierCapabilities & LOC_GPS_CAPABILITY_MSB) { + mask |= LOCATION_CAPABILITIES_GNSS_MSB_BIT; + } + if (LOC_GPS_CAPABILITY_MSA & carrierCapabilities) { + mask |= LOCATION_CAPABILITIES_GNSS_MSA_BIT; + } + if (mLocApi == nullptr) + return mask; + if (mLocApi->isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_LOCATION_BATCHING)) { + mask |= LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT | + LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT; + } + if (mLocApi->isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_TRACKING)) { + mask |= LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT; + } + if (mLocApi->isMessageSupported(LOC_API_ADAPTER_MESSAGE_OUTDOOR_TRIP_BATCHING)) { + mask |= LOCATION_CAPABILITIES_OUTDOOR_TRIP_BATCHING_BIT; + } + if (mLocApi->gnssConstellationConfig()) { + mask |= LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT; + } + if (mLocApi->isFeatureSupported(LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02)) { + mask |= LOCATION_CAPABILITIES_DEBUG_NMEA_BIT; + } + return mask; +} + +void +GnssAdapter::broadcastCapabilities(LocationCapabilitiesMask mask) +{ + for (auto it = mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.capabilitiesCb) { + it->second.capabilitiesCb(mask); + } + } +} + +LocationCallbacks +GnssAdapter::getClientCallbacks(LocationAPI* client) +{ + LocationCallbacks callbacks = {}; + auto it = mClientData.find(client); + if (it != mClientData.end()) { + callbacks = it->second; + } + return callbacks; +} + +void +GnssAdapter::saveClient(LocationAPI* client, const LocationCallbacks& callbacks) +{ + mClientData[client] = callbacks; + updateClientsEventMask(); +} + +void +GnssAdapter::eraseClient(LocationAPI* client) +{ + auto it = mClientData.find(client); + if (it != mClientData.end()) { + mClientData.erase(it); + } + updateClientsEventMask(); +} + +bool +GnssAdapter::hasTrackingCallback(LocationAPI* client) +{ + auto it = mClientData.find(client); + return (it != mClientData.end() && it->second.trackingCb); +} + +bool +GnssAdapter::hasMeasurementsCallback(LocationAPI* client) +{ + auto it = mClientData.find(client); + return (it != mClientData.end() && it->second.gnssMeasurementsCb); +} + +bool +GnssAdapter::isTrackingSession(LocationAPI* client, uint32_t sessionId) +{ + LocationSessionKey key(client, sessionId); + return (mTrackingSessions.find(key) != mTrackingSessions.end()); +} + +void +GnssAdapter::saveTrackingSession(LocationAPI* client, uint32_t sessionId, + const LocationOptions& options) +{ + LocationSessionKey key(client, sessionId); + mTrackingSessions[key] = options; +} + +void +GnssAdapter::eraseTrackingSession(LocationAPI* client, uint32_t sessionId) +{ + LocationSessionKey key(client, sessionId); + auto it = mTrackingSessions.find(key); + if (it != mTrackingSessions.end()) { + mTrackingSessions.erase(it); + } + +} + +bool GnssAdapter::setUlpPositionMode(const LocPosMode& mode) { + if (!mUlpPositionMode.equals(mode)) { + mUlpPositionMode = mode; + return true; + } else { + return false; + } +} + +void +GnssAdapter::reportResponse(LocationAPI* client, LocationError err, uint32_t sessionId) +{ + LOC_LOGD("%s]: client %p id %u err %u", __func__, client, sessionId, err); + + auto it = mClientData.find(client); + if (it != mClientData.end() && + it->second.responseCb != nullptr) { + it->second.responseCb(err, sessionId); + } else { + LOC_LOGW("%s]: client %p id %u not found in data", __func__, client, sessionId); + } +} + +void +GnssAdapter::reportResponse(LocationError err, uint32_t sessionId) +{ + LOC_LOGD("%s]: id %u err %u", __func__, sessionId, err); + + if (mControlCallbacks.size > 0 && mControlCallbacks.responseCb != nullptr) { + mControlCallbacks.responseCb(err, sessionId); + } else { + LOC_LOGW("%s]: control client response callback not found", __func__); + } +} + +void +GnssAdapter::reportResponse(size_t count, LocationError* errs, uint32_t* ids) +{ + IF_LOC_LOGD { + std::string idsString = "["; + std::string errsString = "["; + if (NULL != ids && NULL != errs) { + for (size_t i=0; i < count; ++i) { + idsString += std::to_string(ids[i]) + " "; + errsString += std::to_string(errs[i]) + " "; + } + } + idsString += "]"; + errsString += "]"; + + LOC_LOGD("%s]: ids %s errs %s", + __func__, idsString.c_str(), errsString.c_str()); + } + + if (mControlCallbacks.size > 0 && mControlCallbacks.collectiveResponseCb != nullptr) { + mControlCallbacks.collectiveResponseCb(count, errs, ids); + } else { + LOC_LOGW("%s]: control client callback not found", __func__); + } +} + +uint32_t +GnssAdapter::startTrackingCommand(LocationAPI* client, LocationOptions& options) +{ + uint32_t sessionId = generateSessionId(); + LOC_LOGD("%s]: client %p id %u minInterval %u mode %u", + __func__, client, sessionId, options.minInterval, options.mode); + + struct MsgStartTracking : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + LocationAPI* mClient; + uint32_t mSessionId; + LocationOptions mOptions; + inline MsgStartTracking(GnssAdapter& adapter, + LocApiBase& api, + LocationAPI* client, + uint32_t sessionId, + LocationOptions options) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mClient(client), + mSessionId(sessionId), + mOptions(options) {} + inline virtual void proc() const { + LocationError err = LOCATION_ERROR_SUCCESS; + if (!mAdapter.hasTrackingCallback(mClient) && + !mAdapter.hasMeasurementsCallback(mClient)) { + err = LOCATION_ERROR_CALLBACK_MISSING; + } else if (0 == mOptions.size) { + err = LOCATION_ERROR_INVALID_PARAMETER; + } else { + // Api doesn't support multiple clients for time based tracking, so mutiplex + err = mAdapter.startTrackingMultiplex(mOptions); + if (LOCATION_ERROR_SUCCESS == err) { + mAdapter.saveTrackingSession(mClient, mSessionId, mOptions); + } + } + mAdapter.reportResponse(mClient, err, mSessionId); + } + }; + + sendMsg(new MsgStartTracking(*this, *mLocApi, client, sessionId, options)); + return sessionId; + +} + +LocationError +GnssAdapter::startTrackingMultiplex(const LocationOptions& options) +{ + LocationError err = LOCATION_ERROR_SUCCESS; + + if (mTrackingSessions.empty()) { + err = startTracking(options); + } else { + // get the LocationOptions that has the smallest interval, which should be the active one + LocationOptions smallestIntervalOptions = {}; // size is zero until set for the first time + for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end(); ++it) { + if (0 == smallestIntervalOptions.size || //size of zero means we havent set it yet + it->second.minInterval < smallestIntervalOptions.minInterval) { + smallestIntervalOptions = it->second; + } + } + // if new session's minInterval is smaller than any in other sessions + if (options.minInterval < smallestIntervalOptions.minInterval) { + // restart time based tracking with new options + err = startTracking(options); + } + } + + return err; +} + +LocationError +GnssAdapter::startTracking(const LocationOptions& options) +{ + LocationError err = LOCATION_ERROR_SUCCESS; + LocPosMode locPosMode = {}; + convertOptions(locPosMode, options); + if (!mUlpProxy->sendFixMode(locPosMode)) { + // do nothing + } + if (!mUlpProxy->sendStartFix()) { + loc_api_adapter_err apiErr = mLocApi->startFix(locPosMode); + if (LOC_API_ADAPTER_ERR_SUCCESS == apiErr) { + err = LOCATION_ERROR_SUCCESS; + } else { + err = LOCATION_ERROR_GENERAL_FAILURE; + } + } + + return err; +} + +void +GnssAdapter::setPositionModeCommand(LocPosMode& locPosMode) +{ + LOC_LOGD("%s]: min_interval %u mode %u", + __func__, locPosMode.min_interval, locPosMode.mode); + + struct MsgSetPositionMode : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + LocPosMode mLocPosMode; + inline MsgSetPositionMode(GnssAdapter& adapter, + LocApiBase& api, + LocPosMode& locPosMode) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mLocPosMode(locPosMode) {} + inline virtual void proc() const { + // saves the mode in adapter to be used when startTrackingCommand is called from ULP + if (mAdapter.setUlpPositionMode(mLocPosMode)) { + mApi.setPositionMode(mLocPosMode); + } + } + }; + + sendMsg(new MsgSetPositionMode(*this, *mLocApi, locPosMode)); +} + +void +GnssAdapter::startTrackingCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgStartTracking : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + inline MsgStartTracking(GnssAdapter& adapter, + LocApiBase& api) : + LocMsg(), + mAdapter(adapter), + mApi(api) {} + inline virtual void proc() const { + // we get this call from ULP, so just call LocApi without multiplexing because + // ulp would be doing the multiplexing for us if it is present + if (!mAdapter.isInSession()) { + LocPosMode& ulpPositionMode = mAdapter.getUlpPositionMode(); + mApi.startFix(ulpPositionMode); + } + } + }; + + sendMsg(new MsgStartTracking(*this, *mLocApi)); +} + +void +GnssAdapter::updateTrackingOptionsCommand(LocationAPI* client, uint32_t id, + LocationOptions& options) +{ + LOC_LOGD("%s]: client %p id %u minInterval %u mode %u", + __func__, client, id, options.minInterval, options.mode); + + struct MsgUpdateTracking : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + LocationAPI* mClient; + uint32_t mSessionId; + LocationOptions mOptions; + inline MsgUpdateTracking(GnssAdapter& adapter, + LocApiBase& api, + LocationAPI* client, + uint32_t sessionId, + LocationOptions options) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mClient(client), + mSessionId(sessionId), + mOptions(options) {} + inline virtual void proc() const { + if (mAdapter.isTrackingSession(mClient, mSessionId)) { + LocationError err = LOCATION_ERROR_SUCCESS; + if (0 == mOptions.size) { + err = LOCATION_ERROR_INVALID_PARAMETER; + } else { + // Api doesn't support multiple clients for time based tracking, so mutiplex + err = mAdapter.updateTrackingMultiplex(mClient, mSessionId, mOptions); + if (LOCATION_ERROR_SUCCESS == err) { + mAdapter.saveTrackingSession(mClient, mSessionId, mOptions); + } + } + mAdapter.reportResponse(mClient, err, mSessionId); + } + // we do not reportResponse for the case where there is no existing tracking session + // for the client and id being used, since updateTrackingCommand can be sent to both + // GnssAdapter & FlpAdapter by LocationAPI and we want to avoid incorrect error response + } + }; + + sendMsg(new MsgUpdateTracking(*this, *mLocApi, client, id, options)); +} + +LocationError +GnssAdapter::updateTrackingMultiplex(LocationAPI* client, uint32_t id, + const LocationOptions& options) +{ + LocationError err = LOCATION_ERROR_SUCCESS; + + if (1 == mTrackingSessions.size()) { + err = startTracking(options); + } else { + LocationSessionKey key(client, id); + + // get the session we are updating + auto it = mTrackingSessions.find(key); + if (it != mTrackingSessions.end()) { + // find the smallest interval, other than the session we are updating + LocationOptions smallestIntervalOptions = {}; // size is 0 until set for the first time + for (auto it2 = mTrackingSessions.begin(); it2 != mTrackingSessions.end(); ++it2) { + // if session is not the one we are updating and either smallest interval is not set + // or there is a new smallest interval, then set the new smallest interval + if (it2->first != key && (0 == smallestIntervalOptions.size || + it2->second.minInterval < smallestIntervalOptions.minInterval)) { + smallestIntervalOptions = it2->second; + } + } + // if session we are updating has smaller interval then next smallest + if (options.minInterval < smallestIntervalOptions.minInterval) { + // restart time based tracking with the newly updated interval + err = startTracking(options); + // else if the session we are updating used to be the smallest + } else if (it->second.minInterval < smallestIntervalOptions.minInterval) { + // restart time based tracking with the next smallest + err = startTracking(smallestIntervalOptions); + } + } + } + + return err; +} + +void +GnssAdapter::stopTrackingCommand(LocationAPI* client, uint32_t id) +{ + LOC_LOGD("%s]: client %p id %u", __func__, client, id); + + struct MsgStopTracking : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + LocationAPI* mClient; + uint32_t mSessionId; + inline MsgStopTracking(GnssAdapter& adapter, + LocApiBase& api, + LocationAPI* client, + uint32_t sessionId) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mClient(client), + mSessionId(sessionId) {} + inline virtual void proc() const { + if (mAdapter.isTrackingSession(mClient, mSessionId)) { + LocationError err = LOCATION_ERROR_SUCCESS; + // Api doesn't support multiple clients for time based tracking, so mutiplex + err = mAdapter.stopTrackingMultiplex(mClient, mSessionId); + if (LOCATION_ERROR_SUCCESS == err) { + mAdapter.eraseTrackingSession(mClient, mSessionId); + } + mAdapter.reportResponse(mClient, err, mSessionId); + } + // we do not reportResponse for the case where there is no existing tracking session + // for the client and id being used, since stopTrackingCommand can be sent to both + // GnssAdapter & FlpAdapter by LocationAPI and we want to avoid incorrect error response + + } + }; + + sendMsg(new MsgStopTracking(*this, *mLocApi, client, id)); +} + +LocationError +GnssAdapter::stopTrackingMultiplex(LocationAPI* client, uint32_t id) +{ + LocationError err = LOCATION_ERROR_SUCCESS; + + if (1 == mTrackingSessions.size()) { + err = stopTracking(); + } else { + LocationSessionKey key(client, id); + + // get the session we are stopping + auto it = mTrackingSessions.find(key); + if (it != mTrackingSessions.end()) { + // find the next smallest interval, other than the session we are stopping + LocationOptions smallestIntervalOptions = {}; // size is 0 until set for the first time + for (auto it2 = mTrackingSessions.begin(); it2 != mTrackingSessions.end(); ++it2) { + // if session is not the one we are stopping and either smallest interval is not set + // or there is a new smallest interval, then set the new smallest interval + if (it2->first != key && (0 == smallestIntervalOptions.size || + it2->second.minInterval < smallestIntervalOptions.minInterval)) { + smallestIntervalOptions = it2->second; + } + } + // if session we are stopping has smaller interval then next smallest + if (it->second.minInterval < smallestIntervalOptions.minInterval) { + // restart time based tracking with next smallest interval + err = startTracking(smallestIntervalOptions); + } + } + } + + return err; +} + +LocationError +GnssAdapter::stopTracking() +{ + LocationError err = LOCATION_ERROR_SUCCESS; + if (!mUlpProxy->sendStopFix()) { + loc_api_adapter_err apiErr = mLocApi->stopFix(); + if (LOC_API_ADAPTER_ERR_SUCCESS == apiErr) { + err = LOCATION_ERROR_SUCCESS; + } else { + err = LOCATION_ERROR_GENERAL_FAILURE; + } + } + + return err; +} + +void +GnssAdapter::stopTrackingCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgStopTracking : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + inline MsgStopTracking(GnssAdapter& adapter, + LocApiBase& api) : + LocMsg(), + mAdapter(adapter), + mApi(api) {} + inline virtual void proc() const { + // clear the position mode + LocPosMode mLocPosMode = {}; + mLocPosMode.mode = LOC_POSITION_MODE_INVALID; + mAdapter.setUlpPositionMode(mLocPosMode); + // don't need to multiplex because ULP will do that for us if it is present + mApi.stopFix(); + } + }; + + sendMsg(new MsgStopTracking(*this, *mLocApi)); +} + +void +GnssAdapter::getZppCommand() +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgGetZpp : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + inline MsgGetZpp(GnssAdapter& adapter, + LocApiBase& api) : + LocMsg(), + mAdapter(adapter), + mApi(api) {} + inline virtual void proc() const { + UlpLocation location = {}; + LocPosTechMask techMask = LOC_POS_TECH_MASK_DEFAULT; + GpsLocationExtended locationExtended = {}; + locationExtended.size = sizeof(locationExtended); + + mApi.getBestAvailableZppFix(location.gpsLocation, locationExtended, + techMask); + //Mark the location source as from ZPP + location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO; + location.position_source = ULP_LOCATION_IS_FROM_ZPP; + + mAdapter.getUlpProxy()->reportPosition(location, + locationExtended, + LOC_SESS_SUCCESS, + techMask); + } + }; + + sendMsg(new MsgGetZpp(*this, *mLocApi)); +} + +bool +GnssAdapter::hasNiNotifyCallback(LocationAPI* client) +{ + auto it = mClientData.find(client); + return (it != mClientData.end() && it->second.gnssNiCb); +} + +void +GnssAdapter::gnssNiResponseCommand(LocationAPI* client, + uint32_t id, + GnssNiResponse response) +{ + LOC_LOGD("%s]: client %p id %u response %u", __func__, client, id, response); + + struct MsgGnssNiResponse : public LocMsg { + GnssAdapter& mAdapter; + LocationAPI* mClient; + uint32_t mSessionId; + GnssNiResponse mResponse; + inline MsgGnssNiResponse(GnssAdapter& adapter, + LocationAPI* client, + uint32_t sessionId, + GnssNiResponse response) : + LocMsg(), + mAdapter(adapter), + mClient(client), + mSessionId(sessionId), + mResponse(response) {} + inline virtual void proc() const { + NiData& niData = mAdapter.getNiData(); + LocationError err = LOCATION_ERROR_SUCCESS; + if (!mAdapter.hasNiNotifyCallback(mClient)) { + err = LOCATION_ERROR_ID_UNKNOWN; + } else { + NiSession* pSession = NULL; + if (mSessionId == niData.sessionEs.reqID && + NULL != niData.sessionEs.rawRequest) { + pSession = &niData.sessionEs; + // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted + if (mResponse == GNSS_NI_RESPONSE_ACCEPT && + NULL != niData.session.rawRequest) { + pthread_mutex_lock(&niData.session.tLock); + niData.session.resp = GNSS_NI_RESPONSE_IGNORE; + niData.session.respRecvd = true; + pthread_cond_signal(&niData.session.tCond); + pthread_mutex_unlock(&niData.session.tLock); + } + } else if (mSessionId == niData.session.reqID && + NULL != niData.session.rawRequest) { + pSession = &niData.session; + } + + if (pSession) { + LOC_LOGI("%s]: gnssNiResponseCommand: send user mResponse %u for id %u", + __func__, mResponse, mSessionId); + pthread_mutex_lock(&pSession->tLock); + pSession->resp = mResponse; + pSession->respRecvd = true; + pthread_cond_signal(&pSession->tCond); + pthread_mutex_unlock(&pSession->tLock); + } else { + err = LOCATION_ERROR_ID_UNKNOWN; + LOC_LOGE("%s]: gnssNiResponseCommand: id %u not an active session", + __func__, mSessionId); + } + } + mAdapter.reportResponse(mClient, err, mSessionId); + } + }; + + sendMsg(new MsgGnssNiResponse(*this, client, id, response)); + +} + +void +GnssAdapter::gnssNiResponseCommand(GnssNiResponse response, void* rawRequest) +{ + LOC_LOGD("%s]: response %u", __func__, response); + + struct MsgGnssNiResponse : public LocMsg { + LocApiBase& mApi; + const GnssNiResponse mResponse; + const void* mPayload; + inline MsgGnssNiResponse(LocApiBase& api, + const GnssNiResponse response, + const void* rawRequest) : + LocMsg(), + mApi(api), + mResponse(response), + mPayload(rawRequest) {} + inline virtual ~MsgGnssNiResponse() { + // this is a bit weird since mPayload is not + // allocated by this class. But there is no better way. + // mPayload actually won't be NULL here. + free((void*)mPayload); + } + inline virtual void proc() const { + mApi.informNiResponse(mResponse, mPayload); + } + }; + + sendMsg(new MsgGnssNiResponse(*mLocApi, response, rawRequest)); + +} + +uint32_t +GnssAdapter::enableCommand(LocationTechnologyType techType) +{ + uint32_t sessionId = generateSessionId(); + LOC_LOGD("%s]: id %u techType %u", __func__, sessionId, techType); + + struct MsgEnableGnss : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + ContextBase& mContext; + uint32_t mSessionId; + LocationTechnologyType mTechType; + inline MsgEnableGnss(GnssAdapter& adapter, + LocApiBase& api, + ContextBase& context, + uint32_t sessionId, + LocationTechnologyType techType) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mContext(context), + mSessionId(sessionId), + mTechType(techType) {} + inline virtual void proc() const { + LocationError err = LOCATION_ERROR_SUCCESS; + uint32_t powerVoteId = mAdapter.getPowerVoteId(); + if (mTechType != LOCATION_TECHNOLOGY_TYPE_GNSS) { + err = LOCATION_ERROR_INVALID_PARAMETER; + } else if (powerVoteId > 0) { + err = LOCATION_ERROR_ALREADY_STARTED; + } else { + mContext.modemPowerVote(true); + mAdapter.setPowerVoteId(mSessionId); + mApi.setGpsLock(GNSS_CONFIG_GPS_LOCK_NONE); + mAdapter.mXtraObserver.updateLockStatus( + mAdapter.convertGpsLock(GNSS_CONFIG_GPS_LOCK_NONE)); + } + mAdapter.reportResponse(err, mSessionId); + } + }; + + if (mContext != NULL) { + sendMsg(new MsgEnableGnss(*this, *mLocApi, *mContext, sessionId, techType)); + } else { + LOC_LOGE("%s]: Context is NULL", __func__); + } + + return sessionId; +} + +void +GnssAdapter::disableCommand(uint32_t id) +{ + LOC_LOGD("%s]: id %u", __func__, id); + + struct MsgDisableGnss : public LocMsg { + GnssAdapter& mAdapter; + LocApiBase& mApi; + ContextBase& mContext; + uint32_t mSessionId; + inline MsgDisableGnss(GnssAdapter& adapter, + LocApiBase& api, + ContextBase& context, + uint32_t sessionId) : + LocMsg(), + mAdapter(adapter), + mApi(api), + mContext(context), + mSessionId(sessionId) {} + inline virtual void proc() const { + LocationError err = LOCATION_ERROR_SUCCESS; + uint32_t powerVoteId = mAdapter.getPowerVoteId(); + if (powerVoteId != mSessionId) { + err = LOCATION_ERROR_ID_UNKNOWN; + } else { + mContext.modemPowerVote(false); + mAdapter.setPowerVoteId(0); + mApi.setGpsLock(mAdapter.convertGpsLock(ContextBase::mGps_conf.GPS_LOCK)); + mAdapter.mXtraObserver.updateLockStatus( + mAdapter.convertGpsLock(ContextBase::mGps_conf.GPS_LOCK)); + } + mAdapter.reportResponse(err, mSessionId); + } + }; + + if (mContext != NULL) { + sendMsg(new MsgDisableGnss(*this, *mLocApi, *mContext, id)); + } + +} + +void +GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + enum loc_sess_status status, + LocPosTechMask techMask, + bool fromUlp) +{ + LOC_LOGD("%s]: fromUlp %u status %u", __func__, fromUlp, status); + + // if this event is not called from ULP, then try to call into ULP and return if successfull + if (!fromUlp) { + if (mUlpProxy->reportPosition(ulpLocation, locationExtended, + status, techMask)) { + return; + } + } + + struct MsgReportPosition : public LocMsg { + GnssAdapter& mAdapter; + const UlpLocation mUlpLocation; + const GpsLocationExtended mLocationExtended; + loc_sess_status mStatus; + LocPosTechMask mTechMask; + inline MsgReportPosition(GnssAdapter& adapter, + const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + loc_sess_status status, + LocPosTechMask techMask) : + LocMsg(), + mAdapter(adapter), + mUlpLocation(ulpLocation), + mLocationExtended(locationExtended), + mStatus(status), + mTechMask(techMask) {} + inline virtual void proc() const { + // extract bug report info - this returns true if consumed by systemstatus + SystemStatus* s = mAdapter.getSystemStatus(); + if ((nullptr != s) && (LOC_SESS_SUCCESS == mStatus)){ + s->eventPosition(mUlpLocation, mLocationExtended); + } + mAdapter.reportPosition(mUlpLocation, mLocationExtended, mStatus, mTechMask); + } + }; + + sendMsg(new MsgReportPosition(*this, ulpLocation, locationExtended, status, techMask)); +} + +void +GnssAdapter::reportPosition(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + enum loc_sess_status status, + LocPosTechMask techMask) +{ + bool reported = false; + // what's in the if is... (line by line) + // 1. this is a final fix; and + // 1.1 it is a Satellite fix; or + // 1.2 it is a sensor fix + // 2. (must be intermediate fix... implicit) + // 2.1 we accepte intermediate; and + // 2.2 it is NOT the case that + // 2.2.1 there is inaccuracy; and + // 2.2.2 we care about inaccuracy; and + // 2.2.3 the inaccuracy exceeds our tolerance + if ((LOC_SESS_SUCCESS == status && + ((LOC_POS_TECH_MASK_SATELLITE | + LOC_POS_TECH_MASK_SENSORS | + LOC_POS_TECH_MASK_HYBRID) & + techMask)) || + (LOC_SESS_INTERMEDIATE == ContextBase::mGps_conf.INTERMEDIATE_POS && + !((ulpLocation.gpsLocation.flags & + LOC_GPS_LOCATION_HAS_ACCURACY) && + (ContextBase::mGps_conf.ACCURACY_THRES != 0) && + (ulpLocation.gpsLocation.accuracy > + ContextBase::mGps_conf.ACCURACY_THRES)))) { + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA) { + mGnssSvIdUsedInPosAvail = true; + mGnssSvIdUsedInPosition = locationExtended.gnss_sv_used_ids; + } + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.trackingCb) { + Location location = {}; + convertLocation(location, ulpLocation.gpsLocation, locationExtended, techMask); + it->second.trackingCb(location); + } + if (nullptr != it->second.gnssLocationInfoCb) { + GnssLocationInfoNotification locationInfo = {}; + convertLocationInfo(locationInfo, locationExtended); + it->second.gnssLocationInfoCb(locationInfo); + } + } + reported = true; + } + + if (NMEA_PROVIDER_AP == ContextBase::mGps_conf.NMEA_PROVIDER && !mTrackingSessions.empty()) { + /*Only BlankNMEA sentence needs to be processed and sent, if both lat, long is 0 & + horReliability is not set. */ + bool blank_fix = ((0 == ulpLocation.gpsLocation.latitude) && + (0 == ulpLocation.gpsLocation.longitude) && + (LOC_RELIABILITY_NOT_SET == locationExtended.horizontal_reliability)); + uint8_t generate_nmea = (reported && status != LOC_SESS_FAILURE && !blank_fix); + std::vector nmeaArraystr; + loc_nmea_generate_pos(ulpLocation, locationExtended, generate_nmea, nmeaArraystr); + for (auto sentence : nmeaArraystr) { + reportNmea(sentence.c_str(), sentence.length()); + } + } + + // Free the allocated memory for rawData + UlpLocation* gp = (UlpLocation*)&(ulpLocation); + if (gp != NULL && gp->rawData != NULL) + { + delete (char*)gp->rawData; + gp->rawData = NULL; + gp->rawDataSize = 0; + } +} + +void +GnssAdapter::reportSvEvent(const GnssSvNotification& svNotify, + bool fromUlp) +{ + LOC_LOGD("%s]: fromUlp %u", __func__, fromUlp); + + // if this event is not called from ULP, then try to call into ULP and return if successfull + if (!fromUlp) { + if (mUlpProxy->reportSv(svNotify)) { + return; + } + } + + struct MsgReportSv : public LocMsg { + GnssAdapter& mAdapter; + const GnssSvNotification mSvNotify; + inline MsgReportSv(GnssAdapter& adapter, + const GnssSvNotification& svNotify) : + LocMsg(), + mAdapter(adapter), + mSvNotify(svNotify) {} + inline virtual void proc() const { + mAdapter.reportSv((GnssSvNotification&)mSvNotify); + } + }; + + sendMsg(new MsgReportSv(*this, svNotify)); +} + +void +GnssAdapter::reportSv(GnssSvNotification& svNotify) +{ + int numSv = svNotify.count; + int16_t gnssSvId = 0; + uint64_t svUsedIdMask = 0; + for (int i=0; i < numSv; i++) { + svUsedIdMask = 0; + gnssSvId = svNotify.gnssSvs[i].svId; + switch (svNotify.gnssSvs[i].type) { + case GNSS_SV_TYPE_GPS: + if (mGnssSvIdUsedInPosAvail) { + svUsedIdMask = mGnssSvIdUsedInPosition.gps_sv_used_ids_mask; + } + break; + case GNSS_SV_TYPE_GLONASS: + if (mGnssSvIdUsedInPosAvail) { + svUsedIdMask = mGnssSvIdUsedInPosition.glo_sv_used_ids_mask; + } + break; + case GNSS_SV_TYPE_BEIDOU: + if (mGnssSvIdUsedInPosAvail) { + svUsedIdMask = mGnssSvIdUsedInPosition.bds_sv_used_ids_mask; + } + break; + case GNSS_SV_TYPE_GALILEO: + if (mGnssSvIdUsedInPosAvail) { + svUsedIdMask = mGnssSvIdUsedInPosition.gal_sv_used_ids_mask; + } + break; + case GNSS_SV_TYPE_QZSS: + if (mGnssSvIdUsedInPosAvail) { + svUsedIdMask = mGnssSvIdUsedInPosition.qzss_sv_used_ids_mask; + } + // QZSS SV id's need to reported as it is to framework, since + // framework expects it as it is. See GnssStatus.java. + // SV id passed to here by LocApi is 1-based. + svNotify.gnssSvs[i].svId += (QZSS_SV_PRN_MIN - 1); + break; + default: + svUsedIdMask = 0; + break; + } + + // If SV ID was used in previous position fix, then set USED_IN_FIX + // flag, else clear the USED_IN_FIX flag. + if (svUsedIdMask & (1 << (gnssSvId - 1))) { + svNotify.gnssSvs[i].gnssSvOptionsMask |= GNSS_SV_OPTIONS_USED_IN_FIX_BIT; + } + } + + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.gnssSvCb) { + it->second.gnssSvCb(svNotify); + } + } + + if (NMEA_PROVIDER_AP == ContextBase::mGps_conf.NMEA_PROVIDER && !mTrackingSessions.empty()) { + std::vector nmeaArraystr; + loc_nmea_generate_sv(svNotify, nmeaArraystr); + for (auto sentence : nmeaArraystr) { + reportNmea(sentence.c_str(), sentence.length()); + } + } + + mGnssSvIdUsedInPosAvail = false; +} + +void +GnssAdapter::reportNmeaEvent(const char* nmea, size_t length, bool fromUlp) +{ + // if this event is not called from ULP, then try to call into ULP and return if successfull + if (!fromUlp && !loc_nmea_is_debug(nmea, length)) { + if (mUlpProxy->reportNmea(nmea, length)) { + return; + } + } + + struct MsgReportNmea : public LocMsg { + GnssAdapter& mAdapter; + const char* mNmea; + size_t mLength; + inline MsgReportNmea(GnssAdapter& adapter, + const char* nmea, + size_t length) : + LocMsg(), + mAdapter(adapter), + mNmea(new char[length+1]), + mLength(length) { + if (mNmea == nullptr) { + LOC_LOGE("%s] new allocation failed, fatal error.", __func__); + return; + } + strlcpy((char*)mNmea, nmea, length+1); + } + inline virtual ~MsgReportNmea() + { + delete[] mNmea; + } + inline virtual void proc() const { + // extract bug report info - this returns true if consumed by systemstatus + bool ret = false; + SystemStatus* s = mAdapter.getSystemStatus(); + if (nullptr != s) { + ret = s->setNmeaString(mNmea, mLength); + } + if (false == ret) { + // forward NMEA message to upper layer + mAdapter.reportNmea(mNmea, mLength); + } + } + }; + + sendMsg(new MsgReportNmea(*this, nmea, length)); +} + +void +GnssAdapter::reportNmea(const char* nmea, size_t length) +{ + GnssNmeaNotification nmeaNotification = {}; + nmeaNotification.size = sizeof(GnssNmeaNotification); + + struct timeval tv; + gettimeofday(&tv, (struct timezone *) NULL); + int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000; + nmeaNotification.timestamp = now; + nmeaNotification.nmea = nmea; + nmeaNotification.length = length; + + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.gnssNmeaCb) { + it->second.gnssNmeaCb(nmeaNotification); + } + } +} + +bool +GnssAdapter::requestNiNotifyEvent(const GnssNiNotification ¬ify, const void* data) +{ + LOC_LOGI("%s]: notif_type: %d, timeout: %d, default_resp: %d" + "requestor_id: %s (encoding: %d) text: %s text (encoding: %d) extras: %s", + __func__, notify.type, notify.timeout, notify.timeoutResponse, + notify.requestor, notify.requestorEncoding, + notify.message, notify.messageEncoding, notify.extras); + + struct MsgReportNiNotify : public LocMsg { + GnssAdapter& mAdapter; + const GnssNiNotification mNotify; + const void* mData; + inline MsgReportNiNotify(GnssAdapter& adapter, + const GnssNiNotification& notify, + const void* data) : + LocMsg(), + mAdapter(adapter), + mNotify(notify), + mData(data) {} + inline virtual void proc() const { + mAdapter.requestNiNotify(mNotify, mData); + } + }; + + sendMsg(new MsgReportNiNotify(*this, notify, data)); + + return true; +} + +static void* niThreadProc(void *args) +{ + NiSession* pSession = (NiSession*)args; + int rc = 0; /* return code from pthread calls */ + + struct timeval present_time; + struct timespec expire_time; + + pthread_mutex_lock(&pSession->tLock); + /* Calculate absolute expire time */ + gettimeofday(&present_time, NULL); + expire_time.tv_sec = present_time.tv_sec + pSession->respTimeLeft; + expire_time.tv_nsec = present_time.tv_usec * 1000; + LOC_LOGD("%s]: time out set for abs time %ld with delay %d sec", + __func__, (long)expire_time.tv_sec, pSession->respTimeLeft); + + while (!pSession->respRecvd) { + rc = pthread_cond_timedwait(&pSession->tCond, + &pSession->tLock, + &expire_time); + if (rc == ETIMEDOUT) { + pSession->resp = GNSS_NI_RESPONSE_NO_RESPONSE; + LOC_LOGD("%s]: time out after valting for specified time. Ret Val %d", + __func__, rc); + break; + } + } + LOC_LOGD("%s]: Java layer has sent us a user response and return value from " + "pthread_cond_timedwait = %d pSession->resp is %u", __func__, rc, pSession->resp); + pSession->respRecvd = false; /* Reset the user response flag for the next session*/ + + // adding this check to support modem restart, in which case, we need the thread + // to exit without calling sending data. We made sure that rawRequest is NULL in + // loc_eng_ni_reset_on_engine_restart() + GnssAdapter* adapter = pSession->adapter; + GnssNiResponse resp; + void* rawRequest = NULL; + bool sendResponse = false; + + if (NULL != pSession->rawRequest) { + if (pSession->resp != GNSS_NI_RESPONSE_IGNORE) { + resp = pSession->resp; + rawRequest = pSession->rawRequest; + sendResponse = true; + } else { + free(pSession->rawRequest); + } + pSession->rawRequest = NULL; + } + pthread_mutex_unlock(&pSession->tLock); + + pSession->respTimeLeft = 0; + pSession->reqID = 0; + + if (sendResponse) { + adapter->gnssNiResponseCommand(resp, rawRequest); + } + + return NULL; +} + +bool +GnssAdapter::requestNiNotify(const GnssNiNotification& notify, const void* data) +{ + NiSession* pSession = NULL; + gnssNiCallback gnssNiCb = nullptr; + + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.gnssNiCb) { + gnssNiCb = it->second.gnssNiCb; + break; + } + } + if (nullptr == gnssNiCb) { + EXIT_LOG(%s, "no clients with gnssNiCb."); + return false; + } + + if (notify.type == GNSS_NI_TYPE_EMERGENCY_SUPL) { + if (NULL != mNiData.sessionEs.rawRequest) { + LOC_LOGI("%s]: supl es NI in progress, new supl es NI ignored, type: %d", + __func__, notify.type); + if (NULL != data) { + free((void*)data); + } + } else { + pSession = &mNiData.sessionEs; + } + } else { + if (NULL != mNiData.session.rawRequest || + NULL != mNiData.sessionEs.rawRequest) { + LOC_LOGI("%s]: supl NI in progress, new supl NI ignored, type: %d", + __func__, notify.type); + if (NULL != data) { + free((void*)data); + } + } else { + pSession = &mNiData.session; + } + } + + if (pSession) { + /* Save request */ + pSession->rawRequest = (void*)data; + pSession->reqID = ++mNiData.reqIDCounter; + pSession->adapter = this; + + int sessionId = pSession->reqID; + + /* For robustness, spawn a thread at this point to timeout to clear up the notification + * status, even though the OEM layer in java does not do so. + **/ + pSession->respTimeLeft = + 5 + (notify.timeout != 0 ? notify.timeout : LOC_NI_NO_RESPONSE_TIME); + + int rc = 0; + rc = pthread_create(&pSession->thread, NULL, niThreadProc, pSession); + if (rc) { + LOC_LOGE("%s]: Loc NI thread is not created.", __func__); + } + rc = pthread_detach(pSession->thread); + if (rc) { + LOC_LOGE("%s]: Loc NI thread is not detached.", __func__); + } + + if (nullptr != gnssNiCb) { + gnssNiCb(sessionId, notify); + } + } + + return true; +} + +void +GnssAdapter::reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurements, + int msInWeek) +{ + LOC_LOGD("%s]: ", __func__); + + struct MsgReportGnssMeasurementData : public LocMsg { + GnssAdapter& mAdapter; + GnssMeasurementsNotification mMeasurementsNotify; + inline MsgReportGnssMeasurementData(GnssAdapter& adapter, + const GnssMeasurementsNotification& measurements, + int msInWeek) : + LocMsg(), + mAdapter(adapter), + mMeasurementsNotify(measurements) { + if (-1 != msInWeek) { + mAdapter.getAgcInformation(mMeasurementsNotify, msInWeek); + } + } + inline virtual void proc() const { + mAdapter.reportGnssMeasurementData(mMeasurementsNotify); + } + }; + + sendMsg(new MsgReportGnssMeasurementData(*this, measurements, msInWeek)); +} + +void +GnssAdapter::reportGnssMeasurementData(const GnssMeasurementsNotification& measurements) +{ + for (auto it=mClientData.begin(); it != mClientData.end(); ++it) { + if (nullptr != it->second.gnssMeasurementsCb) { + it->second.gnssMeasurementsCb(measurements); + } + } +} + +void +GnssAdapter::reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet) +{ + LOC_LOGD("%s]: ", __func__); + + // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary. + mUlpProxy->reportSvMeasurement(svMeasurementSet); +} + +void +GnssAdapter::reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial) +{ + LOC_LOGD("%s]: ", __func__); + + // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary. + mUlpProxy->reportSvPolynomial(svPolynomial); +} + +void GnssAdapter::initDefaultAgps() { + LOC_LOGD("%s]: ", __func__); + + LocationCapabilitiesMask mask = getCapabilities(); + if (!(mask & LOCATION_CAPABILITIES_GNSS_MSB_BIT) && + !(mask & LOCATION_CAPABILITIES_GNSS_MSA_BIT)) { + LOC_LOGI("%s]: Target does not support MSB and MSA.", __func__); + return; + } + + void *handle = nullptr; + if ((handle = dlopen("libloc_net_iface.so", RTLD_NOW)) == nullptr) { + LOC_LOGE("%s]: libloc_net_iface.so not found !", __func__); + return; + } + + LocAgpsGetAgpsCbInfo getAgpsCbInfo = (LocAgpsGetAgpsCbInfo) + dlsym(handle, "LocNetIfaceAgps_getAgpsCbInfo"); + if (getAgpsCbInfo == nullptr) { + LOC_LOGE("%s]: Failed to get method LocNetIfaceAgps_getStatusCb", __func__); + return; + } + + AgpsCbInfo& cbInfo = getAgpsCbInfo(agpsOpenResultCb, agpsCloseResultCb, this); + + if (cbInfo.statusV4Cb == nullptr) { + LOC_LOGE("%s]: statusV4Cb is nullptr!", __func__); + return; + } + + initAgpsCommand(cbInfo); +} + +void GnssAdapter::initDefaultAgpsCommand() { + LOC_LOGD("%s]: ", __func__); + + struct MsgInitDefaultAgps : public LocMsg { + GnssAdapter& mAdapter; + inline MsgInitDefaultAgps(GnssAdapter& adapter) : + LocMsg(), + mAdapter(adapter) { + LOC_LOGV("MsgInitDefaultAgps"); + } + inline virtual void proc() const { + mAdapter.initDefaultAgps(); + } + }; + + sendMsg(new MsgInitDefaultAgps(*this)); +} + +/* INIT LOC AGPS MANAGER */ +void GnssAdapter::initAgpsCommand(const AgpsCbInfo& cbInfo){ + + LOC_LOGI("GnssAdapter::initAgpsCommand"); + + /* Set ATL open/close callbacks */ + AgpsAtlOpenStatusCb atlOpenStatusCb = + [this](int handle, int isSuccess, char* apn, + AGpsBearerType bearerType, AGpsExtType agpsType) { + + mLocApi->atlOpenStatus( + handle, isSuccess, apn, bearerType, agpsType); + }; + AgpsAtlCloseStatusCb atlCloseStatusCb = + [this](int handle, int isSuccess) { + + mLocApi->atlCloseStatus(handle, isSuccess); + }; + + /* Register DS Client APIs */ + AgpsDSClientInitFn dsClientInitFn = + [this](bool isDueToSSR) { + + return mLocApi->initDataServiceClient(isDueToSSR); + }; + + AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn = + [this] { + + return mLocApi->openAndStartDataCall(); + }; + + AgpsDSClientStopDataCallFn dsClientStopDataCallFn = + [this] { + + mLocApi->stopDataCall(); + }; + + AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn = + [this] { + + mLocApi->closeDataCall(); + }; + + AgpsDSClientReleaseFn dsClientReleaseFn = + [this] { + + mLocApi->releaseDataServiceClient(); + }; + + /* Send Msg function */ + SendMsgToAdapterMsgQueueFn sendMsgFn = + [this](LocMsg* msg) { + + sendMsg(msg); + }; + + /* Message to initialize AGPS module */ + struct AgpsMsgInit: public LocMsg { + + AgpsManager* mAgpsManager; + + AgnssStatusIpV4Cb mFrameworkStatusV4Cb; + + AgpsAtlOpenStatusCb mAtlOpenStatusCb; + AgpsAtlCloseStatusCb mAtlCloseStatusCb; + + AgpsDSClientInitFn mDSClientInitFn; + AgpsDSClientOpenAndStartDataCallFn mDSClientOpenAndStartDataCallFn; + AgpsDSClientStopDataCallFn mDSClientStopDataCallFn; + AgpsDSClientCloseDataCallFn mDSClientCloseDataCallFn; + AgpsDSClientReleaseFn mDSClientReleaseFn; + + SendMsgToAdapterMsgQueueFn mSendMsgFn; + GnssAdapter& mAdapter; + + inline AgpsMsgInit(AgpsManager* agpsManager, + AgnssStatusIpV4Cb frameworkStatusV4Cb, + AgpsAtlOpenStatusCb atlOpenStatusCb, + AgpsAtlCloseStatusCb atlCloseStatusCb, + AgpsDSClientInitFn dsClientInitFn, + AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn, + AgpsDSClientStopDataCallFn dsClientStopDataCallFn, + AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn, + AgpsDSClientReleaseFn dsClientReleaseFn, + SendMsgToAdapterMsgQueueFn sendMsgFn, + GnssAdapter& adapter) : + LocMsg(), mAgpsManager(agpsManager), mFrameworkStatusV4Cb( + frameworkStatusV4Cb), mAtlOpenStatusCb(atlOpenStatusCb), mAtlCloseStatusCb( + atlCloseStatusCb), mDSClientInitFn(dsClientInitFn), mDSClientOpenAndStartDataCallFn( + dsClientOpenAndStartDataCallFn), mDSClientStopDataCallFn( + dsClientStopDataCallFn), mDSClientCloseDataCallFn( + dsClientCloseDataCallFn), mDSClientReleaseFn( + dsClientReleaseFn), mSendMsgFn(sendMsgFn), + mAdapter(adapter) { + + LOC_LOGV("AgpsMsgInit"); + } + + inline virtual void proc() const { + + LOC_LOGV("AgpsMsgInit::proc()"); + + mAgpsManager->registerCallbacks(mFrameworkStatusV4Cb, mAtlOpenStatusCb, + mAtlCloseStatusCb, mDSClientInitFn, + mDSClientOpenAndStartDataCallFn, mDSClientStopDataCallFn, + mDSClientCloseDataCallFn, mDSClientReleaseFn, mSendMsgFn); + + mAgpsManager->createAgpsStateMachines(); + + /* Register for AGPS event mask */ + mAdapter.updateEvtMask(LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST, + LOC_REGISTRATION_MASK_ENABLED); + } + }; + + if (mAgpsCbInfo.cbPriority > cbInfo.cbPriority) { + LOC_LOGI("Higher priority AGPS CB already registered (%d > %d) !", + mAgpsCbInfo.cbPriority, cbInfo.cbPriority); + return; + } else { + mAgpsCbInfo = cbInfo; + LOC_LOGI("Registering AGPS CB %p with priority %d", + mAgpsCbInfo.statusV4Cb, mAgpsCbInfo.cbPriority); + } + + /* Send message to initialize AGPS Manager */ + sendMsg(new AgpsMsgInit( + &mAgpsManager, + (AgnssStatusIpV4Cb)cbInfo.statusV4Cb, + atlOpenStatusCb, atlCloseStatusCb, + dsClientInitFn, dsClientOpenAndStartDataCallFn, + dsClientStopDataCallFn, dsClientCloseDataCallFn, + dsClientReleaseFn, + sendMsgFn, + *this)); +} + +/* GnssAdapter::requestATL + * Method triggered in QMI thread as part of handling below message: + * eQMI_LOC_SERVER_REQUEST_OPEN_V02 + * Triggers the AGPS state machine to setup AGPS call for below WWAN types: + * eQMI_LOC_WWAN_TYPE_INTERNET_V02 + * eQMI_LOC_WWAN_TYPE_AGNSS_V02 */ +bool GnssAdapter::requestATL(int connHandle, LocAGpsType agpsType){ + + LOC_LOGI("GnssAdapter::requestATL"); + + sendMsg( new AgpsMsgRequestATL( + &mAgpsManager, connHandle, (AGpsExtType)agpsType)); + + return true; +} + +/* GnssAdapter::requestSuplES + * Method triggered in QMI thread as part of handling below message: + * eQMI_LOC_SERVER_REQUEST_OPEN_V02 + * Triggers the AGPS state machine to setup AGPS call for below WWAN types: + * eQMI_LOC_WWAN_TYPE_AGNSS_EMERGENCY_V02 */ +bool GnssAdapter::requestSuplES(int connHandle){ + + LOC_LOGI("GnssAdapter::requestSuplES"); + + sendMsg( new AgpsMsgRequestATL( + &mAgpsManager, connHandle, LOC_AGPS_TYPE_SUPL_ES)); + + return true; +} + +/* GnssAdapter::releaseATL + * Method triggered in QMI thread as part of handling below message: + * eQMI_LOC_SERVER_REQUEST_CLOSE_V02 + * Triggers teardown of an existing AGPS call */ +bool GnssAdapter::releaseATL(int connHandle){ + + LOC_LOGI("GnssAdapter::releaseATL"); + + /* Release SUPL/INTERNET/SUPL_ES ATL */ + struct AgpsMsgReleaseATL: public LocMsg { + + AgpsManager* mAgpsManager; + int mConnHandle; + + inline AgpsMsgReleaseATL(AgpsManager* agpsManager, int connHandle) : + LocMsg(), mAgpsManager(agpsManager), mConnHandle(connHandle) { + + LOC_LOGV("AgpsMsgReleaseATL"); + } + + inline virtual void proc() const { + + LOC_LOGV("AgpsMsgReleaseATL::proc()"); + mAgpsManager->releaseATL(mConnHandle); + } + }; + + sendMsg( new AgpsMsgReleaseATL(&mAgpsManager, connHandle)); + + return true; +} + +/* GnssAdapter::reportDataCallOpened + * DS Client data call opened successfully. + * Send message to AGPS Manager to handle. */ +bool GnssAdapter::reportDataCallOpened(){ + + LOC_LOGI("GnssAdapter::reportDataCallOpened"); + + struct AgpsMsgSuplEsOpened: public LocMsg { + + AgpsManager* mAgpsManager; + + inline AgpsMsgSuplEsOpened(AgpsManager* agpsManager) : + LocMsg(), mAgpsManager(agpsManager) { + + LOC_LOGV("AgpsMsgSuplEsOpened"); + } + + inline virtual void proc() const { + + LOC_LOGV("AgpsMsgSuplEsOpened::proc()"); + mAgpsManager->reportDataCallOpened(); + } + }; + + sendMsg( new AgpsMsgSuplEsOpened(&mAgpsManager)); + + return true; +} + +/* GnssAdapter::reportDataCallClosed + * DS Client data call closed. + * Send message to AGPS Manager to handle. */ +bool GnssAdapter::reportDataCallClosed(){ + + LOC_LOGI("GnssAdapter::reportDataCallClosed"); + + struct AgpsMsgSuplEsClosed: public LocMsg { + + AgpsManager* mAgpsManager; + + inline AgpsMsgSuplEsClosed(AgpsManager* agpsManager) : + LocMsg(), mAgpsManager(agpsManager) { + + LOC_LOGV("AgpsMsgSuplEsClosed"); + } + + inline virtual void proc() const { + + LOC_LOGV("AgpsMsgSuplEsClosed::proc()"); + mAgpsManager->reportDataCallClosed(); + } + }; + + sendMsg( new AgpsMsgSuplEsClosed(&mAgpsManager)); + + return true; +} + +void GnssAdapter::dataConnOpenCommand( + AGpsExtType agpsType, + const char* apnName, int apnLen, AGpsBearerType bearerType){ + + LOC_LOGI("GnssAdapter::frameworkDataConnOpen"); + + struct AgpsMsgAtlOpenSuccess: public LocMsg { + + AgpsManager* mAgpsManager; + AGpsExtType mAgpsType; + char* mApnName; + int mApnLen; + AGpsBearerType mBearerType; + + inline AgpsMsgAtlOpenSuccess(AgpsManager* agpsManager, AGpsExtType agpsType, + const char* apnName, int apnLen, AGpsBearerType bearerType) : + LocMsg(), mAgpsManager(agpsManager), mAgpsType(agpsType), mApnName( + new char[apnLen + 1]), mApnLen(apnLen), mBearerType(bearerType) { + + LOC_LOGV("AgpsMsgAtlOpenSuccess"); + if (mApnName == nullptr) { + LOC_LOGE("%s] new allocation failed, fatal error.", __func__); + return; + } + memcpy(mApnName, apnName, apnLen); + mApnName[apnLen] = 0; + } + + inline ~AgpsMsgAtlOpenSuccess() { + delete[] mApnName; + } + + inline virtual void proc() const { + + LOC_LOGV("AgpsMsgAtlOpenSuccess::proc()"); + mAgpsManager->reportAtlOpenSuccess(mAgpsType, mApnName, mApnLen, mBearerType); + } + }; + + sendMsg( new AgpsMsgAtlOpenSuccess( + &mAgpsManager, agpsType, apnName, apnLen, bearerType)); +} + +void GnssAdapter::dataConnClosedCommand(AGpsExtType agpsType){ + + LOC_LOGI("GnssAdapter::frameworkDataConnClosed"); + + struct AgpsMsgAtlClosed: public LocMsg { + + AgpsManager* mAgpsManager; + AGpsExtType mAgpsType; + + inline AgpsMsgAtlClosed(AgpsManager* agpsManager, AGpsExtType agpsType) : + LocMsg(), mAgpsManager(agpsManager), mAgpsType(agpsType) { + + LOC_LOGV("AgpsMsgAtlClosed"); + } + + inline virtual void proc() const { + + LOC_LOGV("AgpsMsgAtlClosed::proc()"); + mAgpsManager->reportAtlClosed(mAgpsType); + } + }; + + sendMsg( new AgpsMsgAtlClosed(&mAgpsManager, (AGpsExtType)agpsType)); +} + +void GnssAdapter::dataConnFailedCommand(AGpsExtType agpsType){ + + LOC_LOGI("GnssAdapter::frameworkDataConnFailed"); + + struct AgpsMsgAtlOpenFailed: public LocMsg { + + AgpsManager* mAgpsManager; + AGpsExtType mAgpsType; + + inline AgpsMsgAtlOpenFailed(AgpsManager* agpsManager, AGpsExtType agpsType) : + LocMsg(), mAgpsManager(agpsManager), mAgpsType(agpsType) { + + LOC_LOGV("AgpsMsgAtlOpenFailed"); + } + + inline virtual void proc() const { + + LOC_LOGV("AgpsMsgAtlOpenFailed::proc()"); + mAgpsManager->reportAtlOpenFailed(mAgpsType); + } + }; + + sendMsg( new AgpsMsgAtlOpenFailed(&mAgpsManager, (AGpsExtType)agpsType)); +} + +void GnssAdapter::convertSatelliteInfo(std::vector& out, + const GnssSvType& in_constellation, + const SystemStatusReports& in) +{ + uint64_t sv_mask = 0ULL; + uint32_t svid_min = 0; + uint32_t svid_num = 0; + uint32_t svid_idx = 0; + + uint64_t eph_health_good_mask = 0ULL; + uint64_t eph_health_bad_mask = 0ULL; + uint64_t server_perdiction_available_mask = 0ULL; + float server_perdiction_age = 0.0f; + + // set constellationi based parameters + switch (in_constellation) { + case GNSS_SV_TYPE_GPS: + svid_min = GNSS_BUGREPORT_GPS_MIN; + svid_num = GPS_NUM; + svid_idx = 0; + if (!in.mSvHealth.empty()) { + eph_health_good_mask = in.mSvHealth.back().mGpsGoodMask; + eph_health_bad_mask = in.mSvHealth.back().mGpsBadMask; + } + if (!in.mXtra.empty()) { + server_perdiction_available_mask = in.mXtra.back().mGpsXtraValid; + server_perdiction_age = (float)(in.mXtra.back().mGpsXtraAge); + } + break; + case GNSS_SV_TYPE_GLONASS: + svid_min = GNSS_BUGREPORT_GLO_MIN; + svid_num = GLO_NUM; + svid_idx = GPS_NUM; + if (!in.mSvHealth.empty()) { + eph_health_good_mask = in.mSvHealth.back().mGloGoodMask; + eph_health_bad_mask = in.mSvHealth.back().mGloBadMask; + } + if (!in.mXtra.empty()) { + server_perdiction_available_mask = in.mXtra.back().mGloXtraValid; + server_perdiction_age = (float)(in.mXtra.back().mGloXtraAge); + } + break; + case GNSS_SV_TYPE_QZSS: + svid_min = GNSS_BUGREPORT_QZSS_MIN; + svid_num = QZSS_NUM; + svid_idx = GPS_NUM+GLO_NUM+BDS_NUM+GAL_NUM; + if (!in.mSvHealth.empty()) { + eph_health_good_mask = in.mSvHealth.back().mQzssGoodMask; + eph_health_bad_mask = in.mSvHealth.back().mQzssBadMask; + } + if (!in.mXtra.empty()) { + server_perdiction_available_mask = in.mXtra.back().mQzssXtraValid; + server_perdiction_age = (float)(in.mXtra.back().mQzssXtraAge); + } + break; + case GNSS_SV_TYPE_BEIDOU: + svid_min = GNSS_BUGREPORT_BDS_MIN; + svid_num = BDS_NUM; + svid_idx = GPS_NUM+GLO_NUM; + if (!in.mSvHealth.empty()) { + eph_health_good_mask = in.mSvHealth.back().mBdsGoodMask; + eph_health_bad_mask = in.mSvHealth.back().mBdsBadMask; + } + if (!in.mXtra.empty()) { + server_perdiction_available_mask = in.mXtra.back().mBdsXtraValid; + server_perdiction_age = (float)(in.mXtra.back().mBdsXtraAge); + } + break; + case GNSS_SV_TYPE_GALILEO: + svid_min = GNSS_BUGREPORT_GAL_MIN; + svid_num = GAL_NUM; + svid_idx = GPS_NUM+GLO_NUM+BDS_NUM; + if (!in.mSvHealth.empty()) { + eph_health_good_mask = in.mSvHealth.back().mGalGoodMask; + eph_health_bad_mask = in.mSvHealth.back().mGalBadMask; + } + if (!in.mXtra.empty()) { + server_perdiction_available_mask = in.mXtra.back().mGalXtraValid; + server_perdiction_age = (float)(in.mXtra.back().mGalXtraAge); + } + break; + default: + return; + } + + // extract each sv info from systemstatus report + for(uint32_t i=0; igetReport(reports, true); + + r.size = sizeof(r); + + // location block + r.mLocation.size = sizeof(r.mLocation); + if(!reports.mLocation.empty() && reports.mLocation.back().mValid) { + r.mLocation.mValid = true; + r.mLocation.mLocation.latitude = + reports.mLocation.back().mLocation.gpsLocation.latitude; + r.mLocation.mLocation.longitude = + reports.mLocation.back().mLocation.gpsLocation.longitude; + r.mLocation.mLocation.altitude = + reports.mLocation.back().mLocation.gpsLocation.altitude; + r.mLocation.mLocation.speed = + (double)(reports.mLocation.back().mLocation.gpsLocation.speed); + r.mLocation.mLocation.bearing = + (double)(reports.mLocation.back().mLocation.gpsLocation.bearing); + r.mLocation.mLocation.accuracy = + (double)(reports.mLocation.back().mLocation.gpsLocation.accuracy); + + r.mLocation.verticalAccuracyMeters = + reports.mLocation.back().mLocationEx.vert_unc; + r.mLocation.speedAccuracyMetersPerSecond = + reports.mLocation.back().mLocationEx.speed_unc; + r.mLocation.bearingAccuracyDegrees = + reports.mLocation.back().mLocationEx.bearing_unc; + + r.mLocation.mUtcReported = + reports.mLocation.back().mUtcReported; + } + else if(!reports.mBestPosition.empty() && reports.mBestPosition.back().mValid) { + r.mLocation.mValid = true; + r.mLocation.mLocation.latitude = + (double)(reports.mBestPosition.back().mBestLat) * RAD2DEG; + r.mLocation.mLocation.longitude = + (double)(reports.mBestPosition.back().mBestLon) * RAD2DEG; + r.mLocation.mLocation.altitude = reports.mBestPosition.back().mBestAlt; + r.mLocation.mUtcReported = reports.mBestPosition.back().mUtcReported; + } + else { + r.mLocation.mValid = false; + } + + if (r.mLocation.mValid) { + LOC_LOGV("getDebugReport - lat=%f lon=%f alt=%f speed=%f", + r.mLocation.mLocation.latitude, + r.mLocation.mLocation.longitude, + r.mLocation.mLocation.altitude, + r.mLocation.mLocation.speed); + } + + // time block + r.mTime.size = sizeof(r.mTime); + if(!reports.mTimeAndClock.empty() && reports.mTimeAndClock.back().mTimeValid) { + r.mTime.mValid = true; + r.mTime.timeEstimate = + (((int64_t)(reports.mTimeAndClock.back().mGpsWeek)*7 + + GNSS_UTC_TIME_OFFSET)*24*60*60 - + (int64_t)(reports.mTimeAndClock.back().mLeapSeconds))*1000ULL + + (int64_t)(reports.mTimeAndClock.back().mGpsTowMs); + + r.mTime.timeUncertaintyNs = + (float)((reports.mTimeAndClock.back().mTimeUnc + + reports.mTimeAndClock.back().mLeapSecUnc)*1000); + r.mTime.frequencyUncertaintyNsPerSec = + (float)(reports.mTimeAndClock.back().mClockFreqBiasUnc); + LOC_LOGV("getDebugReport - timeestimate=%" PRIu64 " unc=%f frequnc=%f", + r.mTime.timeEstimate, + r.mTime.timeUncertaintyNs, r.mTime.frequencyUncertaintyNsPerSec); + } + else { + r.mTime.mValid = false; + } + + // satellite info block + convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_GPS, reports); + convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_GLONASS, reports); + convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_QZSS, reports); + convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_BEIDOU, reports); + convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_GALILEO, reports); + LOC_LOGV("getDebugReport - satellite=%zu", r.mSatelliteInfo.size()); + + return true; +} + +/* get AGC information from system status and fill it */ +void +GnssAdapter::getAgcInformation(GnssMeasurementsNotification& measurements, int msInWeek) +{ + SystemStatus* systemstatus = getSystemStatus(); + + if (nullptr != systemstatus) { + SystemStatusReports reports = {}; + systemstatus->getReport(reports, true); + + if ((!reports.mRfAndParams.empty()) && (!reports.mTimeAndClock.empty()) && + reports.mTimeAndClock.back().mTimeValid && + (abs(msInWeek - (int)reports.mTimeAndClock.back().mGpsTowMs) < 2000)) { + + for (size_t i = 0; i < measurements.count; i++) { + switch (measurements.measurements[i].svType) { + case GNSS_SV_TYPE_GPS: + measurements.measurements[i].agcLevelDb = + reports.mRfAndParams.back().mAgcGps; + measurements.measurements[i].flags |= + GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT; + break; + + case GNSS_SV_TYPE_GALILEO: + measurements.measurements[i].agcLevelDb = + reports.mRfAndParams.back().mAgcGal; + measurements.measurements[i].flags |= + GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT; + break; + + case GNSS_SV_TYPE_GLONASS: + measurements.measurements[i].agcLevelDb = + reports.mRfAndParams.back().mAgcGlo; + measurements.measurements[i].flags |= + GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT; + break; + + case GNSS_SV_TYPE_BEIDOU: + measurements.measurements[i].agcLevelDb = + reports.mRfAndParams.back().mAgcBds; + measurements.measurements[i].flags |= + GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT; + break; + + case GNSS_SV_TYPE_QZSS: + case GNSS_SV_TYPE_SBAS: + case GNSS_SV_TYPE_UNKNOWN: + default: + break; + } + } + } + } +} + +/* Callbacks registered with loc_net_iface library */ +static void agpsOpenResultCb (bool isSuccess, AGpsExtType agpsType, const char* apn, + AGpsBearerType bearerType, void* userDataPtr) { + LOC_LOGD("%s]: ", __func__); + if (userDataPtr == nullptr) { + LOC_LOGE("%s]: userDataPtr is nullptr.", __func__); + return; + } + if (apn == nullptr) { + LOC_LOGE("%s]: apn is nullptr.", __func__); + return; + } + GnssAdapter* adapter = (GnssAdapter*)userDataPtr; + if (isSuccess) { + adapter->dataConnOpenCommand(agpsType, apn, strlen(apn), bearerType); + } else { + adapter->dataConnFailedCommand(agpsType); + } +} + +static void agpsCloseResultCb (bool isSuccess, AGpsExtType agpsType, void* userDataPtr) { + LOC_LOGD("%s]: ", __func__); + if (userDataPtr == nullptr) { + LOC_LOGE("%s]: userDataPtr is nullptr.", __func__); + return; + } + GnssAdapter* adapter = (GnssAdapter*)userDataPtr; + if (isSuccess) { + adapter->dataConnClosedCommand(agpsType); + } else { + adapter->dataConnFailedCommand(agpsType); + } +} diff --git a/gps/gnss/GnssAdapter.h b/gps/gnss/GnssAdapter.h new file mode 100644 index 0000000..e7605f9 --- /dev/null +++ b/gps/gnss/GnssAdapter.h @@ -0,0 +1,287 @@ +/* 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 GNSS_ADAPTER_H +#define GNSS_ADAPTER_H + +#include +#include +#include +#include +#include +#include +#include + +#define MAX_URL_LEN 256 +#define NMEA_SENTENCE_MAX_LENGTH 200 +#define GLONASS_SV_ID_OFFSET 64 +#define MAX_SATELLITES_IN_USE 12 +#define LOC_NI_NO_RESPONSE_TIME 20 +#define LOC_GPS_NI_RESPONSE_IGNORE 4 + +class GnssAdapter; + +typedef struct { + pthread_t thread; /* NI thread */ + uint32_t respTimeLeft; /* examine time for NI response */ + bool respRecvd; /* NI User reponse received or not from Java layer*/ + void* rawRequest; + uint32_t reqID; /* ID to check against response */ + GnssNiResponse resp; + pthread_cond_t tCond; + pthread_mutex_t tLock; + GnssAdapter* adapter; +} NiSession; +typedef struct { + NiSession session; /* SUPL NI Session */ + NiSession sessionEs; /* Emergency SUPL NI Session */ + uint32_t reqIDCounter; +} NiData; + +typedef enum { + NMEA_PROVIDER_AP = 0, // Application Processor Provider of NMEA + NMEA_PROVIDER_MP // Modem Processor Provider of NMEA +} NmeaProviderType; +typedef struct { + GnssSvType svType; + const char* talker; + uint64_t mask; + uint32_t svIdOffset; +} NmeaSvMeta; + +using namespace loc_core; + +namespace loc_core { + class SystemStatus; +} + +class GnssAdapter : public LocAdapterBase { + /* ==== ULP ============================================================================ */ + UlpProxyBase* mUlpProxy; + + /* ==== CLIENT ========================================================================= */ + typedef std::map ClientDataMap; + ClientDataMap mClientData; + + /* ==== TRACKING ======================================================================= */ + LocationSessionMap mTrackingSessions; + LocPosMode mUlpPositionMode; + GnssSvUsedInPosition mGnssSvIdUsedInPosition; + bool mGnssSvIdUsedInPosAvail; + + /* ==== CONTROL ======================================================================== */ + LocationControlCallbacks mControlCallbacks; + uint32_t mPowerVoteId; + uint32_t mNmeaMask; + + /* ==== NI ============================================================================= */ + NiData mNiData; + + /* ==== AGPS ========================================================*/ + // This must be initialized via initAgps() + AgpsManager mAgpsManager; + AgpsCbInfo mAgpsCbInfo; + + /* === SystemStatus ===================================================================== */ + SystemStatus* mSystemStatus; + std::string mServerUrl; + XtraSystemStatusObserver mXtraObserver; + + /*==== CONVERSION ===================================================================*/ + static void convertOptions(LocPosMode& out, const LocationOptions& options); + static void convertLocation(Location& out, const LocGpsLocation& locGpsLocation, + const GpsLocationExtended& locationExtended, + const LocPosTechMask techMask); + static void convertLocationInfo(GnssLocationInfoNotification& out, + const GpsLocationExtended& locationExtended); + +public: + + GnssAdapter(); + virtual inline ~GnssAdapter() { delete mUlpProxy; } + + /* ==== SSR ============================================================================ */ + /* ======== EVENTS ====(Called from QMI Thread)========================================= */ + virtual void handleEngineUpEvent(); + /* ======== UTILITIES ================================================================== */ + void restartSessions(); + + /* ==== ULP ============================================================================ */ + /* ======== COMMANDS ====(Called from ULP Thread)==================================== */ + virtual void setUlpProxyCommand(UlpProxyBase* ulp); + /* ======== UTILITIES ================================================================== */ + void setUlpProxy(UlpProxyBase* ulp); + inline UlpProxyBase* getUlpProxy() { return mUlpProxy; } + + /* ==== CLIENT ========================================================================= */ + /* ======== COMMANDS ====(Called from Client Thread)==================================== */ + void addClientCommand(LocationAPI* client, const LocationCallbacks& callbacks); + void removeClientCommand(LocationAPI* client); + void requestCapabilitiesCommand(LocationAPI* client); + /* ======== UTILITIES ================================================================== */ + void saveClient(LocationAPI* client, const LocationCallbacks& callbacks); + void eraseClient(LocationAPI* client); + void updateClientsEventMask(); + void stopClientSessions(LocationAPI* client); + LocationCallbacks getClientCallbacks(LocationAPI* client); + LocationCapabilitiesMask getCapabilities(); + void broadcastCapabilities(LocationCapabilitiesMask); + + /* ==== TRACKING ======================================================================= */ + /* ======== COMMANDS ====(Called from Client Thread)==================================== */ + uint32_t startTrackingCommand(LocationAPI* client, LocationOptions& options); + void updateTrackingOptionsCommand(LocationAPI* client, uint32_t id, LocationOptions& options); + void stopTrackingCommand(LocationAPI* client, uint32_t id); + /* ======================(Called from ULP Thread)======================================= */ + virtual void setPositionModeCommand(LocPosMode& locPosMode); + virtual void startTrackingCommand(); + virtual void stopTrackingCommand(); + virtual void getZppCommand(); + /* ======== RESPONSES ================================================================== */ + void reportResponse(LocationAPI* client, LocationError err, uint32_t sessionId); + /* ======== UTILITIES ================================================================== */ + bool hasTrackingCallback(LocationAPI* client); + bool hasMeasurementsCallback(LocationAPI* client); + bool isTrackingSession(LocationAPI* client, uint32_t sessionId); + void saveTrackingSession(LocationAPI* client, uint32_t sessionId, + const LocationOptions& options); + void eraseTrackingSession(LocationAPI* client, uint32_t sessionId); + bool setUlpPositionMode(const LocPosMode& mode); + LocPosMode& getUlpPositionMode() { return mUlpPositionMode; } + LocationError startTrackingMultiplex(const LocationOptions& options); + LocationError startTracking(const LocationOptions& options); + LocationError stopTrackingMultiplex(LocationAPI* client, uint32_t id); + LocationError stopTracking(); + LocationError updateTrackingMultiplex(LocationAPI* client, uint32_t id, + const LocationOptions& options); + + /* ==== NI ============================================================================= */ + /* ======== COMMANDS ====(Called from Client Thread)==================================== */ + void gnssNiResponseCommand(LocationAPI* client, uint32_t id, GnssNiResponse response); + /* ======================(Called from NI Thread)======================================== */ + void gnssNiResponseCommand(GnssNiResponse response, void* rawRequest); + /* ======== UTILITIES ================================================================== */ + bool hasNiNotifyCallback(LocationAPI* client); + NiData& getNiData() { return mNiData; } + + /* ==== CONTROL ======================================================================== */ + /* ======== COMMANDS ====(Called from Client Thread)==================================== */ + uint32_t enableCommand(LocationTechnologyType techType); + void disableCommand(uint32_t id); + void setControlCallbacksCommand(LocationControlCallbacks& controlCallbacks); + void readConfigCommand(); + void setConfigCommand(); + uint32_t* gnssUpdateConfigCommand(GnssConfig config); + uint32_t gnssDeleteAidingDataCommand(GnssAidingData& data); + + void initDefaultAgpsCommand(); + void initAgpsCommand(const AgpsCbInfo& cbInfo); + void dataConnOpenCommand(AGpsExtType agpsType, + const char* apnName, int apnLen, AGpsBearerType bearerType); + void dataConnClosedCommand(AGpsExtType agpsType); + void dataConnFailedCommand(AGpsExtType agpsType); + + /* ======== RESPONSES ================================================================== */ + void reportResponse(LocationError err, uint32_t sessionId); + void reportResponse(size_t count, LocationError* errs, uint32_t* ids); + /* ======== UTILITIES ================================================================== */ + LocationControlCallbacks& getControlCallbacks() { return mControlCallbacks; } + void setControlCallbacks(const LocationControlCallbacks& controlCallbacks) + { mControlCallbacks = controlCallbacks; } + void setPowerVoteId(uint32_t id) { mPowerVoteId = id; } + uint32_t getPowerVoteId() { return mPowerVoteId; } + bool resolveInAddress(const char* hostAddress, struct in_addr* inAddress); + virtual bool isInSession() { return !mTrackingSessions.empty(); } + void initDefaultAgps(); + + /* ==== REPORTS ======================================================================== */ + /* ======== EVENTS ====(Called from QMI/ULP Thread)===================================== */ + virtual void reportPositionEvent(const UlpLocation& ulpLocation, + const GpsLocationExtended& locationExtended, + enum loc_sess_status status, + LocPosTechMask techMask, + bool fromUlp=false); + virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp=false); + virtual void reportNmeaEvent(const char* nmea, size_t length, bool fromUlp=false); + virtual bool requestNiNotifyEvent(const GnssNiNotification& notify, const void* data); + virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurements, + int msInWeek); + virtual void reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet); + virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial); + + virtual bool requestATL(int connHandle, LocAGpsType agps_type); + virtual bool releaseATL(int connHandle); + virtual bool requestSuplES(int connHandle); + virtual bool reportDataCallOpened(); + virtual bool reportDataCallClosed(); + + /* ======== UTILITIES ================================================================= */ + void reportPosition(const UlpLocation &ulpLocation, + const GpsLocationExtended &locationExtended, + enum loc_sess_status status, + LocPosTechMask techMask); + void reportSv(GnssSvNotification& svNotify); + void reportNmea(const char* nmea, size_t length); + bool requestNiNotify(const GnssNiNotification& notify, const void* data); + void reportGnssMeasurementData(const GnssMeasurementsNotification& measurements); + + /*======== GNSSDEBUG ================================================================*/ + bool getDebugReport(GnssDebugReport& report); + /* get AGC information from system status and fill it */ + void getAgcInformation(GnssMeasurementsNotification& measurements, int msInWeek); + + /*==== SYSTEM STATUS ================================================================*/ + inline SystemStatus* getSystemStatus(void) { return mSystemStatus; } + std::string& getServerUrl(void) { return mServerUrl; } + void setServerUrl(const char* server) { mServerUrl.assign(server); } + + /*==== CONVERSION ===================================================================*/ + static uint32_t convertGpsLock(const GnssConfigGpsLock gpsLock); + static GnssConfigGpsLock convertGpsLock(const uint32_t gpsLock); + static uint32_t convertSuplVersion(const GnssConfigSuplVersion suplVersion); + static GnssConfigSuplVersion convertSuplVersion(const uint32_t suplVersion); + static uint32_t convertLppProfile(const GnssConfigLppProfile lppProfile); + static GnssConfigLppProfile convertLppProfile(const uint32_t lppProfile); + static uint32_t convertEP4ES(const GnssConfigEmergencyPdnForEmergencySupl); + static uint32_t convertSuplEs(const GnssConfigSuplEmergencyServices suplEmergencyServices); + static uint32_t convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlaneMask); + static GnssConfigLppeControlPlaneMask convertLppeCp(const uint32_t lppeControlPlaneMask); + static uint32_t convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask); + static GnssConfigLppeUserPlaneMask convertLppeUp(const uint32_t lppeUserPlaneMask); + static uint32_t convertAGloProt(const GnssConfigAGlonassPositionProtocolMask); + static uint32_t convertSuplMode(const GnssConfigSuplModeMask suplModeMask); + static void convertSatelliteInfo(std::vector& out, + const GnssSvType& in_constellation, + const SystemStatusReports& in); + + void injectLocationCommand(double latitude, double longitude, float accuracy); + void injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty); + +}; + +#endif //GNSS_ADAPTER_H diff --git a/gps/gnss/Makefile.am b/gps/gnss/Makefile.am new file mode 100644 index 0000000..3afdcd7 --- /dev/null +++ b/gps/gnss/Makefile.am @@ -0,0 +1,99 @@ +AM_CFLAGS = \ + $(LOCPLA_CFLAGS) \ + $(LOCHAL_CFLAGS) \ + -I./ \ + -I../utils \ + -I../core \ + -I../location \ + -std=c++11 + +libgnss_la_SOURCES = \ + location_gnss.cpp \ + GnssAdapter.cpp \ + Agps.cpp + +if USE_GLIB +libgnss_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ +libgnss_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -avoid-version +libgnss_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ +else +libgnss_la_CFLAGS = $(AM_CFLAGS) +libgnss_la_LDFLAGS = -lpthread -shared -version-info 1:0:0 +libgnss_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) +endif + +libgnss_la_LIBADD = -lstdc++ $(LOCPLA_LIBS) $(LOCHAL_LIBS) + + +#Create and Install libraries +#lib_LTLIBRARIES = libgnss.la + +#library_includedir = $(pkgincludedir) +#pkgconfigdir = $(libdir)/pkgconfig +#pkgconfig_DATA = location-api.pc +#EXTRA_DIST = $(pkgconfig_DATA) + + +libloc_ds_api_CFLAGS = \ + $(QMIF_CFLAGS) \ + $(QMI_CFLAGS) \ + $(DATA_CFLAGS) \ + $(GPSUTILS_CFLAGS) \ + -I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api + +libloc_ds_api_la_SOURCES = \ + $(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.c + +if USE_GLIB +libloc_ds_api_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) @GLIB_CFLAGS@ +libloc_ds_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 +libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic +libloc_ds_api_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ +else +libloc_ds_api_la_CFLAGS = $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) +libloc_ds_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -Wl,--export-dynamic -shared -version-info 1:0:0 +libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic +libloc_ds_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_ds_api_CFLAGS) +endif + +libloc_ds_api_la_LIBADD = -lstdc++ $(QMIF_LIBS) -lqmiservices -ldsi_netctrl $(GPSUTILS_LIBS) $(LOCPLA_LIBS) + +libloc_api_v02_CFLAGS = \ + $(QMIF_CFLAGS) \ + $(GPSUTILS_CFLAGS) \ + -I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api \ + -I$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02 + +libloc_api_v02_la_SOURCES = \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.cpp \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.c \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.c \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.c \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.c + +if USE_GLIB +libloc_api_v02_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) @GLIB_CFLAGS@ +libloc_api_v02_la_LDFLAGS = -lstdc++ -g -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 +libloc_api_v02_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ +else +libloc_api_v02_la_CFLAGS = $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) +libloc_api_v02_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -shared -version-info 1:0:0 +libloc_api_v02_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_api_v02_CFLAGS) +endif + +libloc_api_v02_la_CXXFLAGS = -std=c++0x +libloc_api_v02_la_LIBADD = -lstdc++ -lqmi_cci -lqmi_common_so $(QMIF_LIBS) $(GPSUTILS_LIBS) $(LOCPLA_LIBS) ../core/libloc_core.la libloc_ds_api.la + +library_include_HEADERS = \ + $(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.h \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.h \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.h \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.h \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.h \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.h \ + $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_util_log.h + +library_includedir = $(pkgincludedir) + +#Create and Install libraries +lib_LTLIBRARIES = libgnss.la libloc_ds_api.la libloc_api_v02.la diff --git a/gps/gnss/XtraSystemStatusObserver.cpp b/gps/gnss/XtraSystemStatusObserver.cpp new file mode 100644 index 0000000..ce08f64 --- /dev/null +++ b/gps/gnss/XtraSystemStatusObserver.cpp @@ -0,0 +1,234 @@ +/* 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_XtraSystemStatusObs" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace loc_core; + +#define XTRA_HAL_SOCKET_NAME "/data/vendor/location/xtra/socket_hal_xtra" + +bool XtraSystemStatusObserver::updateLockStatus(uint32_t lock) { + stringstream ss; + ss << "gpslock"; + ss << " " << lock; + ss << "\n"; // append seperator + return ( sendEvent(ss) ); +} + +bool XtraSystemStatusObserver::updateConnectionStatus(bool connected, uint32_t type) { + stringstream ss; + ss << "connection"; + ss << " " << (connected ? "1" : "0"); + ss << " " << (int)type; + ss << "\n"; // append seperator + return ( sendEvent(ss) ); +} +bool XtraSystemStatusObserver::updateTac(const string& tac) { + stringstream ss; + ss << "tac"; + ss << " " << tac.c_str(); + ss << "\n"; // append seperator + return ( sendEvent(ss) ); +} + +bool XtraSystemStatusObserver::updateMccMnc(const string& mccmnc) { + stringstream ss; + ss << "mncmcc"; + ss << " " << mccmnc.c_str(); + ss << "\n"; // append seperator + return ( sendEvent(ss) ); +} + +bool XtraSystemStatusObserver::sendEvent(const stringstream& event) { + int socketFd = createSocket(); + if (socketFd < 0) { + LOC_LOGe("XTRA unreachable. sending failed."); + return false; + } + + const string& data = event.str(); + int remain = data.length(); + ssize_t sent = 0; + while (remain > 0 && + (sent = ::send(socketFd, data.c_str() + (data.length() - remain), + remain, MSG_NOSIGNAL)) > 0) { + remain -= sent; + } + + if (sent < 0) { + LOC_LOGe("sending error. reason:%s", strerror(errno)); + } + + closeSocket(socketFd); + + return (remain == 0); +} + + +int XtraSystemStatusObserver::createSocket() { + int socketFd = -1; + + if ((socketFd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { + LOC_LOGe("create socket error. reason:%s", strerror(errno)); + + } else { + const char* socketPath = XTRA_HAL_SOCKET_NAME ; + struct sockaddr_un addr = { .sun_family = AF_UNIX }; + snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socketPath); + + if (::connect(socketFd, (struct sockaddr*)&addr, sizeof(addr)) < 0) { + LOC_LOGe("cannot connect to XTRA. reason:%s", strerror(errno)); + if (::close(socketFd)) { + LOC_LOGe("close socket error. reason:%s", strerror(errno)); + } + socketFd = -1; + } + } + + return socketFd; +} + +void XtraSystemStatusObserver::closeSocket(const int socketFd) { + if (socketFd >= 0) { + if(::close(socketFd)) { + LOC_LOGe("close socket error. reason:%s", strerror(errno)); + } + } +} + +void XtraSystemStatusObserver::subscribe(bool yes) +{ + // Subscription data list + list subItemIdList; + subItemIdList.push_back(NETWORKINFO_DATA_ITEM_ID); + subItemIdList.push_back(MCCMNC_DATA_ITEM_ID); + + if (yes) { + mSystemStatusObsrvr->subscribe(subItemIdList, this); + + list reqItemIdList; + reqItemIdList.push_back(TAC_DATA_ITEM_ID); + + mSystemStatusObsrvr->requestData(reqItemIdList, this); + + } else { + mSystemStatusObsrvr->unsubscribe(subItemIdList, this); + } +} + +// IDataItemObserver overrides +void XtraSystemStatusObserver::getName(string& name) +{ + name = "XtraSystemStatusObserver"; +} + +void XtraSystemStatusObserver::notify(const list& dlist) +{ + struct handleOsObserverUpdateMsg : public LocMsg { + XtraSystemStatusObserver* mXtraSysStatObj; + list mDataItemList; + + inline handleOsObserverUpdateMsg(XtraSystemStatusObserver* xtraSysStatObs, + const list& dataItemList) : + mXtraSysStatObj(xtraSysStatObs) { + for (auto eachItem : dataItemList) { + IDataItemCore* dataitem = DataItemsFactoryProxy::createNewDataItem( + eachItem->getId()); + if (NULL == dataitem) { + break; + } + // Copy the contents of the data item + dataitem->copy(eachItem); + + mDataItemList.push_back(dataitem); + } + } + + inline ~handleOsObserverUpdateMsg() { + for (auto each : mDataItemList) { + delete each; + } + } + + inline void proc() const { + for (auto each : mDataItemList) { + switch (each->getId()) + { + case NETWORKINFO_DATA_ITEM_ID: + { + SystemStatusNetworkInfo* networkInfo = + reinterpret_cast(each); + mXtraSysStatObj->updateConnectionStatus(networkInfo->mConnected, + networkInfo->mType); + } + break; + + case TAC_DATA_ITEM_ID: + { + SystemStatusTac* tac = reinterpret_cast(each); + mXtraSysStatObj->updateTac(tac->mValue); + } + break; + + case MCCMNC_DATA_ITEM_ID: + { + SystemStatusMccMnc* mccmnc = reinterpret_cast(each); + mXtraSysStatObj->updateMccMnc(mccmnc->mValue); + } + break; + + default: + break; + } + } + } + }; + mMsgTask->sendMsg(new (nothrow) handleOsObserverUpdateMsg(this, dlist)); +} + + diff --git a/gps/gnss/XtraSystemStatusObserver.h b/gps/gnss/XtraSystemStatusObserver.h new file mode 100644 index 0000000..42f49b5 --- /dev/null +++ b/gps/gnss/XtraSystemStatusObserver.h @@ -0,0 +1,71 @@ +/* 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 XTRA_SYSTEM_STATUS_OBS_H +#define XTRA_SYSTEM_STATUS_OBS_H + +#include +#include + +using namespace std; +using loc_core::IOsObserver; +using loc_core::IDataItemObserver; +using loc_core::IDataItemCore; + + +class XtraSystemStatusObserver : public IDataItemObserver { +public : + // constructor & destructor + inline XtraSystemStatusObserver(IOsObserver* sysStatObs, const MsgTask* msgTask): + mSystemStatusObsrvr(sysStatObs), mMsgTask(msgTask) { + subscribe(true); + } + inline XtraSystemStatusObserver() {}; + inline virtual ~XtraSystemStatusObserver() { subscribe(false); } + + // IDataItemObserver overrides + inline virtual void getName(string& name); + virtual void notify(const list& dlist); + + bool updateLockStatus(uint32_t lock); + bool updateConnectionStatus(bool connected, uint32_t type); + bool updateTac(const string& tac); + bool updateMccMnc(const string& mccmnc); + inline const MsgTask* getMsgTask() { return mMsgTask; } + void subscribe(bool yes); + +private: + int createSocket(); + void closeSocket(const int32_t socketFd); + bool sendEvent(const stringstream& event); + IOsObserver* mSystemStatusObsrvr; + const MsgTask* mMsgTask; + +}; + +#endif diff --git a/gps/gnss/location_gnss.cpp b/gps/gnss/location_gnss.cpp new file mode 100644 index 0000000..b5623e1 --- /dev/null +++ b/gps/gnss/location_gnss.cpp @@ -0,0 +1,258 @@ +/* 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. + * + */ + +#include "GnssAdapter.h" +#include "location_interface.h" + +static GnssAdapter* gGnssAdapter = NULL; + +static void initialize(); +static void deinitialize(); + +static void addClient(LocationAPI* client, const LocationCallbacks& callbacks); +static void removeClient(LocationAPI* client); +static void requestCapabilities(LocationAPI* client); + +static uint32_t startTracking(LocationAPI* client, LocationOptions& options); +static void updateTrackingOptions(LocationAPI* client, uint32_t id, LocationOptions& options); +static void stopTracking(LocationAPI* client, uint32_t id); + +static void gnssNiResponse(LocationAPI* client, uint32_t id, GnssNiResponse response); +static uint32_t gnssDeleteAidingData(GnssAidingData& data); + +static void setControlCallbacks(LocationControlCallbacks& controlCallbacks); +static uint32_t enable(LocationTechnologyType techType); +static void disable(uint32_t id); +static uint32_t* gnssUpdateConfig(GnssConfig config); + +static void injectLocation(double latitude, double longitude, float accuracy); +static void injectTime(int64_t time, int64_t timeReference, int32_t uncertainty); + +static void agpsInit(const AgpsCbInfo& cbInfo); +static void agpsDataConnOpen(AGpsExtType agpsType, const char* apnName, int apnLen, int ipType); +static void agpsDataConnClosed(AGpsExtType agpsType); +static void agpsDataConnFailed(AGpsExtType agpsType); +static void getDebugReport(GnssDebugReport& report); +static void updateConnectionStatus(bool connected, uint8_t type); + +static const GnssInterface gGnssInterface = { + sizeof(GnssInterface), + initialize, + deinitialize, + addClient, + removeClient, + requestCapabilities, + startTracking, + updateTrackingOptions, + stopTracking, + gnssNiResponse, + setControlCallbacks, + enable, + disable, + gnssUpdateConfig, + gnssDeleteAidingData, + injectLocation, + injectTime, + agpsInit, + agpsDataConnOpen, + agpsDataConnClosed, + agpsDataConnFailed, + getDebugReport, + updateConnectionStatus, +}; + +#ifndef DEBUG_X86 +extern "C" const GnssInterface* getGnssInterface() +#else +const GnssInterface* getGnssInterface() +#endif // DEBUG_X86 +{ + return &gGnssInterface; +} + +static void initialize() +{ + if (NULL == gGnssAdapter) { + gGnssAdapter = new GnssAdapter(); + } +} + +static void deinitialize() +{ + if (NULL != gGnssAdapter) { + delete gGnssAdapter; + gGnssAdapter = NULL; + } +} + +static void addClient(LocationAPI* client, const LocationCallbacks& callbacks) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->addClientCommand(client, callbacks); + } +} + +static void removeClient(LocationAPI* client) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->removeClientCommand(client); + } +} + +static void requestCapabilities(LocationAPI* client) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->requestCapabilitiesCommand(client); + } +} + +static uint32_t startTracking(LocationAPI* client, LocationOptions& options) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->startTrackingCommand(client, options); + } else { + return 0; + } +} + +static void updateTrackingOptions(LocationAPI* client, uint32_t id, LocationOptions& options) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->updateTrackingOptionsCommand(client, id, options); + } +} + +static void stopTracking(LocationAPI* client, uint32_t id) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->stopTrackingCommand(client, id); + } +} + +static void gnssNiResponse(LocationAPI* client, uint32_t id, GnssNiResponse response) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->gnssNiResponseCommand(client, id, response); + } +} + +static void setControlCallbacks(LocationControlCallbacks& controlCallbacks) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->setControlCallbacksCommand(controlCallbacks); + } +} + +static uint32_t enable(LocationTechnologyType techType) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->enableCommand(techType); + } else { + return 0; + } +} + +static void disable(uint32_t id) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->disableCommand(id); + } +} + +static uint32_t* gnssUpdateConfig(GnssConfig config) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->gnssUpdateConfigCommand(config); + } else { + return NULL; + } +} + +static uint32_t gnssDeleteAidingData(GnssAidingData& data) +{ + if (NULL != gGnssAdapter) { + return gGnssAdapter->gnssDeleteAidingDataCommand(data); + } else { + return 0; + } +} + +static void injectLocation(double latitude, double longitude, float accuracy) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->injectLocationCommand(latitude, longitude, accuracy); + } +} + +static void injectTime(int64_t time, int64_t timeReference, int32_t uncertainty) +{ + if (NULL != gGnssAdapter) { + gGnssAdapter->injectTimeCommand(time, timeReference, uncertainty); + } +} + +static void agpsInit(const AgpsCbInfo& cbInfo) { + + if (NULL != gGnssAdapter) { + gGnssAdapter->initAgpsCommand(cbInfo); + } +} +static void agpsDataConnOpen( + AGpsExtType agpsType, const char* apnName, int apnLen, int ipType) { + + if (NULL != gGnssAdapter) { + gGnssAdapter->dataConnOpenCommand( + agpsType, apnName, apnLen, (AGpsBearerType)ipType); + } +} +static void agpsDataConnClosed(AGpsExtType agpsType) { + + if (NULL != gGnssAdapter) { + gGnssAdapter->dataConnClosedCommand(agpsType); + } +} +static void agpsDataConnFailed(AGpsExtType agpsType) { + + if (NULL != gGnssAdapter) { + gGnssAdapter->dataConnFailedCommand(agpsType); + } +} + +static void getDebugReport(GnssDebugReport& report) { + + if (NULL != gGnssAdapter) { + gGnssAdapter->getDebugReport(report); + } +} + +static void updateConnectionStatus(bool connected, uint8_t type) { + if (NULL != gGnssAdapter) { + gGnssAdapter->getSystemStatus()->eventConnectionStatus(connected, type); + } +} diff --git a/gps/gnsspps/Android.mk b/gps/gnsspps/Android.mk deleted file mode 100644 index 70005ff..0000000 --- a/gps/gnsspps/Android.mk +++ /dev/null @@ -1,32 +0,0 @@ -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_MODULE := libgnsspps - -LOCAL_MODULE_TAGS := optional - -LOCAL_SHARED_LIBRARIES := \ - libutils \ - libcutils \ - libgps.utils \ - liblog - -LOCAL_SRC_FILES += \ - gnsspps.c - -LOCAL_CFLAGS += \ - -fno-short-enums \ - -D_ANDROID_ - -LOCAL_COPY_HEADERS_TO:= libgnsspps/ - -LOCAL_COPY_HEADERS:= \ - gnsspps.h - -## Includes -LOCAL_C_INCLUDES := \ - $(TARGET_OUT_HEADERS)/gps.utils \ - $(TARGET_OUT_HEADERS)/libloc_pla - -include $(BUILD_SHARED_LIBRARY) diff --git a/gps/gnsspps/gnsspps.c b/gps/gnsspps/gnsspps.c deleted file mode 100644 index f92a862..0000000 --- a/gps/gnsspps/gnsspps.c +++ /dev/null @@ -1,194 +0,0 @@ -/* Copyright (c) 2011-2015, 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 Foundatoin, 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. - */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -//DRsync kernel timestamp -static struct timespec drsyncKernelTs = {0,0}; -//DRsync userspace timestamp -static struct timespec drsyncUserTs = {0,0}; -//flag to stop fetching timestamp -static int isActive = 0; -static pps_handle handle; - -static pthread_mutex_t ts_lock; - - /* checks the PPS source and opens it */ -int check_device(char *path, pps_handle *handle) -{ - int ret; - - /* Try to find the source by using the supplied "path" name */ - ret = open(path, O_RDWR); - if (ret < 0) - { - LOC_LOGV("%s:%d unable to open device %s", __func__, __LINE__, path); - return ret; - } - - /* Open the PPS source */ - ret = pps_create(ret, handle); - if (ret < 0) - { - LOC_LOGV( "%s:%d cannot create a PPS source from device %s", __func__, __LINE__, path); - return -1; - } - return 0; -} - -/* fetches the timestamp from the PPS source */ -int read_pps(pps_handle *handle) -{ - struct timespec timeout; - pps_info infobuf; - int ret; - // 3sec timeout - timeout.tv_sec = 3; - timeout.tv_nsec = 0; - - ret = pps_fetch(*handle, PPS_TSFMT_TSPEC, &infobuf,&timeout); - - if (ret < 0 && ret !=-EINTR) - { - LOC_LOGV("%s:%d pps_fetch() error %d", __func__, __LINE__, ret); - return -1; - } - - pthread_mutex_lock(&ts_lock); - drsyncKernelTs.tv_sec = infobuf.tv_sec; - drsyncKernelTs.tv_nsec = infobuf.tv_nsec; - ret = clock_gettime(CLOCK_BOOTTIME,&drsyncUserTs); - pthread_mutex_unlock(&ts_lock); - - if(ret != 0) - { - LOC_LOGV("%s:%d clock_gettime() error",__func__,__LINE__); - } - return 0; -} - -#ifdef __cplusplus -extern "C" { -#endif -/* infinitely calls read_pps() */ -void *thread_handle(void *input) -{ - int ret; - if(input != NULL) - { - LOC_LOGV("%s:%d Thread Input is present", __func__, __LINE__); - } - while(isActive) - { - ret = read_pps(&handle); - - if (ret == -1 && errno != ETIMEDOUT ) - { - LOC_LOGV("%s:%d Could not fetch PPS source", __func__, __LINE__); - } - } - return NULL; -} - -/* opens the device and fetches from PPS source */ -int initPPS(char *devname) -{ - int ret,pid; - pthread_t thread; - isActive = 1; - - ret = check_device(devname, &handle); - if (ret < 0) - { - LOC_LOGV("%s:%d Could not find PPS source", __func__, __LINE__); - return 0; - } - - pthread_mutex_init(&ts_lock,NULL); - - pid = pthread_create(&thread,NULL,&thread_handle,NULL); - if(pid != 0) - { - LOC_LOGV("%s:%d Could not create thread in InitPPS", __func__, __LINE__); - return 0; - } - return 1; -} - -/* stops fetching and closes the device */ -void deInitPPS() -{ - pthread_mutex_lock(&ts_lock); - isActive = 0; - pthread_mutex_unlock(&ts_lock); - - pthread_mutex_destroy(&ts_lock); - pps_destroy(handle); -} - -/* retrieves DRsync kernel timestamp,DRsync userspace timestamp - and updates current timestamp */ -/* Returns: - * 1. @Param out DRsync kernel timestamp - * 2. @Param out DRsync userspace timestamp - * 3. @Param out current timestamp - */ -int getPPS(struct timespec *fineKernelTs ,struct timespec *currentTs, - struct timespec *fineUserTs) -{ - int ret; - - pthread_mutex_lock(&ts_lock); - fineKernelTs->tv_sec = drsyncKernelTs.tv_sec; - fineKernelTs->tv_nsec = drsyncKernelTs.tv_nsec; - - fineUserTs->tv_sec = drsyncUserTs.tv_sec; - fineUserTs->tv_nsec = drsyncUserTs.tv_nsec; - - ret = clock_gettime(CLOCK_BOOTTIME,currentTs); - pthread_mutex_unlock(&ts_lock); - if(ret != 0) - { - LOC_LOGV("%s:%d clock_gettime() error",__func__,__LINE__); - return 0; - } - return 1; -} - -#ifdef __cplusplus -} -#endif - diff --git a/gps/gnsspps/timepps.h b/gps/gnsspps/timepps.h deleted file mode 100644 index fe0d8f0..0000000 --- a/gps/gnsspps/timepps.h +++ /dev/null @@ -1,106 +0,0 @@ -/* Copyright (c) 2011-2015, 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 Foundatoin, 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. - */ -#include -#include -#include -#include -#include - -#ifndef _TIMEPPS_H -#define _TIMEPPS_H - -#ifdef __cplusplus -extern "C" { -#endif -/* time of assert event */ -typedef struct timespec pps_info; -/* represents pps source */ -typedef int pps_handle; - - /* Open the PPS source */ -static __inline int pps_create(int source, pps_handle *handle) -{ - int ret; - struct pps_kparams dummy; - - if (!handle) - { - errno = EINVAL; - return -1; - } - /* check if current device is valid pps */ - ret = ioctl(source, PPS_GETPARAMS, &dummy); - if (ret) - { - errno = EOPNOTSUPP; - return -1; - } - *handle = source; - - return 0; -} -/* close the pps source */ -static __inline int pps_destroy(pps_handle handle) -{ - return close(handle); -} -/*reads timestamp from pps device*/ -static __inline int pps_fetch(pps_handle handle, const int tsformat, - pps_info *ppsinfobuf, - const struct timespec *timeout) -{ - struct pps_fdata fdata; - int ret; - - if (tsformat != PPS_TSFMT_TSPEC) - { - errno = EINVAL; - return -1; - } - if (timeout) - { - fdata.timeout.sec = timeout->tv_sec; - fdata.timeout.nsec = timeout->tv_nsec; - fdata.timeout.flags = ~PPS_TIME_INVALID; - } - else - { - fdata.timeout.flags = PPS_TIME_INVALID; - } - ret = ioctl(handle, PPS_FETCH, &fdata); - - ppsinfobuf->tv_sec = fdata.info.assert_tu.sec; - ppsinfobuf->tv_nsec = fdata.info.assert_tu.nsec; - - return ret; -} - -#ifdef __cplusplus -} -#endif -#endif diff --git a/gps/loc-hal.pc.in b/gps/loc-hal.pc.in new file mode 100644 index 0000000..64750db --- /dev/null +++ b/gps/loc-hal.pc.in @@ -0,0 +1,10 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: loc-hal +Description: QTI GPS Loc HAL +Version: @VERSION +Libs: -L${libdir} -lloc_core -llocation_api -lgnss -lloc_ds_api -lloc_api_v02 +Cflags: -I${includedir} -I${includedir}/loc-hal -I${includedir}/loc-hal/location -I${includedir}/loc-hal/gnss -I${includedir}/loc-hal/core diff --git a/gps/loc_api/Android.mk b/gps/loc_api/Android.mk deleted file mode 100644 index 7a16792..0000000 --- a/gps/loc_api/Android.mk +++ /dev/null @@ -1,3 +0,0 @@ -LOCAL_PATH := $(call my-dir) - -include $(call all-makefiles-under,$(LOCAL_PATH)) diff --git a/gps/loc_api/libloc_api_50001/Android.mk b/gps/loc_api/libloc_api_50001/Android.mk deleted file mode 100644 index d8652d1..0000000 --- a/gps/loc_api/libloc_api_50001/Android.mk +++ /dev/null @@ -1,111 +0,0 @@ -ifneq ($(BUILD_TINY_ANDROID),true) -#Compile this library only for builds with the latest modem image - -LOCAL_PATH := $(call my-dir) - -include $(CLEAR_VARS) - -LOCAL_MODULE := libloc_eng -LOCAL_MODULE_OWNER := qcom - -LOCAL_MODULE_TAGS := optional - -LOCAL_SHARED_LIBRARIES := \ - libutils \ - libcutils \ - libdl \ - liblog \ - libloc_core \ - libgps.utils \ - libloc_pla - -LOCAL_SRC_FILES += \ - loc_eng.cpp \ - loc_eng_agps.cpp \ - loc_eng_xtra.cpp \ - loc_eng_ni.cpp \ - loc_eng_log.cpp \ - loc_eng_nmea.cpp \ - LocEngAdapter.cpp - -LOCAL_SRC_FILES += \ - loc_eng_dmn_conn.cpp \ - loc_eng_dmn_conn_handler.cpp \ - loc_eng_dmn_conn_thread_helper.c \ - loc_eng_dmn_conn_glue_msg.c \ - loc_eng_dmn_conn_glue_pipe.c - -LOCAL_CFLAGS += \ - -fno-short-enums \ - -D_ANDROID_ - -LOCAL_C_INCLUDES:= \ - $(LOCAL_PATH) \ - $(TARGET_OUT_HEADERS)/gps.utils \ - $(TARGET_OUT_HEADERS)/libloc_core \ - $(TARGET_OUT_HEADERS)/libflp \ - $(TARGET_OUT_HEADERS)/libloc_pla - -LOCAL_COPY_HEADERS_TO:= libloc_eng/ -LOCAL_COPY_HEADERS:= \ - LocEngAdapter.h \ - loc.h \ - loc_eng.h \ - loc_eng_xtra.h \ - loc_eng_ni.h \ - loc_eng_agps.h \ - loc_eng_msg.h \ - loc_eng_log.h - -LOCAL_PRELINK_MODULE := false - -include $(BUILD_SHARED_LIBRARY) - -include $(CLEAR_VARS) - -LOCAL_MODULE := gps.$(TARGET_BOARD_PLATFORM) -LOCAL_MODULE_OWNER := qcom - -LOCAL_MODULE_TAGS := optional - -## Libs - -LOCAL_SHARED_LIBRARIES := \ - libutils \ - libcutils \ - liblog \ - libloc_eng \ - libloc_core \ - libgps.utils \ - libdl \ - libloc_pla - -LOCAL_SRC_FILES += \ - loc.cpp \ - gps.c - -LOCAL_CFLAGS += \ - -fno-short-enums \ - -D_ANDROID_ \ - -ifeq ($(TARGET_BUILD_VARIANT),user) - LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER -endif - -ifeq ($(TARGET_USES_QCOM_BSP), true) -LOCAL_CFLAGS += -DTARGET_USES_QCOM_BSP -endif - -## Includes -LOCAL_C_INCLUDES:= \ - $(TARGET_OUT_HEADERS)/gps.utils \ - $(TARGET_OUT_HEADERS)/libloc_core \ - $(TARGET_OUT_HEADERS)/libflp \ - $(TARGET_OUT_HEADERS)/libloc_pla - -LOCAL_PRELINK_MODULE := false -LOCAL_MODULE_RELATIVE_PATH := hw - -include $(BUILD_SHARED_LIBRARY) - -endif # not BUILD_TINY_ANDROID diff --git a/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp b/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp deleted file mode 100644 index 2d9eeac..0000000 --- a/gps/loc_api/libloc_api_50001/LocEngAdapter.cpp +++ /dev/null @@ -1,598 +0,0 @@ -/* Copyright (c) 2011-2015, 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_EngAdapter" - -#include -#include -#include -#include -#include -#include "loc_eng_msg.h" -#include "loc_log.h" - -#define CHIPSET_SERIAL_NUMBER_MAX_LEN 16 -#define USER_AGENT_MAX_LEN 512 - -using namespace loc_core; - -LocInternalAdapter::LocInternalAdapter(LocEngAdapter* adapter) : - LocAdapterBase(adapter->getMsgTask()), - mLocEngAdapter(adapter) -{ -} -void LocInternalAdapter::setPositionModeInt(LocPosMode& posMode) { - sendMsg(new LocEngPositionMode(mLocEngAdapter, posMode)); -} -void LocInternalAdapter::startFixInt() { - sendMsg(new LocEngStartFix(mLocEngAdapter)); -} -void LocInternalAdapter::stopFixInt() { - sendMsg(new LocEngStopFix(mLocEngAdapter)); -} -void LocInternalAdapter::getZppInt() { - sendMsg(new LocEngGetZpp(mLocEngAdapter)); -} - -LocEngAdapter::LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask, - void* owner, ContextBase* context, - LocThread::tCreate tCreator) : - LocAdapterBase(mask, - //Get the AFW context if VzW context has not already been intialized in - //loc_ext - context == NULL? - LocDualContext::getLocFgContext(tCreator, - NULL, - LocDualContext::mLocationHalName, - false) - :context), - mOwner(owner), mInternalAdapter(new LocInternalAdapter(this)), - mUlp(new UlpProxyBase()), mNavigating(false), - mSupportsAgpsRequests(false), - mSupportsPositionInjection(false), - mSupportsTimeInjection(false), - mPowerVote(0) -{ - memset(&mFixCriteria, 0, sizeof(mFixCriteria)); - mFixCriteria.mode = LOC_POSITION_MODE_INVALID; - LOC_LOGD("LocEngAdapter created"); -} - -inline -LocEngAdapter::~LocEngAdapter() -{ - delete mInternalAdapter; - LOC_LOGV("LocEngAdapter deleted"); -} - -void LocEngAdapter::setXtraUserAgent() { - struct LocSetXtraUserAgent : public LocMsg { - const ContextBase* const mContext; - inline LocSetXtraUserAgent(ContextBase* context) : - LocMsg(), mContext(context) { - } - virtual void proc() const { - char release[PROPERTY_VALUE_MAX]; - char manufacture[PROPERTY_VALUE_MAX]; - char model[PROPERTY_VALUE_MAX]; - char board[PROPERTY_VALUE_MAX]; - char brand[PROPERTY_VALUE_MAX]; - char chipsetsn[CHIPSET_SERIAL_NUMBER_MAX_LEN]; - char userAgent[USER_AGENT_MAX_LEN]; - const char defVal[] = "-"; - - property_get("ro.build.version.release", release, defVal); - property_get("ro.product.manufacturer", manufacture, defVal); - property_get("ro.product.model", model, defVal); - property_get("ro.product.board", board, defVal); - property_get("ro.product.brand", brand, defVal); - getChipsetSerialNo(chipsetsn, sizeof(chipsetsn), defVal); - - encodeInPlace(release, PROPERTY_VALUE_MAX); - encodeInPlace(manufacture, PROPERTY_VALUE_MAX); - encodeInPlace(model, PROPERTY_VALUE_MAX); - encodeInPlace(board, PROPERTY_VALUE_MAX); - encodeInPlace(brand, PROPERTY_VALUE_MAX); - - snprintf(userAgent, sizeof(userAgent), "A/%s/%s/%s/%s/-/QCX3/s%u/-/%s/-/%s/-/-/-", - release, manufacture, model, board, - mContext->getIzatDevId(), chipsetsn, brand); - - for (int i = 0; i < sizeof(userAgent) && userAgent[i]; i++) { - if (' ' == userAgent[i]) userAgent[i] = '#'; - } - - saveUserAgentString(userAgent, strlen(userAgent)); - LOC_LOGV("%s] UserAgent %s", __func__, userAgent); - } - - void saveUserAgentString(const char* data, const int len) const { - const char XTRA_FOLDER[] = "/data/misc/location/xtra"; - const char USER_AGENT_FILE[] = "/data/misc/location/xtra/useragent.txt"; - - if (data == NULL || len < 1) { - LOC_LOGE("%s:%d]: invalid input data = %p len = %d", __func__, __LINE__, data, len); - return; - } - - struct stat s; - int err = stat(XTRA_FOLDER, &s); - if (err < 0) { - if (ENOENT == errno) { - if (mkdir(XTRA_FOLDER, 0700) < 0) { - LOC_LOGE("%s:%d]: make XTRA_FOLDER failed", __func__, __LINE__); - return; - } - } else { - LOC_LOGE("%s:%d]: XTRA_FOLDER invalid", __func__, __LINE__); - return; - } - } - - FILE* file = fopen(USER_AGENT_FILE, "wt"); - if (file == NULL) { - LOC_LOGE("%s:%d]: open USER_AGENT_FILE failed", __func__, __LINE__); - return; - } - - size_t written = fwrite(data, 1, len, file); - fclose(file); - file = NULL; - - // set file permission - chmod(USER_AGENT_FILE, 0600); - - if (written != len) { - LOC_LOGE("%s:%d]: write USER_AGENT_FILE failed", __func__, __LINE__); - } - } - - void getChipsetSerialNo(char buf[], int buflen, const char def[]) const { - const char SOC_SERIAL_NUMBER[] = "/sys/devices/soc0/serial_number"; - - FILE* file = fopen(SOC_SERIAL_NUMBER, "rt"); - if (file == NULL) { - // use default upon unreadable file - strlcpy(buf, def, buflen); - - } else { - size_t size = fread(buf, 1, buflen - 1, file); - if (size == 0) { - // use default upon empty file - strlcpy(buf, def, buflen); - - } else { - buf[size] = '\0'; - } - - fclose(file); - - // remove trailing spaces - size_t len = strlen(buf); - while (--len >= 0 && isspace(buf[len])) { - buf[len] = '\0'; - } - } - - return; - } - - /** - * encode the given string value such that all separator characters ('/','+','|','%') - * in the string are repaced by their corresponding encodings (%2F","%2B","%7C", "%25") - */ - static void encodeInPlace(char value[], const int size) { - char buffer[size]; - - struct ENCODE { - const char ch; - const char *code; - }; - - const ENCODE encodings[] = { {'/', "%2F"}, {'+', "%2B"}, {'|', "%7C",}, {'%', "%25"} }; - const int nencodings = (int)sizeof(encodings) / sizeof(encodings[0]); - - int inpos = 0, outpos = 0; - while(value[inpos] != '\0' && outpos < size - 1) { - // check if escaped character - int escchar = 0; - while(escchar < nencodings && encodings[escchar].ch != value[inpos]) { - escchar++; - } - - if (escchar == nencodings) { - // non escaped character - buffer[outpos++] = value[inpos++]; - continue; - } - - // escaped character - int codepos = 0; - #define NUM_CHARS_IN_CODE 3 - - if (outpos + NUM_CHARS_IN_CODE >= size) { - // skip last character if there is insufficient space - break; - } - - while(outpos < size - 1 && codepos < NUM_CHARS_IN_CODE) { - buffer[outpos++] = encodings[escchar].code[codepos++]; - } - inpos++; - } - - // copy to ouput - value[outpos] = '\0'; - while(--outpos >= 0) { - value[outpos] = buffer[outpos]; - } - } - }; - - sendMsg(new LocSetXtraUserAgent(mContext)); -} - -void LocInternalAdapter::setUlpProxy(UlpProxyBase* ulp) { - struct LocSetUlpProxy : public LocMsg { - LocAdapterBase* mAdapter; - UlpProxyBase* mUlp; - inline LocSetUlpProxy(LocAdapterBase* adapter, UlpProxyBase* ulp) : - LocMsg(), mAdapter(adapter), mUlp(ulp) { - } - virtual void proc() const { - LOC_LOGV("%s] ulp %p adapter %p", __func__, - mUlp, mAdapter); - mAdapter->setUlpProxy(mUlp); - } - }; - - sendMsg(new LocSetUlpProxy(mLocEngAdapter, ulp)); -} - -void LocEngAdapter::setUlpProxy(UlpProxyBase* ulp) -{ - if (ulp == mUlp) { - //This takes care of the case when double initalization happens - //and we get the same object back for UlpProxyBase . Do nothing - return; - } - - LOC_LOGV("%s] %p", __func__, ulp); - if (NULL == ulp) { - LOC_LOGE("%s:%d]: ulp pointer is NULL", __func__, __LINE__); - ulp = new UlpProxyBase(); - } - - if (LOC_POSITION_MODE_INVALID != mUlp->mPosMode.mode) { - // need to send this mode and start msg to ULP - ulp->sendFixMode(mUlp->mPosMode); - } - - if(mUlp->mFixSet) { - ulp->sendStartFix(); - } - - delete mUlp; - mUlp = ulp; -} - -int LocEngAdapter::setGpsLockMsg(LOC_GPS_LOCK_MASK lockMask) -{ - struct LocEngAdapterGpsLock : public LocMsg { - LocEngAdapter* mAdapter; - LOC_GPS_LOCK_MASK mLockMask; - inline LocEngAdapterGpsLock(LocEngAdapter* adapter, LOC_GPS_LOCK_MASK lockMask) : - LocMsg(), mAdapter(adapter), mLockMask(lockMask) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setGpsLock(mLockMask); - } - inline void locallog() const { - LOC_LOGV("LocEngAdapterGpsLock - mLockMask: %x", mLockMask); - } - inline virtual void log() const { - locallog(); - } - }; - sendMsg(new LocEngAdapterGpsLock(this, lockMask)); - return 0; -} - -void LocEngAdapter::requestPowerVote() -{ - if (getPowerVoteRight()) { - /* Power voting without engine lock: - * 101: vote down, 102-104 - vote up - * These codes are used not to confuse with actual engine lock - * functionality, that can't be used in SSR scenario, as it - * conflicts with initialization sequence. - */ - bool powerUp = getPowerVote(); - LOC_LOGV("LocEngAdapterVotePower - Vote Power: %d", (int)powerUp); - setGpsLock(powerUp ? 103 : 101); - } -} - -void LocInternalAdapter::reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask) -{ - sendMsg(new LocEngReportPosition(mLocEngAdapter, - location, - locationExtended, - locationExt, - status, - loc_technology_mask)); -} - - -void LocEngAdapter::reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask) -{ - if (! mUlp->reportPosition(location, - locationExtended, - locationExt, - status, - loc_technology_mask )) { - mInternalAdapter->reportPosition(location, - locationExtended, - locationExt, - status, - loc_technology_mask); - } -} - -void LocInternalAdapter::reportSv(GnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt){ - sendMsg(new LocEngReportSv(mLocEngAdapter, svStatus, - locationExtended, svExt)); -} - -void LocEngAdapter::reportSv(GnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt) -{ - - // We want to send SV info to ULP to help it in determining GNSS - // signal strength ULP will forward the SV reports to HAL without - // any modifications - if (! mUlp->reportSv(svStatus, locationExtended, svExt)) { - mInternalAdapter->reportSv(svStatus, locationExtended, svExt); - } -} - - -void LocEngAdapter::reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet) -{ - // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary. - if (! mUlp->reportSvMeasurement(svMeasurementSet)) { - //Send to Internal Adapter later if needed by LA - } -} - -void LocEngAdapter::reportSvPolynomial(GnssSvPolynomial &svPolynomial) -{ - // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary. - if (! mUlp->reportSvPolynomial(svPolynomial)) { - //Send to Internal Adapter later if needed by LA - } -} - -void LocEngAdapter::setInSession(bool inSession) -{ - mNavigating = inSession; - mLocApi->setInSession(inSession); - if (!mNavigating) { - mFixCriteria.mode = LOC_POSITION_MODE_INVALID; - } -} - -void LocInternalAdapter::reportStatus(GpsStatusValue status) -{ - sendMsg(new LocEngReportStatus(mLocEngAdapter, status)); -} - -void LocEngAdapter::reportStatus(GpsStatusValue status) -{ - if (!mUlp->reportStatus(status)) { - mInternalAdapter->reportStatus(status); - } -} - -inline -void LocEngAdapter::reportNmea(const char* nmea, int length) -{ - sendMsg(new LocEngReportNmea(mOwner, nmea, length)); -} - -inline -bool LocEngAdapter::reportXtraServer(const char* url1, - const char* url2, - const char* url3, - const int maxlength) -{ - if (mSupportsAgpsRequests) { - sendMsg(new LocEngReportXtraServer(mOwner, url1, - url2, url3, maxlength)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::requestATL(int connHandle, AGpsType agps_type) -{ - if (mSupportsAgpsRequests) { - sendMsg(new LocEngRequestATL(mOwner, - connHandle, agps_type)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::releaseATL(int connHandle) -{ - if (mSupportsAgpsRequests) { - sendMsg(new LocEngReleaseATL(mOwner, connHandle)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::requestXtraData() -{ - if (mSupportsAgpsRequests) { - sendMsg(new LocEngRequestXtra(mOwner)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::requestTime() -{ - if (mSupportsAgpsRequests) { - sendMsg(new LocEngRequestTime(mOwner)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::requestNiNotify(GpsNiNotification ¬if, const void* data) -{ - if (mSupportsAgpsRequests) { - notif.size = sizeof(notif); - notif.timeout = LOC_NI_NO_RESPONSE_TIME; - - sendMsg(new LocEngRequestNi(mOwner, notif, data)); - } - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::requestSuplES(int connHandle) -{ - if (mSupportsAgpsRequests) - sendMsg(new LocEngRequestSuplEs(mOwner, connHandle)); - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::reportDataCallOpened() -{ - if(mSupportsAgpsRequests) - sendMsg(new LocEngSuplEsOpened(mOwner)); - return mSupportsAgpsRequests; -} - -inline -bool LocEngAdapter::reportDataCallClosed() -{ - if(mSupportsAgpsRequests) - sendMsg(new LocEngSuplEsClosed(mOwner)); - return mSupportsAgpsRequests; -} - -inline -void LocEngAdapter::handleEngineDownEvent() -{ - sendMsg(new LocEngDown(mOwner)); -} - -inline -void LocEngAdapter::handleEngineUpEvent() -{ - sendMsg(new LocEngUp(mOwner)); -} - -enum loc_api_adapter_err LocEngAdapter::setTime(GpsUtcTime time, - int64_t timeReference, - int uncertainty) -{ - loc_api_adapter_err result = LOC_API_ADAPTER_ERR_SUCCESS; - - LOC_LOGD("%s:%d]: mSupportsTimeInjection is %d", - __func__, __LINE__, mSupportsTimeInjection); - - if (mSupportsTimeInjection) { - LOC_LOGD("%s:%d]: Injecting time", __func__, __LINE__); - result = mLocApi->setTime(time, timeReference, uncertainty); - } - - return result; -} - -enum loc_api_adapter_err LocEngAdapter::setXtraVersionCheck(int check) -{ - enum loc_api_adapter_err ret; - ENTRY_LOG(); - enum xtra_version_check eCheck; - switch (check) { - case 0: - eCheck = DISABLED; - break; - case 1: - eCheck = AUTO; - break; - case 2: - eCheck = XTRA2; - break; - case 3: - eCheck = XTRA3; - break; - default: - eCheck = DISABLED; - } - ret = mLocApi->setXtraVersionCheck(eCheck); - EXIT_LOG(%d, ret); - return ret; -} - -void LocEngAdapter::reportGnssMeasurementData(GnssData &gnssMeasurementData) -{ - sendMsg(new LocEngReportGnssMeasurement(mOwner, - gnssMeasurementData)); -} - -/* - Set Gnss Constellation Config - */ -bool LocEngAdapter::gnssConstellationConfig() -{ - LOC_LOGD("entering %s", __func__); - bool result = false; - result = mLocApi->gnssConstellationConfig(); - return result; -} diff --git a/gps/loc_api/libloc_api_50001/LocEngAdapter.h b/gps/loc_api/libloc_api_50001/LocEngAdapter.h deleted file mode 100644 index 416e4b7..0000000 --- a/gps/loc_api/libloc_api_50001/LocEngAdapter.h +++ /dev/null @@ -1,355 +0,0 @@ -/* Copyright (c) 2011-2016, 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 LOC_API_ENG_ADAPTER_H -#define LOC_API_ENG_ADAPTER_H - -#include -#include -#include -#include -#include -#include -#include -#include - -#define MAX_URL_LEN 256 - -using namespace loc_core; - -class LocEngAdapter; - -class LocInternalAdapter : public LocAdapterBase { - LocEngAdapter* mLocEngAdapter; -public: - LocInternalAdapter(LocEngAdapter* adapter); - - virtual void reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask); - virtual void reportSv(GnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt); - virtual void reportStatus(GpsStatusValue status); - virtual void setPositionModeInt(LocPosMode& posMode); - virtual void startFixInt(); - virtual void stopFixInt(); - virtual void getZppInt(); - virtual void setUlpProxy(UlpProxyBase* ulp); -}; - -typedef void (*loc_msg_sender)(void* loc_eng_data_p, void* msgp); - -class LocEngAdapter : public LocAdapterBase { - void* mOwner; - LocInternalAdapter* mInternalAdapter; - UlpProxyBase* mUlp; - LocPosMode mFixCriteria; - bool mNavigating; - // mPowerVote is encoded as - // mPowerVote & 0x20 -- powerVoteRight - // mPowerVote & 0x10 -- power On / Off - unsigned int mPowerVote; - static const unsigned int POWER_VOTE_RIGHT = 0x20; - static const unsigned int POWER_VOTE_VALUE = 0x10; - -public: - bool mSupportsAgpsRequests; - bool mSupportsPositionInjection; - bool mSupportsTimeInjection; - GnssSystemInfo mGnssInfo; - - LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask, - void* owner, ContextBase* context, - LocThread::tCreate tCreator); - virtual ~LocEngAdapter(); - - virtual void setUlpProxy(UlpProxyBase* ulp); - void setXtraUserAgent(); - inline void requestUlp(unsigned long capabilities) { - mContext->requestUlp(mInternalAdapter, capabilities); - } - inline LocInternalAdapter* getInternalAdapter() { return mInternalAdapter; } - inline UlpProxyBase* getUlpProxy() { return mUlp; } - inline void* getOwner() { return mOwner; } - inline bool hasAgpsExtendedCapabilities() { - return mContext->hasAgpsExtendedCapabilities(); - } - inline bool hasCPIExtendedCapabilities() { - return mContext->hasCPIExtendedCapabilities(); - } - inline bool hasNativeXtraClient() { - return mContext->hasNativeXtraClient(); - } - inline const MsgTask* getMsgTask() { return mMsgTask; } - - inline enum loc_api_adapter_err - startFix() - { - return mLocApi->startFix(mFixCriteria); - } - inline enum loc_api_adapter_err - stopFix() - { - return mLocApi->stopFix(); - } - inline enum loc_api_adapter_err - deleteAidingData(GpsAidingData f) - { - return mLocApi->deleteAidingData(f); - } - inline enum loc_api_adapter_err - enableData(int enable) - { - return mLocApi->enableData(enable); - } - inline enum loc_api_adapter_err - setAPN(char* apn, int len) - { - return mLocApi->setAPN(apn, len); - } - inline enum loc_api_adapter_err - injectPosition(double latitude, double longitude, float accuracy) - { - return mLocApi->injectPosition(latitude, longitude, accuracy); - } - inline enum loc_api_adapter_err - setXtraData(char* data, int length) - { - return mLocApi->setXtraData(data, length); - } - inline enum loc_api_adapter_err - requestXtraServer() - { - return mLocApi->requestXtraServer(); - } - inline enum loc_api_adapter_err - atlOpenStatus(int handle, int is_succ, char* apn, AGpsBearerType bearer, AGpsType agpsType) - { - return mLocApi->atlOpenStatus(handle, is_succ, apn, bearer, agpsType); - } - inline enum loc_api_adapter_err - atlCloseStatus(int handle, int is_succ) - { - return mLocApi->atlCloseStatus(handle, is_succ); - } - inline enum loc_api_adapter_err - setPositionMode(const LocPosMode *posMode) - { - if (NULL != posMode) { - mFixCriteria = *posMode; - } - return mLocApi->setPositionMode(mFixCriteria); - } - inline enum loc_api_adapter_err - setServer(const char* url, int len) - { - return mLocApi->setServer(url, len); - } - inline enum loc_api_adapter_err - setServer(unsigned int ip, int port, - LocServerType type) - { - return mLocApi->setServer(ip, port, type); - } - inline enum loc_api_adapter_err - informNiResponse(GpsUserResponseType userResponse, const void* passThroughData) - { - return mLocApi->informNiResponse(userResponse, passThroughData); - } - inline enum loc_api_adapter_err - setSUPLVersion(uint32_t version) - { - return mLocApi->setSUPLVersion(version); - } - inline enum loc_api_adapter_err - setNMEATypes (uint32_t typesMask) - { - return mLocApi->setNMEATypes(typesMask); - } - inline enum loc_api_adapter_err - setLPPConfig(uint32_t profile) - { - return mLocApi->setLPPConfig(profile); - } - inline enum loc_api_adapter_err - setSensorControlConfig(int sensorUsage, int sensorProvider) - { - return mLocApi->setSensorControlConfig(sensorUsage, sensorProvider); - } - inline enum loc_api_adapter_err - setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk, - bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk, - bool angleBiasVarianceRandomWalk_valid, float angleBiasVarianceRandomWalk, - bool rateBiasVarianceRandomWalk_valid, float rateBiasVarianceRandomWalk, - bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk) - { - return mLocApi->setSensorProperties(gyroBiasVarianceRandomWalk_valid, gyroBiasVarianceRandomWalk, - accelBiasVarianceRandomWalk_valid, accelBiasVarianceRandomWalk, - angleBiasVarianceRandomWalk_valid, angleBiasVarianceRandomWalk, - rateBiasVarianceRandomWalk_valid, rateBiasVarianceRandomWalk, - velocityBiasVarianceRandomWalk_valid, velocityBiasVarianceRandomWalk); - } - inline virtual enum loc_api_adapter_err - setSensorPerfControlConfig(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec, - int gyroSamplesPerBatch, int gyroBatchesPerSec, - int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh, - int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig) - { - return mLocApi->setSensorPerfControlConfig(controlMode, accelSamplesPerBatch, accelBatchesPerSec, - gyroSamplesPerBatch, gyroBatchesPerSec, - accelSamplesPerBatchHigh, accelBatchesPerSecHigh, - gyroSamplesPerBatchHigh, gyroBatchesPerSecHigh, - algorithmConfig); - } - inline virtual enum loc_api_adapter_err - setAGLONASSProtocol(unsigned long aGlonassProtocol) - { - return mLocApi->setAGLONASSProtocol(aGlonassProtocol); - } - inline virtual enum loc_api_adapter_err - setLPPeProtocol(unsigned long lppeCP, unsigned long lppeUP) - { - return mLocApi->setLPPeProtocol(lppeCP, lppeUP); - } - inline virtual int initDataServiceClient() - { - return mLocApi->initDataServiceClient(); - } - inline virtual int openAndStartDataCall() - { - return mLocApi->openAndStartDataCall(); - } - inline virtual void stopDataCall() - { - mLocApi->stopDataCall(); - } - inline virtual void closeDataCall() - { - mLocApi->closeDataCall(); - } - inline enum loc_api_adapter_err - getZpp(GpsLocation &zppLoc, LocPosTechMask &tech_mask) - { - return mLocApi->getBestAvailableZppFix(zppLoc, tech_mask); - } - enum loc_api_adapter_err setTime(GpsUtcTime time, - int64_t timeReference, - int uncertainty); - enum loc_api_adapter_err setXtraVersionCheck(int check); - inline virtual void installAGpsCert(const DerEncodedCertificate* pData, - size_t length, - uint32_t slotBitMask) - { - mLocApi->installAGpsCert(pData, length, slotBitMask); - } - virtual void handleEngineDownEvent(); - virtual void handleEngineUpEvent(); - virtual void reportPosition(UlpLocation &location, - GpsLocationExtended &locationExtended, - void* locationExt, - enum loc_sess_status status, - LocPosTechMask loc_technology_mask); - virtual void reportSv(GnssSvStatus &svStatus, - GpsLocationExtended &locationExtended, - void* svExt); - virtual void reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet); - virtual void reportSvPolynomial(GnssSvPolynomial &svPolynomial); - virtual void reportStatus(GpsStatusValue status); - virtual void reportNmea(const char* nmea, int length); - virtual bool reportXtraServer(const char* url1, const char* url2, - const char* url3, const int maxlength); - virtual bool requestXtraData(); - virtual bool requestTime(); - virtual bool requestATL(int connHandle, AGpsType agps_type); - virtual bool releaseATL(int connHandle); - virtual bool requestNiNotify(GpsNiNotification ¬ify, const void* data); - virtual bool requestSuplES(int connHandle); - virtual bool reportDataCallOpened(); - virtual bool reportDataCallClosed(); - virtual void reportGnssMeasurementData(GnssData &gnssMeasurementData); - - inline const LocPosMode& getPositionMode() const - {return mFixCriteria;} - inline virtual bool isInSession() - { return mNavigating; } - void setInSession(bool inSession); - - // Permit/prohibit power voting - inline void setPowerVoteRight(bool powerVoteRight) { - mPowerVote = powerVoteRight ? (mPowerVote | POWER_VOTE_RIGHT) : - (mPowerVote & ~POWER_VOTE_RIGHT); - } - inline bool getPowerVoteRight() const { - return (mPowerVote & POWER_VOTE_RIGHT) != 0 ; - } - // Set the power voting up/down and do actual operation if permitted - inline void setPowerVote(bool powerOn) { - mPowerVote = powerOn ? (mPowerVote | POWER_VOTE_VALUE) : - (mPowerVote & ~POWER_VOTE_VALUE); - requestPowerVote(); - mContext->modemPowerVote(powerOn); - } - inline bool getPowerVote() const { - return (mPowerVote & POWER_VOTE_VALUE) != 0 ; - } - // Do power voting according to last settings if permitted - void requestPowerVote(); - - /*Values for lock - 1 = Do not lock any position sessions - 2 = Lock MI position sessions - 3 = Lock MT position sessions - 4 = Lock all position sessions - */ - inline int setGpsLock(LOC_GPS_LOCK_MASK lock) - { - return mLocApi->setGpsLock(lock); - } - - int setGpsLockMsg(LOC_GPS_LOCK_MASK lock); - - /* - Returns - Current value of GPS lock on success - -1 on failure - */ - inline int getGpsLock() - { - return mLocApi->getGpsLock(); - } - - /* - Set Gnss Constellation Config - */ - bool gnssConstellationConfig(); -}; - -#endif //LOC_API_ENG_ADAPTER_H diff --git a/gps/loc_api/libloc_api_50001/gps.c b/gps/loc_api/libloc_api_50001/gps.c deleted file mode 100644 index 29f20f4..0000000 --- a/gps/loc_api/libloc_api_50001/gps.c +++ /dev/null @@ -1,73 +0,0 @@ -/* Copyright (c) 2011,2015 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. - * - */ - -#include - -#include -#include - -extern const GpsInterface* get_gps_interface(); - -const GpsInterface* gps__get_gps_interface(struct gps_device_t* dev) -{ - return get_gps_interface(); -} - -static int open_gps(const struct hw_module_t* module, char const* name, - struct hw_device_t** device) -{ - struct gps_device_t *dev = (struct gps_device_t *) malloc(sizeof(struct gps_device_t)); - - if(dev == NULL) - return -1; - - memset(dev, 0, sizeof(*dev)); - - dev->common.tag = HARDWARE_DEVICE_TAG; - dev->common.version = 0; - dev->common.module = (struct hw_module_t*)module; - dev->get_gps_interface = gps__get_gps_interface; - - *device = (struct hw_device_t*)dev; - return 0; -} - -static struct hw_module_methods_t gps_module_methods = { - .open = open_gps -}; - -struct hw_module_t HAL_MODULE_INFO_SYM = { - .tag = HARDWARE_MODULE_TAG, - .module_api_version = 1, - .hal_api_version = 0, - .id = GPS_HARDWARE_MODULE_ID, - .name = "loc_api GPS Module", - .author = "Qualcomm USA, Inc.", - .methods = &gps_module_methods, -}; diff --git a/gps/loc_api/libloc_api_50001/loc.cpp b/gps/loc_api/libloc_api_50001/loc.cpp deleted file mode 100644 index 222d5da..0000000 --- a/gps/loc_api/libloc_api_50001/loc.cpp +++ /dev/null @@ -1,1120 +0,0 @@ -/* Copyright (c) 2011-2016, 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_afw" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -using namespace loc_core; - -#define LOC_PM_CLIENT_NAME "GPS" - -//Globals defns -static gps_location_callback gps_loc_cb = NULL; -static gps_sv_status_callback gps_sv_cb = NULL; -static gps_ni_notify_callback gps_ni_cb = NULL; - -static void local_loc_cb(UlpLocation* location, void* locExt); -static void local_sv_cb(GpsSvStatus* sv_status, void* svExt); -static void local_ni_cb(GpsNiNotification *notification, bool esEnalbed); - -GpsNiExtCallbacks sGpsNiExtCallbacks = { - local_ni_cb -}; - -static const GpsGeofencingInterface* get_geofence_interface(void); - -// Function declarations for sLocEngInterface -static int loc_init(GpsCallbacks* callbacks); -static int loc_start(); -static int loc_stop(); -static void loc_cleanup(); -static int loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty); -static int loc_inject_location(double latitude, double longitude, float accuracy); -static void loc_delete_aiding_data(GpsAidingData f); -static int loc_set_position_mode(GpsPositionMode mode, GpsPositionRecurrence recurrence, - uint32_t min_interval, uint32_t preferred_accuracy, - uint32_t preferred_time); -static const void* loc_get_extension(const char* name); -// Defines the GpsInterface in gps.h -static const GpsInterface sLocEngInterface = -{ - sizeof(GpsInterface), - loc_init, - loc_start, - loc_stop, - loc_cleanup, - loc_inject_time, - loc_inject_location, - loc_delete_aiding_data, - loc_set_position_mode, - loc_get_extension -}; - -// Function declarations for sLocEngAGpsInterface -static void loc_agps_init(AGpsCallbacks* callbacks); -static int loc_agps_open(const char* apn); -static int loc_agps_closed(); -static int loc_agps_open_failed(); -static int loc_agps_set_server(AGpsType type, const char *hostname, int port); -static int loc_agps_open_with_apniptype( const char* apn, ApnIpType apnIpType); - -static const AGpsInterface sLocEngAGpsInterface = -{ - sizeof(AGpsInterface), - loc_agps_init, - loc_agps_open, - loc_agps_closed, - loc_agps_open_failed, - loc_agps_set_server, - loc_agps_open_with_apniptype -}; - -static int loc_xtra_init(GpsXtraCallbacks* callbacks); -static int loc_xtra_inject_data(char* data, int length); - -static const GpsXtraInterface sLocEngXTRAInterface = -{ - sizeof(GpsXtraInterface), - loc_xtra_init, - loc_xtra_inject_data -}; - -static void loc_ni_init(GpsNiCallbacks *callbacks); -static void loc_ni_respond(int notif_id, GpsUserResponseType user_response); - -static const GpsNiInterface sLocEngNiInterface = -{ - sizeof(GpsNiInterface), - loc_ni_init, - loc_ni_respond, -}; - -static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks); -static void loc_gps_measurement_close(); - -static const GpsMeasurementInterface sLocEngGpsMeasurementInterface = -{ - sizeof(GpsMeasurementInterface), - loc_gps_measurement_init, - loc_gps_measurement_close -}; - -static void loc_agps_ril_init( AGpsRilCallbacks* callbacks ); -static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct); -static void loc_agps_ril_set_set_id(AGpsSetIDType type, const char* setid); -static void loc_agps_ril_ni_message(uint8_t *msg, size_t len); -static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info); -static void loc_agps_ril_update_network_availability(int avaiable, const char* apn); - -static const AGpsRilInterface sLocEngAGpsRilInterface = -{ - sizeof(AGpsRilInterface), - loc_agps_ril_init, - loc_agps_ril_set_ref_location, - loc_agps_ril_set_set_id, - loc_agps_ril_ni_message, - loc_agps_ril_update_network_state, - loc_agps_ril_update_network_availability -}; - -static int loc_agps_install_certificates(const DerEncodedCertificate* certificates, - size_t length); -static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints, - size_t length); - -static const SuplCertificateInterface sLocEngAGpsCertInterface = -{ - sizeof(SuplCertificateInterface), - loc_agps_install_certificates, - loc_agps_revoke_certificates -}; - -static void loc_configuration_update(const char* config_data, int32_t length); - -static const GnssConfigurationInterface sLocEngConfigInterface = -{ - sizeof(GnssConfigurationInterface), - loc_configuration_update -}; - -static loc_eng_data_s_type loc_afw_data; -static int gss_fd = -1; -static int sGnssType = GNSS_UNKNOWN; -/*=========================================================================== -FUNCTION gps_get_hardware_interface - -DESCRIPTION - Returns the GPS hardware interaface based on LOC API - if GPS is enabled. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -extern "C" const GpsInterface* gps_get_hardware_interface () -{ - ENTRY_LOG_CALLFLOW(); - const GpsInterface* ret_val; - - char propBuf[PROPERTY_VALUE_MAX]; - memset(propBuf, 0, sizeof(propBuf)); - - loc_eng_read_config(); - - // check to see if GPS should be disabled - platform_lib_abstraction_property_get("gps.disable", propBuf, ""); - if (propBuf[0] == '1') - { - LOC_LOGD("gps_get_interface returning NULL because gps.disable=1\n"); - ret_val = NULL; - } else { - ret_val = &sLocEngInterface; - } - - loc_eng_read_config(); - - EXIT_LOG(%p, ret_val); - return ret_val; -} - -// for gps.c -extern "C" const GpsInterface* get_gps_interface() -{ - unsigned int target = TARGET_DEFAULT; - loc_eng_read_config(); - - target = loc_get_target(); - LOC_LOGD("Target name check returned %s", loc_get_target_name(target)); - - sGnssType = getTargetGnssType(target); - switch (sGnssType) - { - case GNSS_GSS: - case GNSS_AUTO: - //APQ8064 - gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB); - gss_fd = open("/dev/gss", O_RDONLY); - if (gss_fd < 0) { - LOC_LOGE("GSS open failed: %s\n", strerror(errno)); - } - else { - LOC_LOGD("GSS open success! CAPABILITIES %0lx\n", - gps_conf.CAPABILITIES); - } - break; - case GNSS_NONE: - //MPQ8064 - LOC_LOGE("No GPS HW on this target. Not returning interface."); - return NULL; - case GNSS_QCA1530: - // qca1530 chip is present - gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB); - LOC_LOGD("qca1530 present: CAPABILITIES %0lx\n", gps_conf.CAPABILITIES); - break; - } - return &sLocEngInterface; -} - -/*=========================================================================== -FUNCTION loc_init - -DESCRIPTION - Initialize the location engine, this include setting up global datas - and registers location engien with loc api service. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/Ax - -===========================================================================*/ -static int loc_init(GpsCallbacks* callbacks) -{ - int retVal = -1; - unsigned int target = (unsigned int) -1; - ENTRY_LOG(); - LOC_API_ADAPTER_EVENT_MASK_T event; - - if (NULL == callbacks) { - LOC_LOGE("loc_init failed. cb = NULL\n"); - EXIT_LOG(%d, retVal); - return retVal; - } - - event = LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT | - LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT | - LOC_API_ADAPTER_BIT_SATELLITE_REPORT | - LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST | - LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST | - LOC_API_ADAPTER_BIT_IOCTL_REPORT | - LOC_API_ADAPTER_BIT_STATUS_REPORT | - LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT | - LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST; - - target = loc_get_target(); - - /* If platform is "auto" and external dr enabled then enable - ** Measurement report and SV Polynomial report - */ - if((1 == gps_conf.EXTERNAL_DR_ENABLED)) - { - event |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT_REPORT | - LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT; - } - - LocCallbacks clientCallbacks = {local_loc_cb, /* location_cb */ - callbacks->status_cb, /* status_cb */ - local_sv_cb, /* sv_status_cb */ - callbacks->nmea_cb, /* nmea_cb */ - callbacks->set_capabilities_cb, /* set_capabilities_cb */ - callbacks->acquire_wakelock_cb, /* acquire_wakelock_cb */ - callbacks->release_wakelock_cb, /* release_wakelock_cb */ - callbacks->create_thread_cb, /* create_thread_cb */ - NULL, /* location_ext_parser */ - NULL, /* sv_ext_parser */ - callbacks->request_utc_time_cb, /* request_utc_time_cb */ - callbacks->set_system_info_cb, /* set_system_info_cb */ - callbacks->gnss_sv_status_cb, /* gnss_sv_status_cb */ - }; - - gps_loc_cb = callbacks->location_cb; - gps_sv_cb = callbacks->sv_status_cb; - - retVal = loc_eng_init(loc_afw_data, &clientCallbacks, event, NULL); - loc_afw_data.adapter->mSupportsAgpsRequests = !loc_afw_data.adapter->hasAgpsExtendedCapabilities(); - loc_afw_data.adapter->mSupportsPositionInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities(); - loc_afw_data.adapter->mSupportsTimeInjection = !loc_afw_data.adapter->hasCPIExtendedCapabilities() - && !loc_afw_data.adapter->hasNativeXtraClient(); - loc_afw_data.adapter->setGpsLockMsg(0); - loc_afw_data.adapter->requestUlp(ContextBase::getCarrierCapabilities()); - loc_afw_data.adapter->setXtraUserAgent(); - - if(retVal) { - LOC_LOGE("loc_eng_init() fail!"); - goto err; - } - - loc_afw_data.adapter->setPowerVoteRight(loc_get_target() == TARGET_QCA1530); - loc_afw_data.adapter->setPowerVote(true); - - LOC_LOGD("loc_eng_init() success!"); - -err: - EXIT_LOG(%d, retVal); - return retVal; -} - -/*=========================================================================== -FUNCTION loc_cleanup - -DESCRIPTION - Cleans location engine. The location client handle will be released. - -DEPENDENCIES - None - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_cleanup() -{ - ENTRY_LOG(); - - loc_afw_data.adapter->setPowerVote(false); - loc_afw_data.adapter->setGpsLockMsg(gps_conf.GPS_LOCK); - - loc_eng_cleanup(loc_afw_data); - gps_loc_cb = NULL; - gps_sv_cb = NULL; - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_start - -DESCRIPTION - Starts the tracking session - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_start() -{ - ENTRY_LOG(); - int ret_val = loc_eng_start(loc_afw_data); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_stop - -DESCRIPTION - Stops the tracking session - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_stop() -{ - ENTRY_LOG(); - int ret_val = -1; - ret_val = loc_eng_stop(loc_afw_data); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_set_position_mode - -DESCRIPTION - Sets the mode and fix frequency for the tracking session. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_set_position_mode(GpsPositionMode mode, - GpsPositionRecurrence recurrence, - uint32_t min_interval, - uint32_t preferred_accuracy, - uint32_t preferred_time) -{ - ENTRY_LOG(); - int ret_val = -1; - LocPositionMode locMode; - switch (mode) { - case GPS_POSITION_MODE_MS_BASED: - locMode = LOC_POSITION_MODE_MS_BASED; - break; - case GPS_POSITION_MODE_MS_ASSISTED: - locMode = LOC_POSITION_MODE_MS_ASSISTED; - break; - default: - locMode = LOC_POSITION_MODE_STANDALONE; - break; - } - - // set position sharing option to true - bool sharePosition = true; - - LocPosMode params(locMode, recurrence, min_interval, - preferred_accuracy, preferred_time, - sharePosition, NULL, NULL); - ret_val = loc_eng_set_position_mode(loc_afw_data, params); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_inject_time - -DESCRIPTION - This is used by Java native function to do time injection. - -DEPENDENCIES - None - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_inject_time(GpsUtcTime time, int64_t timeReference, int uncertainty) -{ - ENTRY_LOG(); - int ret_val = 0; - - ret_val = loc_eng_inject_time(loc_afw_data, time, - timeReference, uncertainty); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - - -/*=========================================================================== -FUNCTION loc_inject_location - -DESCRIPTION - This is used by Java native function to do location injection. - -DEPENDENCIES - None - -RETURN VALUE - 0 : Successful - error code : Failure - -SIDE EFFECTS - N/A -===========================================================================*/ -static int loc_inject_location(double latitude, double longitude, float accuracy) -{ - ENTRY_LOG(); - - int ret_val = 0; - ret_val = loc_eng_inject_location(loc_afw_data, latitude, longitude, accuracy); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - - -/*=========================================================================== -FUNCTION loc_delete_aiding_data - -DESCRIPTION - This is used by Java native function to delete the aiding data. The function - updates the global variable for the aiding data to be deleted. If the GPS - engine is off, the aiding data will be deleted. Otherwise, the actual action - will happen when gps engine is turned off. - -DEPENDENCIES - Assumes the aiding data type specified in GpsAidingData matches with - LOC API specification. - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_delete_aiding_data(GpsAidingData f) -{ - ENTRY_LOG(); - -#ifndef TARGET_BUILD_VARIANT_USER - loc_eng_delete_aiding_data(loc_afw_data, f); -#endif - - EXIT_LOG(%s, VOID_RET); -} - -const GpsGeofencingInterface* get_geofence_interface(void) -{ - ENTRY_LOG(); - void *handle; - const char *error; - typedef const GpsGeofencingInterface* (*get_gps_geofence_interface_function) (void); - get_gps_geofence_interface_function get_gps_geofence_interface; - static const GpsGeofencingInterface* geofence_interface = NULL; - - dlerror(); /* Clear any existing error */ - - handle = dlopen ("libgeofence.so", RTLD_NOW); - - if (!handle) - { - if ((error = dlerror()) != NULL) { - LOC_LOGE ("%s, dlopen for libgeofence.so failed, error = %s\n", __func__, error); - } - goto exit; - } - dlerror(); /* Clear any existing error */ - get_gps_geofence_interface = (get_gps_geofence_interface_function)dlsym(handle, "gps_geofence_get_interface"); - if ((error = dlerror()) != NULL) { - LOC_LOGE ("%s, dlsym for get_gps_geofence_interface failed, error = %s\n", __func__, error); - goto exit; - } - if (NULL == get_gps_geofence_interface) { - LOC_LOGE ("%s, get_gps_geofence_interface is NULL\n", __func__); - goto exit; - } - - geofence_interface = get_gps_geofence_interface(); - -exit: - EXIT_LOG(%d, geofence_interface == NULL); - return geofence_interface; -} -/*=========================================================================== -FUNCTION loc_get_extension - -DESCRIPTION - Get the gps extension to support XTRA. - -DEPENDENCIES - N/A - -RETURN VALUE - The GPS extension interface. - -SIDE EFFECTS - N/A - -===========================================================================*/ -const void* loc_get_extension(const char* name) -{ - ENTRY_LOG(); - const void* ret_val = NULL; - - LOC_LOGD("%s:%d] For Interface = %s\n",__func__, __LINE__, name); - if (strcmp(name, GPS_XTRA_INTERFACE) == 0) - { - ret_val = &sLocEngXTRAInterface; - } - else if (strcmp(name, AGPS_INTERFACE) == 0) - { - ret_val = &sLocEngAGpsInterface; - } - else if (strcmp(name, GPS_NI_INTERFACE) == 0) - { - ret_val = &sLocEngNiInterface; - } - else if (strcmp(name, AGPS_RIL_INTERFACE) == 0) - { - char baseband[PROPERTY_VALUE_MAX]; - platform_lib_abstraction_property_get("ro.baseband", baseband, "msm"); - if (strcmp(baseband, "csfb") == 0) - { - ret_val = &sLocEngAGpsRilInterface; - } - } - else if (strcmp(name, GPS_GEOFENCING_INTERFACE) == 0) - { - if ((gps_conf.CAPABILITIES | GPS_CAPABILITY_GEOFENCING) == gps_conf.CAPABILITIES ){ - ret_val = get_geofence_interface(); - } - } - else if (strcmp(name, SUPL_CERTIFICATE_INTERFACE) == 0) - { - ret_val = &sLocEngAGpsCertInterface; - } - else if (strcmp(name, GNSS_CONFIGURATION_INTERFACE) == 0) - { - ret_val = &sLocEngConfigInterface; - } - else if (strcmp(name, GPS_MEASUREMENT_INTERFACE) == 0) - { - ret_val = &sLocEngGpsMeasurementInterface; - } - else - { - LOC_LOGE ("get_extension: Invalid interface passed in\n"); - } - EXIT_LOG(%p, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_agps_init - -DESCRIPTION - Initialize the AGps interface. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_agps_init(AGpsCallbacks* callbacks) -{ - ENTRY_LOG(); - loc_eng_agps_init(loc_afw_data, (AGpsExtCallbacks*)callbacks); - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_agps_open - -DESCRIPTION - This function is called when on-demand data connection opening is successful. -It should inform ARM 9 about the data open result. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_agps_open(const char* apn) -{ - ENTRY_LOG(); - AGpsType agpsType = AGPS_TYPE_SUPL; - AGpsBearerType bearerType = AGPS_APN_BEARER_IPV4; - int ret_val = loc_eng_agps_open(loc_afw_data, agpsType, apn, bearerType); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_agps_open_with_apniptype - -DESCRIPTION - This function is called when on-demand data connection opening is successful. -It should inform ARM 9 about the data open result. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_agps_open_with_apniptype(const char* apn, ApnIpType apnIpType) -{ - ENTRY_LOG(); - AGpsType agpsType = AGPS_TYPE_SUPL; - AGpsBearerType bearerType; - - switch (apnIpType) { - case APN_IP_IPV4: - bearerType = AGPS_APN_BEARER_IPV4; - break; - case APN_IP_IPV6: - bearerType = AGPS_APN_BEARER_IPV6; - break; - case APN_IP_IPV4V6: - bearerType = AGPS_APN_BEARER_IPV4V6; - break; - default: - bearerType = AGPS_APN_BEARER_IPV4; - break; - } - - int ret_val = loc_eng_agps_open(loc_afw_data, agpsType, apn, bearerType); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_agps_closed - -DESCRIPTION - This function is called when on-demand data connection closing is done. -It should inform ARM 9 about the data close result. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_agps_closed() -{ - ENTRY_LOG(); - AGpsType agpsType = AGPS_TYPE_SUPL; - int ret_val = loc_eng_agps_closed(loc_afw_data, agpsType); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_agps_open_failed - -DESCRIPTION - This function is called when on-demand data connection opening has failed. -It should inform ARM 9 about the data open result. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_agps_open_failed() -{ - ENTRY_LOG(); - AGpsType agpsType = AGPS_TYPE_SUPL; - int ret_val = loc_eng_agps_open_failed(loc_afw_data, agpsType); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_agps_set_server - -DESCRIPTION - If loc_eng_set_server is called before loc_eng_init, it doesn't work. This - proxy buffers server settings and calls loc_eng_set_server when the client is - open. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_agps_set_server(AGpsType type, const char* hostname, int port) -{ - ENTRY_LOG(); - LocServerType serverType; - switch (type) { - case AGPS_TYPE_SUPL: - serverType = LOC_AGPS_SUPL_SERVER; - break; - case AGPS_TYPE_C2K: - serverType = LOC_AGPS_CDMA_PDE_SERVER; - break; - default: - serverType = LOC_AGPS_SUPL_SERVER; - } - int ret_val = loc_eng_set_server_proxy(loc_afw_data, serverType, hostname, port); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTIONf571 - loc_xtra_init - -DESCRIPTION - Initialize XTRA module. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_xtra_init(GpsXtraCallbacks* callbacks) -{ - ENTRY_LOG(); - GpsXtraExtCallbacks extCallbacks; - memset(&extCallbacks, 0, sizeof(extCallbacks)); - extCallbacks.download_request_cb = callbacks->download_request_cb; - int ret_val = loc_eng_xtra_init(loc_afw_data, &extCallbacks); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - - -/*=========================================================================== -FUNCTION loc_xtra_inject_data - -DESCRIPTION - Initialize XTRA module. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_xtra_inject_data(char* data, int length) -{ - ENTRY_LOG(); - int ret_val = -1; - if( (data != NULL) && ((unsigned int)length <= XTRA_DATA_MAX_SIZE)) - ret_val = loc_eng_xtra_inject_data(loc_afw_data, data, length); - else - LOC_LOGE("%s, Could not inject XTRA data. Buffer address: %p, length: %d", - __func__, data, length); - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_gps_measurement_init - -DESCRIPTION - This function initializes the gps measurement interface - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_gps_measurement_init(GpsMeasurementCallbacks* callbacks) -{ - ENTRY_LOG(); - int ret_val = loc_eng_gps_measurement_init(loc_afw_data, - callbacks); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_gps_measurement_close - -DESCRIPTION - This function closes the gps measurement interface - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_gps_measurement_close() -{ - ENTRY_LOG(); - loc_eng_gps_measurement_close(loc_afw_data); - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_ni_init - -DESCRIPTION - This function initializes the NI interface - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_ni_init(GpsNiCallbacks *callbacks) -{ - ENTRY_LOG(); - gps_ni_cb = callbacks->notify_cb; - loc_eng_ni_init(loc_afw_data, &sGpsNiExtCallbacks); - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_ni_respond - -DESCRIPTION - This function sends an NI respond to the modem processor - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_ni_respond(int notif_id, GpsUserResponseType user_response) -{ - ENTRY_LOG(); - loc_eng_ni_respond(loc_afw_data, notif_id, user_response); - EXIT_LOG(%s, VOID_RET); -} - -// Below stub functions are members of sLocEngAGpsRilInterface -static void loc_agps_ril_init( AGpsRilCallbacks* callbacks ) {} -static void loc_agps_ril_set_ref_location(const AGpsRefLocation *agps_reflocation, size_t sz_struct) {} -static void loc_agps_ril_set_set_id(AGpsSetIDType type, const char* setid) {} -static void loc_agps_ril_ni_message(uint8_t *msg, size_t len) {} -static void loc_agps_ril_update_network_state(int connected, int type, int roaming, const char* extra_info) {} - -/*=========================================================================== -FUNCTION loc_agps_ril_update_network_availability - -DESCRIPTION - Sets data call allow vs disallow flag to modem - This is the only member of sLocEngAGpsRilInterface implemented. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_agps_ril_update_network_availability(int available, const char* apn) -{ - ENTRY_LOG(); - loc_eng_agps_ril_update_network_availability(loc_afw_data, available, apn); - EXIT_LOG(%s, VOID_RET); -} - -static int loc_agps_install_certificates(const DerEncodedCertificate* certificates, - size_t length) -{ - ENTRY_LOG(); - int ret_val = loc_eng_agps_install_certificates(loc_afw_data, certificates, length); - EXIT_LOG(%d, ret_val); - return ret_val; -} -static int loc_agps_revoke_certificates(const Sha1CertificateFingerprint* fingerprints, - size_t length) -{ - ENTRY_LOG(); - LOC_LOGE("%s:%d]: agps_revoke_certificates not supported"); - int ret_val = AGPS_CERTIFICATE_ERROR_GENERIC; - EXIT_LOG(%d, ret_val); - return ret_val; -} - -static void loc_configuration_update(const char* config_data, int32_t length) -{ - ENTRY_LOG(); - loc_eng_configuration_update(loc_afw_data, config_data, length); - switch (sGnssType) - { - case GNSS_GSS: - case GNSS_AUTO: - case GNSS_QCA1530: - //APQ - gps_conf.CAPABILITIES &= ~(GPS_CAPABILITY_MSA | GPS_CAPABILITY_MSB); - break; - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_loc_cb(UlpLocation* location, void* locExt) -{ - ENTRY_LOG(); - if (NULL != location) { - CALLBACK_LOG_CALLFLOW("location_cb - from", %d, location->position_source); - - if (NULL != gps_loc_cb) { - gps_loc_cb(&location->gpsLocation); - } - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_sv_cb(GpsSvStatus* sv_status, void* svExt) -{ - ENTRY_LOG(); - if (NULL != gps_sv_cb) { - CALLBACK_LOG_CALLFLOW("sv_status_cb -", %d, sv_status->num_svs); - gps_sv_cb(sv_status); - } - EXIT_LOG(%s, VOID_RET); -} - -static void local_ni_cb(GpsNiNotification *notification, bool esEnalbed) -{ - if (NULL != gps_ni_cb) { - gps_ni_cb(notification); - } -} - diff --git a/gps/loc_api/libloc_api_50001/loc_eng.cpp b/gps/loc_api/libloc_api_50001/loc_eng.cpp deleted file mode 100644 index 318786d..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng.cpp +++ /dev/null @@ -1,3033 +0,0 @@ -/* Copyright (c) 2009-2016, 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_eng" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include /* struct sockaddr_in */ -#include -#include -#include -#include -#include -#include - - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "loc_core_log.h" -#include "loc_eng_log.h" - -#define SUCCESS TRUE -#define FAILURE FALSE - -#ifndef GPS_CONF_FILE -#define GPS_CONF_FILE "/etc/gps.conf" //??? platform independent -#endif - -#ifndef SAP_CONF_FILE -#define SAP_CONF_FILE "/etc/sap.conf" -#endif - -#define XTRA1_GPSONEXTRA "xtra1.gpsonextra.net" - -using namespace loc_core; - -boolean configAlreadyRead = false; -unsigned int agpsStatus = 0; - -/* Parameter spec table */ -static const loc_param_s_type gps_conf_table[] = -{ - {"GPS_LOCK", &gps_conf.GPS_LOCK, NULL, 'n'}, - {"SUPL_VER", &gps_conf.SUPL_VER, NULL, 'n'}, - {"LPP_PROFILE", &gps_conf.LPP_PROFILE, NULL, 'n'}, - {"A_GLONASS_POS_PROTOCOL_SELECT", &gps_conf.A_GLONASS_POS_PROTOCOL_SELECT, NULL, 'n'}, - {"LPPE_CP_TECHNOLOGY", &gps_conf.LPPE_CP_TECHNOLOGY, NULL, 'n'}, - {"LPPE_UP_TECHNOLOGY", &gps_conf.LPPE_UP_TECHNOLOGY, NULL, 'n'}, - {"AGPS_CERT_WRITABLE_MASK", &gps_conf.AGPS_CERT_WRITABLE_MASK, NULL, 'n'}, - {"SUPL_MODE", &gps_conf.SUPL_MODE, NULL, 'n'}, - {"SUPL_ES", &gps_conf.SUPL_ES, NULL, 'n'}, - {"INTERMEDIATE_POS", &gps_conf.INTERMEDIATE_POS, NULL, 'n'}, - {"ACCURACY_THRES", &gps_conf.ACCURACY_THRES, NULL, 'n'}, - {"NMEA_PROVIDER", &gps_conf.NMEA_PROVIDER, NULL, 'n'}, - {"CAPABILITIES", &gps_conf.CAPABILITIES, NULL, 'n'}, - {"XTRA_VERSION_CHECK", &gps_conf.XTRA_VERSION_CHECK, NULL, 'n'}, - {"XTRA_SERVER_1", &gps_conf.XTRA_SERVER_1, NULL, 's'}, - {"XTRA_SERVER_2", &gps_conf.XTRA_SERVER_2, NULL, 's'}, - {"XTRA_SERVER_3", &gps_conf.XTRA_SERVER_3, NULL, 's'}, - {"USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL", &gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL, NULL, 'n'}, - {"AGPS_CONFIG_INJECT", &gps_conf.AGPS_CONFIG_INJECT, NULL, 'n'}, - {"EXTERNAL_DR_ENABLED", &gps_conf.EXTERNAL_DR_ENABLED, NULL, 'n'}, -}; - -static const loc_param_s_type sap_conf_table[] = -{ - {"GYRO_BIAS_RANDOM_WALK", &sap_conf.GYRO_BIAS_RANDOM_WALK, &sap_conf.GYRO_BIAS_RANDOM_WALK_VALID, 'f'}, - {"ACCEL_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, - {"ANGLE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, - {"RATE_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, - {"VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY", &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY, &sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, 'f'}, - {"SENSOR_ACCEL_BATCHES_PER_SEC", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, NULL, 'n'}, - {"SENSOR_ACCEL_SAMPLES_PER_BATCH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, NULL, 'n'}, - {"SENSOR_GYRO_BATCHES_PER_SEC", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC, NULL, 'n'}, - {"SENSOR_GYRO_SAMPLES_PER_BATCH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, NULL, 'n'}, - {"SENSOR_ACCEL_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, NULL, 'n'}, - {"SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, NULL, 'n'}, - {"SENSOR_GYRO_BATCHES_PER_SEC_HIGH", &sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, NULL, 'n'}, - {"SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH", &sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, NULL, 'n'}, - {"SENSOR_CONTROL_MODE", &sap_conf.SENSOR_CONTROL_MODE, NULL, 'n'}, - {"SENSOR_USAGE", &sap_conf.SENSOR_USAGE, NULL, 'n'}, - {"SENSOR_ALGORITHM_CONFIG_MASK", &sap_conf.SENSOR_ALGORITHM_CONFIG_MASK, NULL, 'n'}, - {"SENSOR_PROVIDER", &sap_conf.SENSOR_PROVIDER, NULL, 'n'} -}; - -static void loc_default_parameters(void) -{ - /*Defaults for gps.conf*/ - gps_conf.INTERMEDIATE_POS = 0; - gps_conf.ACCURACY_THRES = 0; - gps_conf.NMEA_PROVIDER = 0; - gps_conf.GPS_LOCK = 0; - gps_conf.SUPL_VER = 0x10000; - gps_conf.SUPL_MODE = 0x3; - gps_conf.SUPL_ES = 0; - gps_conf.CAPABILITIES = 0x7; - /* LTE Positioning Profile configuration is disable by default*/ - gps_conf.LPP_PROFILE = 0; - /*By default no positioning protocol is selected on A-GLONASS system*/ - gps_conf.A_GLONASS_POS_PROTOCOL_SELECT = 0; - /*XTRA version check is disabled by default*/ - gps_conf.XTRA_VERSION_CHECK=0; - /*Use emergency PDN by default*/ - gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = 1; - /* By default no LPPe CP technology is enabled*/ - gps_conf.LPPE_CP_TECHNOLOGY = 0; - /* By default no LPPe UP technology is enabled*/ - gps_conf.LPPE_UP_TECHNOLOGY = 0; - - /*Defaults for sap.conf*/ - sap_conf.GYRO_BIAS_RANDOM_WALK = 0; - sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC = 2; - sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH = 5; - sap_conf.SENSOR_GYRO_BATCHES_PER_SEC = 2; - sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH = 5; - sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH = 4; - sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH = 25; - sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH = 4; - sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH = 25; - sap_conf.SENSOR_CONTROL_MODE = 0; /* AUTO */ - sap_conf.SENSOR_USAGE = 0; /* Enabled */ - sap_conf.SENSOR_ALGORITHM_CONFIG_MASK = 0; /* INS Disabled = FALSE*/ - /* Values MUST be set by OEMs in configuration for sensor-assisted - navigation to work. There are NO default values */ - sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY = 0; - sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY = 0; - sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY = 0; - sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY = 0; - sap_conf.GYRO_BIAS_RANDOM_WALK_VALID = 0; - sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; - sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; - sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; - sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID = 0; - /* default provider is SSC */ - sap_conf.SENSOR_PROVIDER = 1; - - /* None of the 10 slots for agps certificates are writable by default */ - gps_conf.AGPS_CERT_WRITABLE_MASK = 0; - - /* inject supl config to modem with config values from config.xml or gps.conf, default 1 */ - gps_conf.AGPS_CONFIG_INJECT = 1; -} - -// 2nd half of init(), singled out for -// modem restart to use. -static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data); -static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data); - -static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data, - LocServerType type, const char *hostname, int port); -// Internal functions -static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, - GpsStatusValue status); -static void loc_eng_report_status(loc_eng_data_s_type &loc_eng_data, - GpsStatusValue status); -static void loc_eng_process_conn_request(loc_eng_data_s_type &loc_eng_data, - int connHandle, AGpsType agps_type); -static void loc_eng_agps_close_status(loc_eng_data_s_type &loc_eng_data, int is_succ); -static void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data) ; -static void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) ; - -static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data); -static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data); -static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data); -static void deleteAidingData(loc_eng_data_s_type &logEng); -static AgpsStateMachine* -getAgpsStateMachine(loc_eng_data_s_type& logEng, AGpsExtType agpsType); -static void createAgnssNifs(loc_eng_data_s_type& locEng); -static int dataCallCb(void *cb_data); -static void update_aiding_data_for_deletion(loc_eng_data_s_type& loc_eng_data) { - if (loc_eng_data.engine_status != GPS_STATUS_ENGINE_ON && - loc_eng_data.aiding_data_for_deletion != 0) - { - loc_eng_data.adapter->deleteAidingData(loc_eng_data.aiding_data_for_deletion); - loc_eng_data.aiding_data_for_deletion = 0; - } -} - -static void* noProc(void* data) -{ - return NULL; -} - -/********************************************************************* - * definitions of the static messages used in the file - *********************************************************************/ -// case LOC_ENG_MSG_REQUEST_NI: -LocEngRequestNi::LocEngRequestNi(void* locEng, - GpsNiNotification ¬if, - const void* data) : - LocMsg(), mLocEng(locEng), mNotify(notif), mPayload(data) { - locallog(); -} -void LocEngRequestNi::proc() const { - loc_eng_ni_request_handler(*((loc_eng_data_s_type*)mLocEng), - &mNotify, mPayload); -} -void LocEngRequestNi::locallog() const -{ - LOC_LOGV("id: %d\n type: %s\n flags: %d\n time out: %d\n " - "default response: %s\n requestor id encoding: %s\n" - " text encoding: %s\n passThroughData: %p", - mNotify.notification_id, - loc_get_ni_type_name(mNotify.ni_type), - mNotify.notify_flags, - mNotify.timeout, - loc_get_ni_response_name(mNotify.default_response), - loc_get_ni_encoding_name(mNotify.requestor_id_encoding), - loc_get_ni_encoding_name(mNotify.text_encoding), - mPayload); -} -inline void LocEngRequestNi::log() const { - locallog(); -} - -// case LOC_ENG_MSG_INFORM_NI_RESPONSE: -// in loc_eng_ni.cpp - -// case LOC_ENG_MSG_START_FIX: -LocEngStartFix::LocEngStartFix(LocEngAdapter* adapter) : - LocMsg(), mAdapter(adapter) -{ - locallog(); -} -inline void LocEngStartFix::proc() const -{ - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner(); - loc_eng_start_handler(*locEng); -} -inline void LocEngStartFix::locallog() const -{ - LOC_LOGV("LocEngStartFix"); -} -inline void LocEngStartFix::log() const -{ - locallog(); -} -void LocEngStartFix::send() const { - mAdapter->sendMsg(this); -} - -// case LOC_ENG_MSG_STOP_FIX: -LocEngStopFix::LocEngStopFix(LocEngAdapter* adapter) : - LocMsg(), mAdapter(adapter) -{ - locallog(); -} -inline void LocEngStopFix::proc() const -{ - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner(); - loc_eng_stop_handler(*locEng); -} -inline void LocEngStopFix::locallog() const -{ - LOC_LOGV("LocEngStopFix"); -} -inline void LocEngStopFix::log() const -{ - locallog(); -} -void LocEngStopFix::send() const { - mAdapter->sendMsg(this); -} - -// case LOC_ENG_MSG_SET_POSITION_MODE: -LocEngPositionMode::LocEngPositionMode(LocEngAdapter* adapter, - LocPosMode &mode) : - LocMsg(), mAdapter(adapter), mPosMode(mode) -{ - mPosMode.logv(); -} -inline void LocEngPositionMode::proc() const { - mAdapter->setPositionMode(&mPosMode); -} -inline void LocEngPositionMode::log() const { - mPosMode.logv(); -} -void LocEngPositionMode::send() const { - mAdapter->sendMsg(this); -} - -LocEngGetZpp::LocEngGetZpp(LocEngAdapter* adapter) : - LocMsg(), mAdapter(adapter) -{ - locallog(); -} -inline void LocEngGetZpp::proc() const -{ - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mAdapter->getOwner(); - loc_eng_get_zpp_handler(*locEng); -} -inline void LocEngGetZpp::locallog() const -{ - LOC_LOGV("LocEngGetZpp"); -} -inline void LocEngGetZpp::log() const -{ - locallog(); -} -void LocEngGetZpp::send() const { - mAdapter->sendMsg(this); -} - -struct LocEngSetTime : public LocMsg { - LocEngAdapter* mAdapter; - const GpsUtcTime mTime; - const int64_t mTimeReference; - const int mUncertainty; - inline LocEngSetTime(LocEngAdapter* adapter, - GpsUtcTime t, int64_t tf, int unc) : - LocMsg(), mAdapter(adapter), - mTime(t), mTimeReference(tf), mUncertainty(unc) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setTime(mTime, mTimeReference, mUncertainty); - } - inline void locallog() const { - LOC_LOGV("time: %lld\n timeReference: %lld\n uncertainty: %d", - mTime, mTimeReference, mUncertainty); - } - inline virtual void log() const { - locallog(); - } -}; - - // case LOC_ENG_MSG_INJECT_LOCATION: -struct LocEngInjectLocation : public LocMsg { - LocEngAdapter* mAdapter; - const double mLatitude; - const double mLongitude; - const float mAccuracy; - inline LocEngInjectLocation(LocEngAdapter* adapter, - double lat, double lon, float accur) : - LocMsg(), mAdapter(adapter), - mLatitude(lat), mLongitude(lon), mAccuracy(accur) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->injectPosition(mLatitude, mLongitude, mAccuracy); - } - inline void locallog() const { - LOC_LOGV("latitude: %f\n longitude: %f\n accuracy: %f", - mLatitude, mLongitude, mAccuracy); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_SERVER_IPV4: -struct LocEngSetServerIpv4 : public LocMsg { - LocEngAdapter* mAdapter; - const unsigned int mNlAddr; - const int mPort; - const LocServerType mServerType; - inline LocEngSetServerIpv4(LocEngAdapter* adapter, - unsigned int ip, - int port, - LocServerType type) : - LocMsg(), mAdapter(adapter), - mNlAddr(ip), mPort(port), mServerType(type) - { - locallog(); - } - inline virtual void proc() const { - if (gps_conf.AGPS_CONFIG_INJECT) { - mAdapter->setServer(mNlAddr, mPort, mServerType); - } - } - inline void locallog() const { - LOC_LOGV("LocEngSetServerIpv4 - addr: %x, port: %d, type: %s", - mNlAddr, mPort, loc_get_server_type_name(mServerType)); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_SERVER_URL: -struct LocEngSetServerUrl : public LocMsg { - LocEngAdapter* mAdapter; - const int mLen; - char* mUrl; - inline LocEngSetServerUrl(LocEngAdapter* adapter, - char* urlString, - int url_len) : - LocMsg(), mAdapter(adapter), - mLen(url_len), mUrl(new char[mLen+1]) - { - memcpy((void*)mUrl, (void*)urlString, url_len); - mUrl[mLen] = 0; - locallog(); - } - inline ~LocEngSetServerUrl() - { - delete[] mUrl; - } - inline virtual void proc() const { - if (gps_conf.AGPS_CONFIG_INJECT) { - mAdapter->setServer(mUrl, mLen); - } - } - inline void locallog() const { - LOC_LOGV("LocEngSetServerUrl - url: %s", mUrl); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_A_GLONASS_PROTOCOL: -struct LocEngAGlonassProtocol : public LocMsg { - LocEngAdapter* mAdapter; - const unsigned long mAGlonassProtocl; - inline LocEngAGlonassProtocol(LocEngAdapter* adapter, - unsigned long protocol) : - LocMsg(), mAdapter(adapter), mAGlonassProtocl(protocol) - { - locallog(); - } - inline virtual void proc() const { - if (gps_conf.AGPS_CONFIG_INJECT) { - mAdapter->setAGLONASSProtocol(mAGlonassProtocl); - } - } - inline void locallog() const { - LOC_LOGV("A-GLONASS protocol: 0x%lx", mAGlonassProtocl); - } - inline virtual void log() const { - locallog(); - } -}; - - -struct LocEngLPPeProtocol : public LocMsg { - LocEngAdapter* mAdapter; - const unsigned long mLPPeCP; - const unsigned long mLPPeUP; - inline LocEngLPPeProtocol(LocEngAdapter* adapter, - unsigned long lppeCP, unsigned long lppeUP) : - LocMsg(), mAdapter(adapter), mLPPeCP(lppeCP), mLPPeUP(lppeUP) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setLPPeProtocol(mLPPeCP, mLPPeUP); - } - inline void locallog() const { - LOC_LOGV("LPPe CP: 0x%lx LPPe UP: 0x%1x", mLPPeCP, mLPPeUP); - } - inline virtual void log() const { - locallog(); - } -}; - - -// case LOC_ENG_MSG_SUPL_VERSION: -struct LocEngSuplVer : public LocMsg { - LocEngAdapter* mAdapter; - const int mSuplVer; - inline LocEngSuplVer(LocEngAdapter* adapter, - int suplVer) : - LocMsg(), mAdapter(adapter), mSuplVer(suplVer) - { - locallog(); - } - inline virtual void proc() const { - if (gps_conf.AGPS_CONFIG_INJECT) { - mAdapter->setSUPLVersion(mSuplVer); - } - } - inline void locallog() const { - LOC_LOGV("SUPL Version: %d", mSuplVer); - } - inline virtual void log() const { - locallog(); - } -}; - -struct LocEngSuplMode : public LocMsg { - UlpProxyBase* mUlp; - - inline LocEngSuplMode(UlpProxyBase* ulp) : - LocMsg(), mUlp(ulp) - { - locallog(); - } - inline virtual void proc() const { - mUlp->setCapabilities(ContextBase::getCarrierCapabilities()); - } - inline void locallog() const { - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_NMEA_TYPE: -struct LocEngSetNmeaTypes : public LocMsg { - LocEngAdapter* mAdapter; - uint32_t nmeaTypesMask; - inline LocEngSetNmeaTypes(LocEngAdapter* adapter, - uint32_t typesMask) : - LocMsg(), mAdapter(adapter), nmeaTypesMask(typesMask) - { - locallog(); - } - inline virtual void proc() const { - // set the nmea types - mAdapter->setNMEATypes(nmeaTypesMask); - } - inline void locallog() const - { - LOC_LOGV("LocEngSetNmeaTypes %u\n",nmeaTypesMask); - } - inline virtual void log() const - { - locallog(); - } -}; - - -// case LOC_ENG_MSG_LPP_CONFIG: -struct LocEngLppConfig : public LocMsg { - LocEngAdapter* mAdapter; - const int mLppConfig; - inline LocEngLppConfig(LocEngAdapter* adapter, - int lppConfig) : - LocMsg(), mAdapter(adapter), mLppConfig(lppConfig) - { - locallog(); - } - inline virtual void proc() const { - if (gps_conf.AGPS_CONFIG_INJECT) { - mAdapter->setLPPConfig(mLppConfig); - } - } - inline void locallog() const { - LOC_LOGV("LocEngLppConfig - profile: %d", mLppConfig); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_SENSOR_CONTROL_CONFIG: -struct LocEngSensorControlConfig : public LocMsg { - LocEngAdapter* mAdapter; - const int mSensorsDisabled; - const int mSensorProvider; - inline LocEngSensorControlConfig(LocEngAdapter* adapter, - int sensorsDisabled, int sensorProvider) : - LocMsg(), mAdapter(adapter), mSensorsDisabled(sensorsDisabled), - mSensorProvider(sensorProvider) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setSensorControlConfig(mSensorsDisabled, mSensorProvider); - } - inline void locallog() const { - LOC_LOGV("LocEngSensorControlConfig - Sensors Disabled: %d, Sensor Provider: %d", - mSensorsDisabled, mSensorProvider); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_SENSOR_PROPERTIES: -struct LocEngSensorProperties : public LocMsg { - LocEngAdapter* mAdapter; - const bool mGyroBiasVarianceRandomWalkValid; - const float mGyroBiasVarianceRandomWalk; - const bool mAccelRandomWalkValid; - const float mAccelRandomWalk; - const bool mAngleRandomWalkValid; - const float mAngleRandomWalk; - const bool mRateRandomWalkValid; - const float mRateRandomWalk; - const bool mVelocityRandomWalkValid; - const float mVelocityRandomWalk; - inline LocEngSensorProperties(LocEngAdapter* adapter, - bool gyroBiasRandomWalk_valid, - float gyroBiasRandomWalk, - bool accelRandomWalk_valid, - float accelRandomWalk, - bool angleRandomWalk_valid, - float angleRandomWalk, - bool rateRandomWalk_valid, - float rateRandomWalk, - bool velocityRandomWalk_valid, - float velocityRandomWalk) : - LocMsg(), mAdapter(adapter), - mGyroBiasVarianceRandomWalkValid(gyroBiasRandomWalk_valid), - mGyroBiasVarianceRandomWalk(gyroBiasRandomWalk), - mAccelRandomWalkValid(accelRandomWalk_valid), - mAccelRandomWalk(accelRandomWalk), - mAngleRandomWalkValid(angleRandomWalk_valid), - mAngleRandomWalk(angleRandomWalk), - mRateRandomWalkValid(rateRandomWalk_valid), - mRateRandomWalk(rateRandomWalk), - mVelocityRandomWalkValid(velocityRandomWalk_valid), - mVelocityRandomWalk(velocityRandomWalk) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setSensorProperties(mGyroBiasVarianceRandomWalkValid, - mGyroBiasVarianceRandomWalk, - mAccelRandomWalkValid, - mAccelRandomWalk, - mAngleRandomWalkValid, - mAngleRandomWalk, - mRateRandomWalkValid, - mRateRandomWalk, - mVelocityRandomWalkValid, - mVelocityRandomWalk); - } - inline void locallog() const { - LOC_LOGV("Sensor properties validity, Gyro Random walk: %d " - "Accel Random Walk: %d " - "Angle Random Walk: %d Rate Random Walk: %d " - "Velocity Random Walk: %d\n" - "Sensor properties, Gyro Random walk: %f " - "Accel Random Walk: %f " - "Angle Random Walk: %f Rate Random Walk: %f " - "Velocity Random Walk: %f", - mGyroBiasVarianceRandomWalkValid, - mAccelRandomWalkValid, - mAngleRandomWalkValid, - mRateRandomWalkValid, - mVelocityRandomWalkValid, - mGyroBiasVarianceRandomWalk, - mAccelRandomWalk, - mAngleRandomWalk, - mRateRandomWalk, - mVelocityRandomWalk - ); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_SET_SENSOR_PERF_CONTROL_CONFIG: -struct LocEngSensorPerfControlConfig : public LocMsg { - LocEngAdapter* mAdapter; - const int mControlMode; - const int mAccelSamplesPerBatch; - const int mAccelBatchesPerSec; - const int mGyroSamplesPerBatch; - const int mGyroBatchesPerSec; - const int mAccelSamplesPerBatchHigh; - const int mAccelBatchesPerSecHigh; - const int mGyroSamplesPerBatchHigh; - const int mGyroBatchesPerSecHigh; - const int mAlgorithmConfig; - inline LocEngSensorPerfControlConfig(LocEngAdapter* adapter, - int controlMode, - int accelSamplesPerBatch, - int accelBatchesPerSec, - int gyroSamplesPerBatch, - int gyroBatchesPerSec, - int accelSamplesPerBatchHigh, - int accelBatchesPerSecHigh, - int gyroSamplesPerBatchHigh, - int gyroBatchesPerSecHigh, - int algorithmConfig) : - LocMsg(), mAdapter(adapter), - mControlMode(controlMode), - mAccelSamplesPerBatch(accelSamplesPerBatch), - mAccelBatchesPerSec(accelBatchesPerSec), - mGyroSamplesPerBatch(gyroSamplesPerBatch), - mGyroBatchesPerSec(gyroBatchesPerSec), - mAccelSamplesPerBatchHigh(accelSamplesPerBatchHigh), - mAccelBatchesPerSecHigh(accelBatchesPerSecHigh), - mGyroSamplesPerBatchHigh(gyroSamplesPerBatchHigh), - mGyroBatchesPerSecHigh(gyroBatchesPerSecHigh), - mAlgorithmConfig(algorithmConfig) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->setSensorPerfControlConfig(mControlMode, - mAccelSamplesPerBatch, - mAccelBatchesPerSec, - mGyroSamplesPerBatch, - mGyroBatchesPerSec, - mAccelSamplesPerBatchHigh, - mAccelBatchesPerSecHigh, - mGyroSamplesPerBatchHigh, - mGyroBatchesPerSecHigh, - mAlgorithmConfig); - } - inline void locallog() const { - LOC_LOGV("Sensor Perf Control Config (performanceControlMode)(%u) " - "accel(#smp,#batches) (%u,%u) " - "gyro(#smp,#batches) (%u,%u), " - "accel_high(#smp,#batches) (%u,%u) " - "gyro_high(#smp,#batches) (%u,%u), " - "algorithmConfig(%u)\n", - mControlMode, - mAccelSamplesPerBatch, mAccelBatchesPerSec, - mGyroSamplesPerBatch, mGyroBatchesPerSec, - mAccelSamplesPerBatchHigh, mAccelBatchesPerSecHigh, - mGyroSamplesPerBatchHigh, mGyroBatchesPerSecHigh, - mAlgorithmConfig); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_REPORT_POSITION: -LocEngReportPosition::LocEngReportPosition(LocAdapterBase* adapter, - UlpLocation &loc, - GpsLocationExtended &locExtended, - void* locExt, - enum loc_sess_status st, - LocPosTechMask technology) : - LocMsg(), mAdapter(adapter), mLocation(loc), - mLocationExtended(locExtended), - mLocationExt(((loc_eng_data_s_type*) - ((LocEngAdapter*) - (mAdapter))->getOwner())->location_ext_parser(locExt)), - mStatus(st), mTechMask(technology) -{ - locallog(); -} -void LocEngReportPosition::proc() const { - LocEngAdapter* adapter = (LocEngAdapter*)mAdapter; - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner(); - - if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) { - bool reported = false; - if (locEng->location_cb != NULL) { - if (LOC_SESS_FAILURE == mStatus) { - // in case we want to handle the failure case - locEng->location_cb(NULL, NULL); - reported = true; - } - // what's in the else if is... (line by line) - // 1. this is a final fix; and - // 1.1 it is a Satellite fix; or - // 1.2 it is a sensor fix - // 2. (must be intermediate fix... implicit) - // 2.1 we accepte intermediate; and - // 2.2 it is NOT the case that - // 2.2.1 there is inaccuracy; and - // 2.2.2 we care about inaccuracy; and - // 2.2.3 the inaccuracy exceeds our tolerance - else if ((LOC_SESS_SUCCESS == mStatus && - ((LOC_POS_TECH_MASK_SATELLITE | - LOC_POS_TECH_MASK_SENSORS | - LOC_POS_TECH_MASK_HYBRID) & - mTechMask)) || - (LOC_SESS_INTERMEDIATE == locEng->intermediateFix && - !((mLocation.gpsLocation.flags & - GPS_LOCATION_HAS_ACCURACY) && - (gps_conf.ACCURACY_THRES != 0) && - (mLocation.gpsLocation.accuracy > - gps_conf.ACCURACY_THRES)))) { - locEng->location_cb((UlpLocation*)&(mLocation), - (void*)mLocationExt); - reported = true; - } - } - - // if we have reported this fix - if (reported && - // and if this is a singleshot - GPS_POSITION_RECURRENCE_SINGLE == - locEng->adapter->getPositionMode().recurrence) { - if (LOC_SESS_INTERMEDIATE == mStatus) { - // modem could be still working for a final fix, - // although we no longer need it. So stopFix(). - locEng->adapter->stopFix(); - } - // turn off the session flag. - locEng->adapter->setInSession(false); - } - - LOC_LOGV("LocEngReportPosition::proc() - generateNmea: %d, position source: %d, " - "engine_status: %d, isInSession: %d", - locEng->generateNmea, mLocation.position_source, - locEng->engine_status, locEng->adapter->isInSession()); - - if (locEng->generateNmea && - locEng->adapter->isInSession()) - { - unsigned char generate_nmea = reported && - (mStatus != LOC_SESS_FAILURE); - loc_eng_nmea_generate_pos(locEng, mLocation, mLocationExtended, - generate_nmea); - } - - // Free the allocated memory for rawData - UlpLocation* gp = (UlpLocation*)&(mLocation); - if (gp != NULL && gp->rawData != NULL) - { - delete (char*)gp->rawData; - gp->rawData = NULL; - gp->rawDataSize = 0; - } - } -} -void LocEngReportPosition::locallog() const { - LOC_LOGV("LocEngReportPosition"); -} -void LocEngReportPosition::log() const { - locallog(); -} -void LocEngReportPosition::send() const { - mAdapter->sendMsg(this); -} - - -// case LOC_ENG_MSG_REPORT_SV: -LocEngReportSv::LocEngReportSv(LocAdapterBase* adapter, - GnssSvStatus &sv, - GpsLocationExtended &locExtended, - void* svExt) : - LocMsg(), mAdapter(adapter), mSvStatus(sv), - mLocationExtended(locExtended), - mSvExt(((loc_eng_data_s_type*) - ((LocEngAdapter*) - (mAdapter))->getOwner())->sv_ext_parser(svExt)) -{ - locallog(); -} -void LocEngReportSv::proc() const { - LocEngAdapter* adapter = (LocEngAdapter*)mAdapter; - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner(); - - if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) - { - if (locEng->gnss_sv_status_cb != NULL) { - LOC_LOGE("Calling gnss_sv_status_cb"); - locEng->gnss_sv_status_cb((GnssSvStatus*)&(mSvStatus)); - } - - if (locEng->generateNmea) - { - loc_eng_nmea_generate_sv(locEng, mSvStatus, mLocationExtended); - } - } -} -void LocEngReportSv::locallog() const { - LOC_LOGV("%s:%d] LocEngReportSv",__func__, __LINE__); -} -inline void LocEngReportSv::log() const { - locallog(); -} -void LocEngReportSv::send() const { - mAdapter->sendMsg(this); -} - -// case LOC_ENG_MSG_REPORT_STATUS: -LocEngReportStatus::LocEngReportStatus(LocAdapterBase* adapter, - GpsStatusValue engineStatus) : - LocMsg(), mAdapter(adapter), mStatus(engineStatus) -{ - locallog(); -} -inline void LocEngReportStatus::proc() const -{ - LocEngAdapter* adapter = (LocEngAdapter*)mAdapter; - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)adapter->getOwner(); - - loc_eng_report_status(*locEng, mStatus); - update_aiding_data_for_deletion(*locEng); -} -inline void LocEngReportStatus::locallog() const { - LOC_LOGV("LocEngReportStatus"); -} -inline void LocEngReportStatus::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REPORT_NMEA: -LocEngReportNmea::LocEngReportNmea(void* locEng, - const char* data, int len) : - LocMsg(), mLocEng(locEng), mNmea(new char[len]), mLen(len) -{ - memcpy((void*)mNmea, (void*)data, len); - locallog(); -} -void LocEngReportNmea::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng; - - struct timeval tv; - gettimeofday(&tv, (struct timezone *) NULL); - int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000; - - if (locEng->nmea_cb != NULL) - locEng->nmea_cb(now, mNmea, mLen); -} -inline void LocEngReportNmea::locallog() const { - LOC_LOGV("LocEngReportNmea"); -} -inline void LocEngReportNmea::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REPORT_XTRA_SERVER: -LocEngReportXtraServer::LocEngReportXtraServer(void* locEng, - const char *url1, - const char *url2, - const char *url3, - const int maxlength) : - LocMsg(), mLocEng(locEng), mMaxLen(maxlength), - mServers(new char[3*(mMaxLen+1)]) -{ - char * cptr = mServers; - memset(mServers, 0, 3*(mMaxLen+1)); - - // Override modem URLs with uncommented gps.conf urls - if( gps_conf.XTRA_SERVER_1[0] != '\0' ) { - url1 = &gps_conf.XTRA_SERVER_1[0]; - } - if( gps_conf.XTRA_SERVER_2[0] != '\0' ) { - url2 = &gps_conf.XTRA_SERVER_2[0]; - } - if( gps_conf.XTRA_SERVER_3[0] != '\0' ) { - url3 = &gps_conf.XTRA_SERVER_3[0]; - } - // copy non xtra1.gpsonextra.net URLs into the forwarding buffer. - if( NULL == strcasestr(url1, XTRA1_GPSONEXTRA) ) { - strlcpy(cptr, url1, mMaxLen + 1); - cptr += mMaxLen + 1; - } - if( NULL == strcasestr(url2, XTRA1_GPSONEXTRA) ) { - strlcpy(cptr, url2, mMaxLen + 1); - cptr += mMaxLen + 1; - } - if( NULL == strcasestr(url3, XTRA1_GPSONEXTRA) ) { - strlcpy(cptr, url3, mMaxLen + 1); - } - locallog(); -} - -void LocEngReportXtraServer::proc() const { - loc_eng_xtra_data_s_type* locEngXtra = - &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data); - - if (locEngXtra->report_xtra_server_cb != NULL) { - CALLBACK_LOG_CALLFLOW("report_xtra_server_cb", %s, mServers); - locEngXtra->report_xtra_server_cb(mServers, - &(mServers[mMaxLen+1]), - &(mServers[(mMaxLen+1)<<1])); - } else { - LOC_LOGE("Callback function for request xtra is NULL"); - } -} -inline void LocEngReportXtraServer::locallog() const { - LOC_LOGV("LocEngReportXtraServers: server1: %s\n server2: %s\n" - " server3: %s\n", - mServers, &mServers[mMaxLen+1], &mServers[(mMaxLen+1)<<1]); -} -inline void LocEngReportXtraServer::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REQUEST_BIT: -// case LOC_ENG_MSG_RELEASE_BIT: -LocEngReqRelBIT::LocEngReqRelBIT(void* locEng, AGpsExtType type, - int ipv4, char* ipv6, bool isReq) : - LocMsg(), mLocEng(locEng), mType(type), mIPv4Addr(ipv4), - mIPv6Addr(ipv6 ? new char[16] : NULL), mIsReq(isReq) { - if (NULL != ipv6) - memcpy(mIPv6Addr, ipv6, 16); - locallog(); -} -inline LocEngReqRelBIT::~LocEngReqRelBIT() { - if (mIPv6Addr) { - delete[] mIPv6Addr; - } -} -void LocEngReqRelBIT::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - BITSubscriber s(getAgpsStateMachine(*locEng, mType), - mIPv4Addr, mIPv6Addr); - AgpsStateMachine* sm = (AgpsStateMachine*)s.mStateMachine; - - if (mIsReq) { - sm->subscribeRsrc((Subscriber*)&s); - } else { - sm->unsubscribeRsrc((Subscriber*)&s); - } -} -inline void LocEngReqRelBIT::locallog() const { - LOC_LOGV("LocEngRequestBIT - ipv4: %d.%d.%d.%d, ipv6: %s", - (unsigned char)mIPv4Addr, - (unsigned char)(mIPv4Addr>>8), - (unsigned char)(mIPv4Addr>>16), - (unsigned char)(mIPv4Addr>>24), - NULL != mIPv6Addr ? mIPv6Addr : ""); -} -inline void LocEngReqRelBIT::log() const { - locallog(); -} -void LocEngReqRelBIT::send() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - locEng->adapter->sendMsg(this); -} - -// case LOC_ENG_MSG_RELEASE_BIT: -struct LocEngReleaseBIT : public LocMsg { - const BITSubscriber mSubscriber; - inline LocEngReleaseBIT(const AgpsStateMachine* stateMachine, - unsigned int ipv4, char* ipv6) : - LocMsg(), - mSubscriber(stateMachine, ipv4, ipv6) - { - locallog(); - } - inline virtual void proc() const - { - AgpsStateMachine* sm = (AgpsStateMachine*)mSubscriber.mStateMachine; - sm->unsubscribeRsrc((Subscriber*)&mSubscriber); - } - inline void locallog() const { - LOC_LOGV("LocEngReleaseBIT - ipv4: %d.%d.%d.%d, ipv6: %s", - (unsigned char)(mSubscriber.ID>>24), - (unsigned char)(mSubscriber.ID>>16), - (unsigned char)(mSubscriber.ID>>8), - (unsigned char)mSubscriber.ID, - NULL != mSubscriber.mIPv6Addr ? mSubscriber.mIPv6Addr : ""); - } - virtual void log() const { - locallog(); - } -}; - -// LocEngSuplEsOpened -LocEngSuplEsOpened::LocEngSuplEsOpened(void* locEng) : - LocMsg(), mLocEng(locEng) { - locallog(); -} -void LocEngSuplEsOpened::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - if (locEng->ds_nif) { - AgpsStateMachine* sm = locEng->ds_nif; - sm->onRsrcEvent(RSRC_GRANTED); - } -} -void LocEngSuplEsOpened::locallog() const { - LOC_LOGV("LocEngSuplEsOpened"); -} -void LocEngSuplEsOpened::log() const { - locallog(); -} - -// LocEngSuplEsClosed -LocEngSuplEsClosed::LocEngSuplEsClosed(void* locEng) : - LocMsg(), mLocEng(locEng) { - locallog(); -} -void LocEngSuplEsClosed::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - if (locEng->ds_nif) { - AgpsStateMachine* sm = locEng->ds_nif; - sm->onRsrcEvent(RSRC_RELEASED); - } -} -void LocEngSuplEsClosed::locallog() const { - LOC_LOGV("LocEngSuplEsClosed"); -} -void LocEngSuplEsClosed::log() const { - locallog(); -} - - -// case LOC_ENG_MSG_REQUEST_SUPL_ES: -LocEngRequestSuplEs::LocEngRequestSuplEs(void* locEng, int id) : - LocMsg(), mLocEng(locEng), mID(id) { - locallog(); -} -void LocEngRequestSuplEs::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - if (locEng->ds_nif && gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { - AgpsStateMachine* sm = locEng->ds_nif; - DSSubscriber s(sm, mID); - sm->subscribeRsrc((Subscriber*)&s); - } - else if (locEng->agnss_nif) { - AgpsStateMachine *sm = locEng->agnss_nif; - ATLSubscriber s(mID, - sm, - locEng->adapter, - false); - sm->subscribeRsrc((Subscriber*)&s); - LOC_LOGD("%s:%d]: Using regular ATL for SUPL ES", __func__, __LINE__); - } - else { - locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, -1); - } -} -inline void LocEngRequestSuplEs::locallog() const { - LOC_LOGV("LocEngRequestSuplEs"); -} -inline void LocEngRequestSuplEs::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REQUEST_ATL: -LocEngRequestATL::LocEngRequestATL(void* locEng, int id, - AGpsExtType agps_type) : - LocMsg(), mLocEng(locEng), mID(id), mType(agps_type) { - locallog(); -} -void LocEngRequestATL::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - AgpsStateMachine* sm = (AgpsStateMachine*) - getAgpsStateMachine(*locEng, mType); - if (sm) { - ATLSubscriber s(mID, - sm, - locEng->adapter, - AGPS_TYPE_INVALID == mType); - sm->subscribeRsrc((Subscriber*)&s); - } else { - locEng->adapter->atlOpenStatus(mID, 0, NULL, -1, mType); - } -} -inline void LocEngRequestATL::locallog() const { - LOC_LOGV("LocEngRequestATL"); -} -inline void LocEngRequestATL::log() const { - locallog(); -} - -// case LOC_ENG_MSG_RELEASE_ATL: -LocEngReleaseATL::LocEngReleaseATL(void* locEng, int id) : - LocMsg(), mLocEng(locEng), mID(id) { - locallog(); -} -void LocEngReleaseATL::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - - if (locEng->agnss_nif) { - ATLSubscriber s1(mID, locEng->agnss_nif, locEng->adapter, false); - if (locEng->agnss_nif->unsubscribeRsrc((Subscriber*)&s1)) { - LOC_LOGD("%s:%d]: Unsubscribed from agnss_nif", - __func__, __LINE__); - return; - } - } - - if (locEng->internet_nif) { - ATLSubscriber s2(mID, locEng->internet_nif, locEng->adapter, false); - if (locEng->internet_nif->unsubscribeRsrc((Subscriber*)&s2)) { - LOC_LOGD("%s:%d]: Unsubscribed from internet_nif", - __func__, __LINE__); - return; - } - } - - if (locEng->ds_nif) { - DSSubscriber s3(locEng->ds_nif, mID); - if (locEng->ds_nif->unsubscribeRsrc((Subscriber*)&s3)) { - LOC_LOGD("%s:%d]: Unsubscribed from ds_nif", - __func__, __LINE__); - return; - } - } - - LOC_LOGW("%s:%d]: Could not release ATL. " - "No subscribers found\n", - __func__, __LINE__); - locEng->adapter->atlCloseStatus(mID, 0); -} -inline void LocEngReleaseATL::locallog() const { - LOC_LOGV("LocEngReleaseATL"); -} -inline void LocEngReleaseATL::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REQUEST_WIFI: -// case LOC_ENG_MSG_RELEASE_WIFI: -LocEngReqRelWifi::LocEngReqRelWifi(void* locEng, AGpsExtType type, - loc_if_req_sender_id_e_type sender_id, - char* s, char* p, bool isReq) : - LocMsg(), mLocEng(locEng), mType(type), mSenderId(sender_id), - mSSID(NULL == s ? NULL : new char[SSID_BUF_SIZE]), - mPassword(NULL == p ? NULL : new char[SSID_BUF_SIZE]), - mIsReq(isReq) { - if (NULL != s) - strlcpy(mSSID, s, SSID_BUF_SIZE); - if (NULL != p) - strlcpy(mPassword, p, SSID_BUF_SIZE); - locallog(); -} -LocEngReqRelWifi::~LocEngReqRelWifi() { - if (NULL != mSSID) { - delete[] mSSID; - } - if (NULL != mPassword) { - delete[] mPassword; - } -} -void LocEngReqRelWifi::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - locEng->adapter->atlOpenStatus(mSenderId, 0, NULL, -1, mType); -} -inline void LocEngReqRelWifi::locallog() const { - LOC_LOGV("%s - senderId: %d, ssid: %s, password: %s", - mIsReq ? "LocEngRequestWifi" : "LocEngReleaseWifi", - mSenderId, - NULL != mSSID ? mSSID : "", - NULL != mPassword ? mPassword : ""); -} -inline void LocEngReqRelWifi::log() const { - locallog(); -} -void LocEngReqRelWifi::send() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - locEng->adapter->sendMsg(this); -} - -// case LOC_ENG_MSG_REQUEST_XTRA_DATA: -LocEngRequestXtra::LocEngRequestXtra(void* locEng) : - mLocEng(locEng) { - locallog(); -} -void LocEngRequestXtra::proc() const -{ - loc_eng_xtra_data_s_type* locEngXtra = - &(((loc_eng_data_s_type*)mLocEng)->xtra_module_data); - - if (locEngXtra->download_request_cb != NULL) { - CALLBACK_LOG_CALLFLOW("download_request_cb", %p, mLocEng); - locEngXtra->download_request_cb(); - } else { - LOC_LOGE("Callback function for request xtra is NULL"); - } -} -inline void LocEngRequestXtra::locallog() const { - LOC_LOGV("LocEngReqXtra"); -} -inline void LocEngRequestXtra::log() const { - locallog(); -} - -// case LOC_ENG_MSG_REQUEST_TIME: -LocEngRequestTime::LocEngRequestTime(void* locEng) : - LocMsg(), mLocEng(locEng) -{ - locallog(); -} -void LocEngRequestTime::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - if (gps_conf.CAPABILITIES & GPS_CAPABILITY_ON_DEMAND_TIME) { - if (locEng->request_utc_time_cb != NULL) { - locEng->request_utc_time_cb(); - } else { - LOC_LOGE("Callback function for request time is NULL"); - } - } -} -inline void LocEngRequestTime::locallog() const { - LOC_LOGV("LocEngReqTime"); -} -inline void LocEngRequestTime::log() const { - locallog(); -} - -// case LOC_ENG_MSG_DELETE_AIDING_DATA: -struct LocEngDelAidData : public LocMsg { - loc_eng_data_s_type* mLocEng; - const GpsAidingData mType; - inline LocEngDelAidData(loc_eng_data_s_type* locEng, - GpsAidingData f) : - LocMsg(), mLocEng(locEng), mType(f) - { - locallog(); - } - inline virtual void proc() const { - mLocEng->aiding_data_for_deletion = mType; - update_aiding_data_for_deletion(*mLocEng); - } - inline void locallog() const { - LOC_LOGV("aiding data msak %d", mType); - } - virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_ENABLE_DATA: -struct LocEngEnableData : public LocMsg { - LocEngAdapter* mAdapter; - const int mEnable; - char* mAPN; - const int mLen; - inline LocEngEnableData(LocEngAdapter* adapter, - const char* name, int len, int enable) : - LocMsg(), mAdapter(adapter), - mEnable(enable), mAPN(NULL), mLen(len) - { - if (NULL != name) { - mAPN = new char[len+1]; - memcpy((void*)mAPN, (void*)name, len); - mAPN[len] = 0; - } - locallog(); - } - inline ~LocEngEnableData() { - if (NULL != mAPN) { - delete[] mAPN; - } - } - inline virtual void proc() const { - mAdapter->enableData(mEnable); - if (NULL != mAPN) { - mAdapter->setAPN(mAPN, mLen); - } - } - inline void locallog() const { - LOC_LOGV("apn: %s\n enable: %d", - (NULL == mAPN) ? "NULL" : mAPN, mEnable); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_INJECT_XTRA_DATA: -// loc_eng_xtra.cpp - -// case LOC_ENG_MSG_SET_CAPABILITIES: -struct LocEngSetCapabilities : public LocMsg { - loc_eng_data_s_type* mLocEng; - inline LocEngSetCapabilities(loc_eng_data_s_type* locEng) : - LocMsg(), mLocEng(locEng) - { - locallog(); - } - inline virtual void proc() const { - if (NULL != mLocEng->set_capabilities_cb) { - LOC_LOGV("calling set_capabilities_cb 0x%x", - gps_conf.CAPABILITIES); - mLocEng->set_capabilities_cb(gps_conf.CAPABILITIES); - } else { - LOC_LOGV("set_capabilities_cb is NULL.\n"); - } - } - inline void locallog() const - { - LOC_LOGV("LocEngSetCapabilities"); - } - inline virtual void log() const - { - locallog(); - } -}; - -struct LocEngSetSystemInfo : public LocMsg { - loc_eng_data_s_type* mLocEng; - inline LocEngSetSystemInfo(loc_eng_data_s_type* locEng) : - LocMsg(), mLocEng(locEng) - { - locallog(); - } - inline virtual void proc() const { - if (NULL != mLocEng->set_system_info_cb) { - LOC_LOGV("calling set_system_info_cb 0x%x", - mLocEng->adapter->mGnssInfo.year_of_hw); - mLocEng->set_system_info_cb(&(mLocEng->adapter->mGnssInfo)); - } - else { - LOC_LOGV("set_system_info_cb is NULL.\n"); - } - } - inline void locallog() const - { - LOC_LOGV("LocEngSetSystemInfo"); - } - inline virtual void log() const - { - locallog(); - } -}; -// case LOC_ENG_MSG_LOC_INIT: -struct LocEngInit : public LocMsg { - loc_eng_data_s_type* mLocEng; - inline LocEngInit(loc_eng_data_s_type* locEng) : - LocMsg(), mLocEng(locEng) - { - locallog(); - } - inline virtual void proc() const { - loc_eng_reinit(*mLocEng); - // set the capabilities - mLocEng->adapter->sendMsg(new LocEngSetCapabilities(mLocEng)); - mLocEng->adapter->sendMsg(new LocEngSetSystemInfo(mLocEng)); - } - inline void locallog() const - { - LOC_LOGV("LocEngInit"); - } - inline virtual void log() const - { - locallog(); - } -}; - -// case LOC_ENG_MSG_REQUEST_XTRA_SERVER: -// loc_eng_xtra.cpp - -// case LOC_ENG_MSG_ATL_OPEN_SUCCESS: -struct LocEngAtlOpenSuccess : public LocMsg { - loc_eng_data_s_type* mLocEng; - const AGpsExtType mAgpsType; - const int mLen; - char* mAPN; - const AGpsBearerType mBearerType; - inline LocEngAtlOpenSuccess(loc_eng_data_s_type* locEng, - const AGpsExtType agpsType, - const char* name, - int len, - AGpsBearerType btype) : - LocMsg(), - mLocEng(locEng), mAgpsType(agpsType), mLen(len), - mAPN(new char[len+1]), mBearerType(btype) - { - memcpy((void*)mAPN, (void*)name, len); - mAPN[len] = 0; - locallog(); - } - inline ~LocEngAtlOpenSuccess() - { - delete[] mAPN; - } - inline virtual void proc() const { - AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType); - sm->setBearer(mBearerType); - sm->setAPN(mAPN, mLen); - sm->onRsrcEvent(RSRC_GRANTED); - } - inline void locallog() const { - LOC_LOGV("LocEngAtlOpenSuccess agps type: %s\n apn: %s\n" - " bearer type: %s", - loc_get_agps_type_name(mAgpsType), - mAPN, - loc_get_agps_bear_name(mBearerType)); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_ATL_CLOSED: -struct LocEngAtlClosed : public LocMsg { - loc_eng_data_s_type* mLocEng; - const AGpsExtType mAgpsType; - inline LocEngAtlClosed(loc_eng_data_s_type* locEng, - const AGpsExtType agpsType) : - LocMsg(), mLocEng(locEng), mAgpsType(agpsType) { - locallog(); - } - inline virtual void proc() const { - AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType); - sm->onRsrcEvent(RSRC_RELEASED); - } - inline void locallog() const { - LOC_LOGV("LocEngAtlClosed"); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_ATL_OPEN_FAILED: -struct LocEngAtlOpenFailed : public LocMsg { - loc_eng_data_s_type* mLocEng; - const AGpsExtType mAgpsType; - inline LocEngAtlOpenFailed(loc_eng_data_s_type* locEng, - const AGpsExtType agpsType) : - LocMsg(), mLocEng(locEng), mAgpsType(agpsType) { - locallog(); - } - inline virtual void proc() const { - AgpsStateMachine* sm = getAgpsStateMachine(*mLocEng, mAgpsType); - sm->onRsrcEvent(RSRC_DENIED); - } - inline void locallog() const { - LOC_LOGV("LocEngAtlOpenFailed"); - } - inline virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_ENGINE_DOWN: -LocEngDown::LocEngDown(void* locEng) : - LocMsg(), mLocEng(locEng) { - locallog(); -} -inline void LocEngDown::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - loc_eng_handle_engine_down(*locEng); -} -inline void LocEngDown::locallog() const { - LOC_LOGV("LocEngDown"); -} -inline void LocEngDown::log() const { - locallog(); -} - -// case LOC_ENG_MSG_ENGINE_UP: -LocEngUp::LocEngUp(void* locEng) : - LocMsg(), mLocEng(locEng) { - locallog(); -} -inline void LocEngUp::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*)mLocEng; - loc_eng_handle_engine_up(*locEng); -} -inline void LocEngUp::locallog() const { - LOC_LOGV("LocEngUp"); -} -inline void LocEngUp::log() const { - locallog(); -} - -struct LocEngAgnssNifInit : public LocMsg { - loc_eng_data_s_type* mLocEng; - inline LocEngAgnssNifInit(loc_eng_data_s_type* locEng) : - LocMsg(), mLocEng(locEng) { - locallog(); - } - virtual void proc() const { - createAgnssNifs(*mLocEng); - } - void locallog() const { - LOC_LOGV("LocEngAgnssNifInit\n"); - } - virtual void log() const { - locallog(); - } -}; - -struct LocEngInstallAGpsCert : public LocMsg { - LocEngAdapter* mpAdapter; - const size_t mNumberOfCerts; - const uint32_t mSlotBitMask; - DerEncodedCertificate* mpData; - inline LocEngInstallAGpsCert(LocEngAdapter* adapter, - const DerEncodedCertificate* pData, - size_t numberOfCerts, - uint32_t slotBitMask) : - LocMsg(), mpAdapter(adapter), - mNumberOfCerts(numberOfCerts), mSlotBitMask(slotBitMask), - mpData(new DerEncodedCertificate[mNumberOfCerts]) - { - for (int i=0; i < mNumberOfCerts; i++) { - mpData[i].data = new u_char[pData[i].length]; - if (mpData[i].data) { - memcpy(mpData[i].data, (void*)pData[i].data, pData[i].length); - mpData[i].length = pData[i].length; - } else { - LOC_LOGE("malloc failed for cert#%d", i); - break; - } - } - locallog(); - } - inline ~LocEngInstallAGpsCert() - { - for (int i=0; i < mNumberOfCerts; i++) { - if (mpData[i].data) { - delete[] mpData[i].data; - } - } - delete[] mpData; - } - inline virtual void proc() const { - mpAdapter->installAGpsCert(mpData, mNumberOfCerts, mSlotBitMask); - } - inline void locallog() const { - LOC_LOGV("LocEngInstallAGpsCert - certs=%u mask=%u", - mNumberOfCerts, mSlotBitMask); - } - inline virtual void log() const { - locallog(); - } -}; - -struct LocEngGnssConstellationConfig : public LocMsg { - LocEngAdapter* mAdapter; - inline LocEngGnssConstellationConfig(LocEngAdapter* adapter) : - LocMsg(), mAdapter(adapter) { - locallog(); - } - inline virtual void proc() const { - mAdapter->mGnssInfo.size = sizeof(GnssSystemInfo); - if (mAdapter->gnssConstellationConfig()) { - LOC_LOGV("Modem supports GNSS measurements\n"); - gps_conf.CAPABILITIES |= GPS_CAPABILITY_MEASUREMENTS; - mAdapter->mGnssInfo.year_of_hw = 2016; - } else { - mAdapter->mGnssInfo.year_of_hw = 2015; - LOC_LOGV("Modem does not support GNSS measurements\n"); - } - } - void locallog() const { - LOC_LOGV("LocEngGnssConstellationConfig\n"); - } - virtual void log() const { - locallog(); - } -}; - -// case LOC_ENG_MSG_REPORT_GNSS_MEASUREMENT: -LocEngReportGnssMeasurement::LocEngReportGnssMeasurement(void* locEng, - GnssData &gnssData) : - LocMsg(), mLocEng(locEng), mGnssData(gnssData) -{ - locallog(); -} -void LocEngReportGnssMeasurement::proc() const { - loc_eng_data_s_type* locEng = (loc_eng_data_s_type*) mLocEng; - if (locEng->mute_session_state != LOC_MUTE_SESS_IN_SESSION) - { - if (locEng->gnss_measurement_cb != NULL) { - LOC_LOGV("Calling gnss_measurement_cb"); - locEng->gnss_measurement_cb((GnssData*)&(mGnssData)); - } - } -} -void LocEngReportGnssMeasurement::locallog() const { - IF_LOC_LOGV { - LOC_LOGV("%s:%d]: Received in GPS HAL." - "GNSS Measurements count: %d \n", - __func__, __LINE__, mGnssData.measurement_count); - for (int i =0; i< mGnssData.measurement_count && i < GNSS_MAX_SVS; i++) { - LOC_LOGV(" GNSS measurement data in GPS HAL: \n" - " GPS_HAL => Measurement ID | svid | time_offset_ns | state |" - " c_n0_dbhz | pseudorange_rate_mps |" - " pseudorange_rate_uncertainty_mps |" - " accumulated_delta_range_state | flags \n" - " GPS_HAL => %d | %d | %f | %d | %f | %f | %f | %d | %d \n", - i, - mGnssData.measurements[i].svid, - mGnssData.measurements[i].time_offset_ns, - mGnssData.measurements[i].state, - mGnssData.measurements[i].c_n0_dbhz, - mGnssData.measurements[i].pseudorange_rate_mps, - mGnssData.measurements[i].pseudorange_rate_uncertainty_mps, - mGnssData.measurements[i].accumulated_delta_range_state, - mGnssData.measurements[i].flags); - } - LOC_LOGV(" GPS_HAL => Clocks Info: \n" - " time_ns | full_bias_ns | bias_ns | bias_uncertainty_ns | " - " drift_nsps | drift_uncertainty_nsps | hw_clock_discontinuity_count | flags" - " GPS_HAL => Clocks Info: %lld | %lld | %g | %g | %g | %g | %d | 0x%04x\n", - mGnssData.clock.time_ns, - mGnssData.clock.full_bias_ns, - mGnssData.clock.bias_ns, - mGnssData.clock.bias_uncertainty_ns, - mGnssData.clock.drift_nsps, - mGnssData.clock.drift_uncertainty_nsps, - mGnssData.clock.hw_clock_discontinuity_count, - mGnssData.clock.flags); - } -} -inline void LocEngReportGnssMeasurement::log() const { - locallog(); -} - -/********************************************************************* - * Initialization checking macros - *********************************************************************/ -#define STATE_CHECK(ctx, x, ret) \ - if (!(ctx)) \ - { \ - /* Not intialized, abort */\ - LOC_LOGE("%s: log_eng state error: %s", __func__, x); \ - EXIT_LOG(%s, x); \ - ret; \ - } -#define INIT_CHECK(ctx, ret) STATE_CHECK(ctx, "instance not initialized", ret) - -/*=========================================================================== -FUNCTION loc_eng_init - -DESCRIPTION - Initialize the location engine, this include setting up global datas - and registers location engien with loc api service. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_init(loc_eng_data_s_type &loc_eng_data, LocCallbacks* callbacks, - LOC_API_ADAPTER_EVENT_MASK_T event, ContextBase* context) - -{ - int ret_val = 0; - - ENTRY_LOG_CALLFLOW(); - if (NULL == callbacks || 0 == event) { - LOC_LOGE("loc_eng_init: bad parameters cb %p eMask %d", callbacks, event); - ret_val = -1; - EXIT_LOG(%d, ret_val); - return ret_val; - } - - STATE_CHECK((NULL == loc_eng_data.adapter), - "instance already initialized", return 0); - - memset(&loc_eng_data, 0, sizeof (loc_eng_data)); - - // Save callbacks - loc_eng_data.location_cb = callbacks->location_cb; - loc_eng_data.sv_status_cb = callbacks->sv_status_cb; - loc_eng_data.status_cb = callbacks->status_cb; - loc_eng_data.nmea_cb = callbacks->nmea_cb; - loc_eng_data.set_capabilities_cb = callbacks->set_capabilities_cb; - loc_eng_data.acquire_wakelock_cb = callbacks->acquire_wakelock_cb; - loc_eng_data.release_wakelock_cb = callbacks->release_wakelock_cb; - loc_eng_data.request_utc_time_cb = callbacks->request_utc_time_cb; - loc_eng_data.set_system_info_cb = callbacks->set_system_info_cb; - loc_eng_data.gnss_sv_status_cb = callbacks->gnss_sv_status_cb; - loc_eng_data.location_ext_parser = callbacks->location_ext_parser ? - callbacks->location_ext_parser : noProc; - loc_eng_data.sv_ext_parser = callbacks->sv_ext_parser ? - callbacks->sv_ext_parser : noProc; - loc_eng_data.intermediateFix = gps_conf.INTERMEDIATE_POS; - // initial states taken care of by the memset above - // loc_eng_data.engine_status -- GPS_STATUS_NONE; - // loc_eng_data.fix_session_status -- GPS_STATUS_NONE; - // loc_eng_data.mute_session_state -- LOC_MUTE_SESS_NONE; - - if ((event & LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT) && (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_AP)) - { - event = event ^ LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT; // unregister for modem NMEA report - loc_eng_data.generateNmea = true; - } - else if (gps_conf.NMEA_PROVIDER == NMEA_PROVIDER_MP) - { - loc_eng_data.generateNmea = false; - } - - loc_eng_data.adapter = - new LocEngAdapter(event, &loc_eng_data, context, - (LocThread::tCreate)callbacks->create_thread_cb); - - loc_eng_data.adapter->mGnssInfo.size = sizeof(GnssSystemInfo); - loc_eng_data.adapter->mGnssInfo.year_of_hw = 2015; - LOC_LOGD("loc_eng_init created client, id = %p\n", - loc_eng_data.adapter); - loc_eng_data.adapter->sendMsg(new LocEngInit(&loc_eng_data)); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -static int loc_eng_reinit(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - int ret_val = LOC_API_ADAPTER_ERR_SUCCESS; - LocEngAdapter* adapter = loc_eng_data.adapter; - - adapter->sendMsg(new LocEngGnssConstellationConfig(adapter)); - adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER)); - adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE)); - adapter->sendMsg(new LocEngSensorControlConfig(adapter, sap_conf.SENSOR_USAGE, - sap_conf.SENSOR_PROVIDER)); - adapter->sendMsg(new LocEngAGlonassProtocol(adapter, gps_conf.A_GLONASS_POS_PROTOCOL_SELECT)); - adapter->sendMsg(new LocEngLPPeProtocol(adapter, gps_conf.LPPE_CP_TECHNOLOGY, - gps_conf.LPPE_UP_TECHNOLOGY)); - - if (!loc_eng_data.generateNmea) - { - NmeaSentenceTypesMask typesMask = LOC_NMEA_ALL_SUPPORTED_MASK; - LOC_LOGD("loc_eng_init setting nmea types, mask = %u\n",typesMask); - adapter->sendMsg(new LocEngSetNmeaTypes(adapter,typesMask)); - } - - /* Make sure at least one of the sensor property is specified by the user in the gps.conf file. */ - if( sap_conf.GYRO_BIAS_RANDOM_WALK_VALID || - sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID || - sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || - sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID || - sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) { - adapter->sendMsg(new LocEngSensorProperties(adapter, - sap_conf.GYRO_BIAS_RANDOM_WALK_VALID, - sap_conf.GYRO_BIAS_RANDOM_WALK, - sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - sap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY, - sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - sap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY, - sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - sap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY, - sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID, - sap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY)); - } - - adapter->sendMsg(new LocEngSensorPerfControlConfig(adapter, - sap_conf.SENSOR_CONTROL_MODE, - sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH, - sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC, - sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH, - sap_conf.SENSOR_GYRO_BATCHES_PER_SEC, - sap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH, - sap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH, - sap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH, - sap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH, - sap_conf.SENSOR_ALGORITHM_CONFIG_MASK)); - - adapter->sendMsg(new LocEngEnableData(adapter, NULL, 0, (agpsStatus ? 1:0))); - - loc_eng_xtra_version_check(loc_eng_data, gps_conf.XTRA_VERSION_CHECK); - - LOC_LOGD("loc_eng_reinit reinit() successful"); - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_cleanup - -DESCRIPTION - Cleans location engine. The location client handle will be released. - -DEPENDENCIES - None - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return); - - // XTRA has no state, so we are fine with it. - - // we need to check and clear NI -#if 0 - // we need to check and clear ATL - if (NULL != loc_eng_data.agnss_nif) { - delete loc_eng_data.agnss_nif; - loc_eng_data.agnss_nif = NULL; - } - if (NULL != loc_eng_data.internet_nif) { - delete loc_eng_data.internet_nif; - loc_eng_data.internet_nif = NULL; - } -#endif - if (loc_eng_data.adapter->isInSession()) - { - LOC_LOGD("loc_eng_cleanup: fix not stopped. stop it now."); - loc_eng_stop(loc_eng_data); - } - -#if 0 // can't afford to actually clean up, for many reason. - - LOC_LOGD("loc_eng_init: client opened. close it now."); - delete loc_eng_data.adapter; - loc_eng_data.adapter = NULL; - - loc_eng_dmn_conn_loc_api_server_unblock(); - loc_eng_dmn_conn_loc_api_server_join(); - -#endif - - EXIT_LOG(%s, VOID_RET); -} - - -/*=========================================================================== -FUNCTION loc_eng_start - -DESCRIPTION - Starts the tracking session - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_start(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return -1); - - if(! loc_eng_data.adapter->getUlpProxy()->sendStartFix()) - { - loc_eng_data.adapter->sendMsg(new LocEngStartFix(loc_eng_data.adapter)); - } - - EXIT_LOG(%d, 0); - return 0; -} - -static int loc_eng_start_handler(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - int ret_val = LOC_API_ADAPTER_ERR_SUCCESS; - - if (!loc_eng_data.adapter->isInSession()) { - ret_val = loc_eng_data.adapter->startFix(); - - if (ret_val == LOC_API_ADAPTER_ERR_SUCCESS || - ret_val == LOC_API_ADAPTER_ERR_ENGINE_DOWN || - ret_val == LOC_API_ADAPTER_ERR_PHONE_OFFLINE || - ret_val == LOC_API_ADAPTER_ERR_INTERNAL) - { - loc_eng_data.adapter->setInSession(TRUE); - } - } - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_stop_wrapper - -DESCRIPTION - Stops the tracking session - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_stop(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return -1); - - if(! loc_eng_data.adapter->getUlpProxy()->sendStopFix()) - { - loc_eng_data.adapter->sendMsg(new LocEngStopFix(loc_eng_data.adapter)); - } - - EXIT_LOG(%d, 0); - return 0; -} - -static int loc_eng_stop_handler(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - int ret_val = LOC_API_ADAPTER_ERR_SUCCESS; - - if (loc_eng_data.adapter->isInSession()) { - ret_val = loc_eng_data.adapter->stopFix(); - loc_eng_data.adapter->setInSession(FALSE); - } - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_mute_one_session - -DESCRIPTION - Mutes one session - -DEPENDENCIES - None - -RETURN VALUE - 0: Success - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - loc_eng_data.mute_session_state = LOC_MUTE_SESS_WAIT; - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_eng_set_position_mode - -DESCRIPTION - Sets the mode and fix frequency for the tracking session. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data, - LocPosMode ¶ms) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return -1); - - // The position mode for AUTO/GSS/QCA1530 can only be standalone - if (!(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB) && - !(gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) && - (params.mode != LOC_POSITION_MODE_STANDALONE)) { - params.mode = LOC_POSITION_MODE_STANDALONE; - LOC_LOGD("Position mode changed to standalone for target with AUTO/GSS/qca1530."); - } - - if(! loc_eng_data.adapter->getUlpProxy()->sendFixMode(params)) - { - LocEngAdapter* adapter = loc_eng_data.adapter; - adapter->sendMsg(new LocEngPositionMode(adapter, params)); - } - - EXIT_LOG(%d, 0); - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_inject_time - -DESCRIPTION - This is used by Java native function to do time injection. - -DEPENDENCIES - None - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data, GpsUtcTime time, - int64_t timeReference, int uncertainty) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return -1); - LocEngAdapter* adapter = loc_eng_data.adapter; - - adapter->sendMsg(new LocEngSetTime(adapter, time, timeReference, - uncertainty)); - - EXIT_LOG(%d, 0); - return 0; -} - - -/*=========================================================================== -FUNCTION loc_eng_inject_location - -DESCRIPTION - This is used by Java native function to do location injection. - -DEPENDENCIES - None - -RETURN VALUE - 0 : Successful - error code : Failure - -SIDE EFFECTS - N/A -===========================================================================*/ -int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data, double latitude, - double longitude, float accuracy) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return -1); - LocEngAdapter* adapter = loc_eng_data.adapter; - if(adapter->mSupportsPositionInjection) - { - adapter->sendMsg(new LocEngInjectLocation(adapter, latitude, longitude, - accuracy)); - } - - EXIT_LOG(%d, 0); - return 0; -} - - -/*=========================================================================== -FUNCTION loc_eng_delete_aiding_data - -DESCRIPTION - This is used by Java native function to delete the aiding data. The function - updates the global variable for the aiding data to be deleted. If the GPS - engine is off, the aiding data will be deleted. Otherwise, the actual action - will happen when gps engine is turned off. - -DEPENDENCIES - Assumes the aiding data type specified in GpsAidingData matches with - LOC API specification. - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_delete_aiding_data(loc_eng_data_s_type &loc_eng_data, GpsAidingData f) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return); - - //report delete aiding data to ULP to send to DRPlugin - loc_eng_data.adapter->getUlpProxy()->reportDeleteAidingData(f); - - loc_eng_data.adapter->sendMsg(new LocEngDelAidData(&loc_eng_data, f)); - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== - -FUNCTION loc_inform_gps_state - -DESCRIPTION - Informs the GPS Provider about the GPS status - -DEPENDENCIES - None - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_inform_gps_status(loc_eng_data_s_type &loc_eng_data, GpsStatusValue status) -{ - ENTRY_LOG(); - - if (loc_eng_data.status_cb) - { - GpsStatus gs = { sizeof(gs),status }; - CALLBACK_LOG_CALLFLOW("status_cb", %s, - loc_get_gps_status_name(gs.status)); - loc_eng_data.status_cb(&gs); - } - - EXIT_LOG(%s, VOID_RET); -} - -static int loc_eng_get_zpp_handler(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - int ret_val = LOC_API_ADAPTER_ERR_SUCCESS; - UlpLocation location; - LocPosTechMask tech_mask = LOC_POS_TECH_MASK_DEFAULT; - GpsLocationExtended locationExtended; - memset(&locationExtended, 0, sizeof (GpsLocationExtended)); - locationExtended.size = sizeof(locationExtended); - - ret_val = loc_eng_data.adapter->getZpp(location.gpsLocation, tech_mask); - //Mark the location source as from ZPP - location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO; - location.position_source = ULP_LOCATION_IS_FROM_ZPP; - - loc_eng_data.adapter->getUlpProxy()->reportPosition(location, - locationExtended, - NULL, - LOC_SESS_SUCCESS, - tech_mask); - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/* - Callback function passed to Data Services State Machine - This becomes part of the state machine's servicer and - is used to send requests to the data services client -*/ -static int dataCallCb(void *cb_data) -{ - LOC_LOGD("Enter dataCallCb\n"); - int ret=0; - if(cb_data != NULL) { - dsCbData *cbData = (dsCbData *)cb_data; - LocEngAdapter *locAdapter = (LocEngAdapter *)cbData->mAdapter; - if(cbData->action == GPS_REQUEST_AGPS_DATA_CONN) { - LOC_LOGD("dataCallCb GPS_REQUEST_AGPS_DATA_CONN\n"); - ret = locAdapter->openAndStartDataCall(); - } - else if(cbData->action == GPS_RELEASE_AGPS_DATA_CONN) { - LOC_LOGD("dataCallCb GPS_RELEASE_AGPS_DATA_CONN\n"); - locAdapter->stopDataCall(); - } - } - else { - LOC_LOGE("NULL argument received. Failing.\n"); - ret = -1; - goto err; - } - -err: - LOC_LOGD("Exit dataCallCb ret = %d\n", ret); - return ret; -} - -/*=========================================================================== -FUNCTION loc_eng_agps_reinit - -DESCRIPTION - 2nd half of loc_eng_agps_init(), singled out for modem restart to use. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_agps_reinit(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - - // Set server addresses which came before init - if (loc_eng_data.supl_host_set) - { - loc_eng_set_server(loc_eng_data, LOC_AGPS_SUPL_SERVER, - loc_eng_data.supl_host_buf, - loc_eng_data.supl_port_buf); - } - - if (loc_eng_data.c2k_host_set) - { - loc_eng_set_server(loc_eng_data, LOC_AGPS_CDMA_PDE_SERVER, - loc_eng_data.c2k_host_buf, - loc_eng_data.c2k_port_buf); - } - EXIT_LOG(%s, VOID_RET); -} -/*=========================================================================== -FUNCTION loc_eng_agps_init - -DESCRIPTION - Initialize the AGps interface. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, AGpsExtCallbacks* callbacks) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter, return); - STATE_CHECK((NULL == loc_eng_data.agps_status_cb), - "agps instance already initialized", - return); - if (callbacks == NULL) { - LOC_LOGE("loc_eng_agps_init: bad parameters cb %p", callbacks); - EXIT_LOG(%s, VOID_RET); - return; - } - LocEngAdapter* adapter = loc_eng_data.adapter; - loc_eng_data.agps_status_cb = callbacks->status_cb; - - if (NULL != adapter) { - if (adapter->mSupportsAgpsRequests) { - adapter->sendMsg(new LocEngAgnssNifInit(&loc_eng_data)); - } - loc_eng_agps_reinit(loc_eng_data); - } - - EXIT_LOG(%s, VOID_RET); -} - -static void deleteAidingData(loc_eng_data_s_type &logEng) { - if (logEng.engine_status != GPS_STATUS_ENGINE_ON && - logEng.aiding_data_for_deletion != 0) { - logEng.adapter->deleteAidingData(logEng.aiding_data_for_deletion); - logEng.aiding_data_for_deletion = 0; - } -} - -// must be called under msg handler context -static void createAgnssNifs(loc_eng_data_s_type& locEng) { - bool agpsCapable = ((gps_conf.CAPABILITIES & GPS_CAPABILITY_MSA) || - (gps_conf.CAPABILITIES & GPS_CAPABILITY_MSB)); - LocEngAdapter* adapter = locEng.adapter; - if (NULL != adapter && adapter->mSupportsAgpsRequests) { - if (NULL == locEng.internet_nif) { - locEng.internet_nif= new AgpsStateMachine(servicerTypeAgps, - (void *)locEng.agps_status_cb, - AGPS_TYPE_WWAN_ANY, - false); - } - if (agpsCapable) { - if (NULL == locEng.agnss_nif) { - locEng.agnss_nif = new AgpsStateMachine(servicerTypeAgps, - (void *)locEng.agps_status_cb, - AGPS_TYPE_SUPL, - false); - } - if (NULL == locEng.ds_nif && - gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL && - 0 == adapter->initDataServiceClient()) { - locEng.ds_nif = new DSStateMachine(servicerTypeExt, - (void *)dataCallCb, - locEng.adapter); - } - } - } -} - -// must be called under msg handler context -static AgpsStateMachine* -getAgpsStateMachine(loc_eng_data_s_type &locEng, AGpsExtType agpsType) { - AgpsStateMachine* stateMachine; - switch (agpsType) { - case AGPS_TYPE_INVALID: - case AGPS_TYPE_SUPL: { - stateMachine = locEng.agnss_nif; - break; - } - case AGPS_TYPE_SUPL_ES: { - if (gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) { - if (NULL == locEng.ds_nif) { - createAgnssNifs(locEng); - } - stateMachine = locEng.ds_nif; - } else { - stateMachine = locEng.agnss_nif; - } - break; - } - default: - stateMachine = locEng.internet_nif; - } - return stateMachine; -} - -/*=========================================================================== -FUNCTION loc_eng_agps_open - -DESCRIPTION - This function is called when on-demand data connection opening is successful. -It should inform engine about the data open result. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType, - const char* apn, AGpsBearerType bearerType) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb, - return -1); - - if (apn == NULL) - { - LOC_LOGE("APN Name NULL\n"); - return 0; - } - - LOC_LOGD("loc_eng_agps_open APN name = [%s]", apn); - - int apn_len = smaller_of(strlen (apn), MAX_APN_LEN); - loc_eng_data.adapter->sendMsg( - new LocEngAtlOpenSuccess(&loc_eng_data, agpsType, - apn, apn_len, bearerType)); - - EXIT_LOG(%d, 0); - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_agps_closed - -DESCRIPTION - This function is called when on-demand data connection closing is done. -It should inform engine about the data close result. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb, - return -1); - - loc_eng_data.adapter->sendMsg(new LocEngAtlClosed(&loc_eng_data, - agpsType)); - - EXIT_LOG(%d, 0); - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_agps_open_failed - -DESCRIPTION - This function is called when on-demand data connection opening has failed. -It should inform engine about the data open result. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType) -{ - ENTRY_LOG_CALLFLOW(); - INIT_CHECK(loc_eng_data.adapter && loc_eng_data.agps_status_cb, - return -1); - - loc_eng_data.adapter->sendMsg(new LocEngAtlOpenFailed(&loc_eng_data, - agpsType)); - - EXIT_LOG(%d, 0); - return 0; -} - -/*=========================================================================== - -FUNCTION resolve_in_addr - -DESCRIPTION - Translates a hostname to in_addr struct - -DEPENDENCIES - n/a - -RETURN VALUE - TRUE if successful - -SIDE EFFECTS - n/a - -===========================================================================*/ -static boolean resolve_in_addr(const char *host_addr, struct in_addr *in_addr_ptr) -{ - ENTRY_LOG(); - boolean ret_val = TRUE; - - struct hostent *hp; - hp = gethostbyname(host_addr); - if (hp != NULL) /* DNS OK */ - { - memcpy(in_addr_ptr, hp->h_addr_list[0], hp->h_length); - } - else - { - /* Try IP representation */ - if (inet_aton(host_addr, in_addr_ptr) == 0) - { - /* IP not valid */ - LOC_LOGE("DNS query on '%s' failed\n", host_addr); - ret_val = FALSE; - } - } - - EXIT_LOG(%s, loc_logger_boolStr[ret_val!=0]); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_set_server - -DESCRIPTION - This is used to set the default AGPS server. Server address is obtained - from gps.conf. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -static int loc_eng_set_server(loc_eng_data_s_type &loc_eng_data, - LocServerType type, const char* hostname, int port) -{ - ENTRY_LOG(); - int ret = 0; - LocEngAdapter* adapter = loc_eng_data.adapter; - - if (LOC_AGPS_SUPL_SERVER == type) { - char url[MAX_URL_LEN]; - unsigned int len = 0; - const char nohost[] = "NONE"; - if (hostname == NULL || - strncasecmp(nohost, hostname, sizeof(nohost)) == 0) { - url[0] = NULL; - } else { - len = snprintf(url, sizeof(url), "%s:%u", hostname, (unsigned) port); - } - - if (sizeof(url) > len) { - adapter->sendMsg(new LocEngSetServerUrl(adapter, url, len)); - } - } else if (LOC_AGPS_CDMA_PDE_SERVER == type || - LOC_AGPS_CUSTOM_PDE_SERVER == type || - LOC_AGPS_MPC_SERVER == type) { - struct in_addr addr; - if (!resolve_in_addr(hostname, &addr)) - { - LOC_LOGE("loc_eng_set_server, hostname %s cannot be resolved.\n", hostname); - ret = -2; - } else { - unsigned int ip = htonl(addr.s_addr); - adapter->sendMsg(new LocEngSetServerIpv4(adapter, ip, port, type)); - } - } else { - LOC_LOGE("loc_eng_set_server, type %d cannot be resolved.\n", type); - } - - EXIT_LOG(%d, ret); - return ret; -} - -/*=========================================================================== -FUNCTION loc_eng_set_server_proxy - -DESCRIPTION - If loc_eng_set_server is called before loc_eng_init, it doesn't work. This - proxy buffers server settings and calls loc_eng_set_server when the client is - open. - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data, - LocServerType type, - const char* hostname, int port) -{ - ENTRY_LOG_CALLFLOW(); - int ret_val = 0; - - LOC_LOGV("save the address, type: %d, hostname: %s, port: %d", - (int) type, hostname, port); - switch (type) - { - case LOC_AGPS_SUPL_SERVER: - strlcpy(loc_eng_data.supl_host_buf, hostname, - sizeof(loc_eng_data.supl_host_buf)); - loc_eng_data.supl_port_buf = port; - loc_eng_data.supl_host_set = 1; - break; - case LOC_AGPS_CDMA_PDE_SERVER: - strlcpy(loc_eng_data.c2k_host_buf, hostname, - sizeof(loc_eng_data.c2k_host_buf)); - loc_eng_data.c2k_port_buf = port; - loc_eng_data.c2k_host_set = 1; - break; - default: - LOC_LOGE("loc_eng_set_server_proxy, unknown server type = %d", (int) type); - } - - if (NULL != loc_eng_data.adapter) - { - ret_val = loc_eng_set_server(loc_eng_data, type, hostname, port); - } - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_agps_ril_update_network_availability - -DESCRIPTION - Sets data call allow vs disallow flag to modem - This is the only member of sLocEngAGpsRilInterface implemented. - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data, - int available, const char* apn) -{ - ENTRY_LOG_CALLFLOW(); - - //This is to store the status of data availability over the network. - //If GPS is not enabled, the INIT_CHECK will fail and the modem will - //not be updated with the network's availability. Since the data status - //can change before GPS is enabled the, storing the status will enable - //us to inform the modem after GPS is enabled - agpsStatus = available; - - INIT_CHECK(loc_eng_data.adapter, return); - if (apn != NULL) - { - LOC_LOGD("loc_eng_agps_ril_update_network_availability: APN Name = [%s]\n", apn); - int apn_len = smaller_of(strlen (apn), MAX_APN_LEN); - LocEngAdapter* adapter = loc_eng_data.adapter; - adapter->sendMsg(new LocEngEnableData(adapter, apn, apn_len, available)); - } - EXIT_LOG(%s, VOID_RET); -} - -int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data, - const DerEncodedCertificate* certificates, - size_t numberOfCerts) -{ - ENTRY_LOG_CALLFLOW(); - int ret_val = AGPS_CERTIFICATE_OPERATION_SUCCESS; - - uint32_t slotBitMask = gps_conf.AGPS_CERT_WRITABLE_MASK; - uint32_t slotCount = 0; - for (uint32_t slotBitMaskCounter=slotBitMask; slotBitMaskCounter; slotCount++) { - slotBitMaskCounter &= slotBitMaskCounter - 1; - } - LOC_LOGD("SlotBitMask=%u SlotCount=%u NumberOfCerts=%u", - slotBitMask, slotCount, numberOfCerts); - - LocEngAdapter* adapter = loc_eng_data.adapter; - - if (numberOfCerts == 0) { - LOC_LOGE("No certs to install, since numberOfCerts is zero"); - ret_val = AGPS_CERTIFICATE_OPERATION_SUCCESS; - } else if (!adapter) { - LOC_LOGE("adapter is null!"); - ret_val = AGPS_CERTIFICATE_ERROR_GENERIC; - } else if (slotCount < numberOfCerts) { - LOC_LOGE("Not enough cert slots (%u) to install %u certs!", - slotCount, numberOfCerts); - ret_val = AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES; - } else { - for (int i=0; i < numberOfCerts; ++i) - { - if (certificates[i].length > AGPS_CERTIFICATE_MAX_LENGTH) { - LOC_LOGE("cert#(%u) length of %u is too big! greater than %u", - certificates[i].length, AGPS_CERTIFICATE_MAX_LENGTH); - ret_val = AGPS_CERTIFICATE_ERROR_GENERIC; - break; - } - } - - if (ret_val == AGPS_CERTIFICATE_OPERATION_SUCCESS) { - adapter->sendMsg(new LocEngInstallAGpsCert(adapter, - certificates, - numberOfCerts, - slotBitMask)); - } - } - - EXIT_LOG(%d, ret_val); - return ret_val; -} - -void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data, - const char* config_data, int32_t length) -{ - ENTRY_LOG_CALLFLOW(); - - if (config_data && length > 0) { - loc_gps_cfg_s_type gps_conf_tmp = gps_conf; - UTIL_UPDATE_CONF(config_data, length, gps_conf_table); - LocEngAdapter* adapter = loc_eng_data.adapter; - - // it is possible that HAL is not init'ed at this time - if (adapter) { - if (gps_conf_tmp.SUPL_VER != gps_conf.SUPL_VER) { - adapter->sendMsg(new LocEngSuplVer(adapter, gps_conf.SUPL_VER)); - } - if (gps_conf_tmp.LPP_PROFILE != gps_conf.LPP_PROFILE) { - adapter->sendMsg(new LocEngLppConfig(adapter, gps_conf.LPP_PROFILE)); - } - if (gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT != gps_conf.A_GLONASS_POS_PROTOCOL_SELECT) { - adapter->sendMsg(new LocEngAGlonassProtocol(adapter, - gps_conf.A_GLONASS_POS_PROTOCOL_SELECT)); - } - if (gps_conf_tmp.SUPL_MODE != gps_conf.SUPL_MODE) { - adapter->sendMsg(new LocEngSuplMode(adapter->getUlpProxy())); - } - // we always update lock mask, this is because if this is dsds device, we would not - // know if modem has switched dds, if so, lock mask may also need to be updated. - // if we have power vote, HAL is on, lock mask 0; else gps_conf.GPS_LOCK. - adapter->setGpsLockMsg(adapter->getPowerVote() ? 0 : gps_conf.GPS_LOCK); - } - - gps_conf_tmp.SUPL_VER = gps_conf.SUPL_VER; - gps_conf_tmp.LPP_PROFILE = gps_conf.LPP_PROFILE; - gps_conf_tmp.A_GLONASS_POS_PROTOCOL_SELECT = gps_conf.A_GLONASS_POS_PROTOCOL_SELECT; - gps_conf_tmp.SUPL_MODE = gps_conf.SUPL_MODE; - gps_conf_tmp.SUPL_ES = gps_conf.SUPL_ES; - gps_conf_tmp.GPS_LOCK = gps_conf.GPS_LOCK; - gps_conf_tmp.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = - gps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL; - gps_conf = gps_conf_tmp; - } - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_eng_report_status - -DESCRIPTION - Reports GPS engine state to Java layer. - -DEPENDENCIES - N/A - -RETURN VALUE - N/A - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void loc_eng_report_status (loc_eng_data_s_type &loc_eng_data, GpsStatusValue status) -{ - ENTRY_LOG(); - // Switch from WAIT to MUTE, for "engine on" or "session begin" event - if (status == GPS_STATUS_SESSION_BEGIN || status == GPS_STATUS_ENGINE_ON) - { - if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_WAIT) - { - LOC_LOGD("loc_eng_report_status: mute_session_state changed from WAIT to IN SESSION"); - loc_eng_data.mute_session_state = LOC_MUTE_SESS_IN_SESSION; - } - } - - // Switch off MUTE session - if (loc_eng_data.mute_session_state == LOC_MUTE_SESS_IN_SESSION && - (status == GPS_STATUS_SESSION_END || status == GPS_STATUS_ENGINE_OFF)) - { - LOC_LOGD("loc_eng_report_status: mute_session_state changed from IN SESSION to NONE"); - loc_eng_data.mute_session_state = LOC_MUTE_SESS_NONE; - } - - // Session End is not reported during Android navigating state - boolean navigating = loc_eng_data.adapter->isInSession(); - if (status != GPS_STATUS_NONE && - !(status == GPS_STATUS_SESSION_END && navigating) && - !(status == GPS_STATUS_SESSION_BEGIN && !navigating)) - { - if (loc_eng_data.mute_session_state != LOC_MUTE_SESS_IN_SESSION) - { - // Inform GpsLocationProvider about mNavigating status - loc_inform_gps_status(loc_eng_data, status); - } - else { - LOC_LOGD("loc_eng_report_status: muting the status report."); - } - } - - // Only keeps ENGINE ON/OFF in engine_status - if (status == GPS_STATUS_ENGINE_ON || status == GPS_STATUS_ENGINE_OFF) - { - loc_eng_data.engine_status = status; - } - - // Only keeps SESSION BEGIN/END in fix_session_status - if (status == GPS_STATUS_SESSION_BEGIN || status == GPS_STATUS_SESSION_END) - { - loc_eng_data.fix_session_status = status; - } - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_eng_handle_engine_down - loc_eng_handle_engine_up - -DESCRIPTION - Calls this function when it is detected that modem restart is happening. - Either we detected the modem is down or received modem up event. - This must be called from the deferred thread to avoid race condition. - -DEPENDENCIES - None - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_handle_engine_down(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - loc_eng_ni_reset_on_engine_restart(loc_eng_data); - loc_eng_report_status(loc_eng_data, GPS_STATUS_ENGINE_OFF); - EXIT_LOG(%s, VOID_RET); -} - -void loc_eng_handle_engine_up(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - loc_eng_reinit(loc_eng_data); - - loc_eng_data.adapter->requestPowerVote(); - - if (loc_eng_data.agps_status_cb != NULL) { - if (loc_eng_data.agnss_nif) - loc_eng_data.agnss_nif->dropAllSubscribers(); - if (loc_eng_data.internet_nif) - loc_eng_data.internet_nif->dropAllSubscribers(); - - loc_eng_agps_reinit(loc_eng_data); - } - - // modem is back up. If we crashed in the middle of navigating, we restart. - if (loc_eng_data.adapter->isInSession()) { - // This sets the copy in adapter to modem - loc_eng_data.adapter->setInSession(false); - loc_eng_start_handler(loc_eng_data); - } - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_eng_read_config - -DESCRIPTION - Initiates the reading of the gps config file stored in /etc dir - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_read_config(void) -{ - ENTRY_LOG_CALLFLOW(); - if(configAlreadyRead == false) - { - // Initialize our defaults before reading of configuration file overwrites them. - loc_default_parameters(); - // We only want to parse the conf file once. This is a good place to ensure that. - // In fact one day the conf file should go into context. - UTIL_READ_CONF(GPS_CONF_FILE, gps_conf_table); - UTIL_READ_CONF(SAP_CONF_FILE, sap_conf_table); - configAlreadyRead = true; - } else { - LOC_LOGV("GPS Config file has already been read\n"); - } - - EXIT_LOG(%d, 0); - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_gps_measurement_init - -DESCRIPTION - Initialize gps measurement module. - -DEPENDENCIES - N/A - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data, - GpsMeasurementCallbacks* callbacks) -{ - ENTRY_LOG_CALLFLOW(); - - STATE_CHECK((NULL == loc_eng_data.gnss_measurement_cb), - "gnss measurement already initialized", - return GPS_MEASUREMENT_ERROR_ALREADY_INIT); - STATE_CHECK((callbacks != NULL), - "callbacks can not be NULL", - return GPS_MEASUREMENT_ERROR_GENERIC); - STATE_CHECK(loc_eng_data.adapter, - "GpsInterface must be initialized first", - return GPS_MEASUREMENT_ERROR_GENERIC); - - // updated the mask - LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; - loc_eng_data.adapter->updateEvtMask(event, LOC_REGISTRATION_MASK_ENABLED); - // set up the callback - loc_eng_data.gnss_measurement_cb = callbacks->gnss_measurement_callback; - LOC_LOGD ("%s, event masks updated successfully", __func__); - - return GPS_MEASUREMENT_OPERATION_SUCCESS; -} - -/*=========================================================================== -FUNCTION loc_eng_gps_measurement_close - -DESCRIPTION - Close gps measurement module. - -DEPENDENCIES - N/A - -RETURN VALUE - N/A - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG_CALLFLOW(); - - INIT_CHECK(loc_eng_data.adapter, return); - - // updated the mask - LOC_API_ADAPTER_EVENT_MASK_T event = LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT; - loc_eng_data.adapter->updateEvtMask(event, LOC_REGISTRATION_MASK_DISABLED); - // set up the callback - loc_eng_data.gnss_measurement_cb = NULL; - EXIT_LOG(%d, 0); -} diff --git a/gps/loc_api/libloc_api_50001/loc_eng.h b/gps/loc_api/libloc_api_50001/loc_eng.h deleted file mode 100644 index 6deebaa..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng.h +++ /dev/null @@ -1,210 +0,0 @@ -/* Copyright (c) 2009-2014, 2016 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 LOC_ENG_H -#define LOC_ENG_H - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -// Uncomment to keep all LOG messages (LOGD, LOGI, LOGV, etc.) -#define MAX_NUM_ATL_CONNECTIONS 2 - -// Define boolean type to be used by libgps on loc api module -typedef unsigned char boolean; - -#ifndef TRUE -#define TRUE 1 -#endif - -#ifndef FALSE -#define FALSE 0 -#endif - -#include -#include -#include -#include -#include -#include -#include -#include - -// The data connection minimal open time -#define DATA_OPEN_MIN_TIME 1 /* sec */ - -// The system sees GPS engine turns off after inactive for this period of time -#define GPS_AUTO_OFF_TIME 2 /* secs */ -#define SUCCESS TRUE -#define FAILURE FALSE -#define INVALID_ATL_CONNECTION_HANDLE -1 - -#define gps_conf ContextBase::mGps_conf -#define sap_conf ContextBase::mSap_conf - -enum loc_nmea_provider_e_type { - NMEA_PROVIDER_AP = 0, // Application Processor Provider of NMEA - NMEA_PROVIDER_MP // Modem Processor Provider of NMEA -}; - -enum loc_mute_session_e_type { - LOC_MUTE_SESS_NONE = 0, - LOC_MUTE_SESS_WAIT, - LOC_MUTE_SESS_IN_SESSION -}; - -// Module data -typedef struct loc_eng_data_s -{ - LocEngAdapter *adapter; - loc_location_cb_ext location_cb; - gps_status_callback status_cb; - loc_sv_status_cb_ext sv_status_cb; - agps_status_extended agps_status_cb; - gps_nmea_callback nmea_cb; - loc_ni_notify_callback ni_notify_cb; - gps_set_capabilities set_capabilities_cb; - gps_acquire_wakelock acquire_wakelock_cb; - gps_release_wakelock release_wakelock_cb; - gps_request_utc_time request_utc_time_cb; - gnss_set_system_info set_system_info_cb; - gnss_sv_status_callback gnss_sv_status_cb; - gnss_measurement_callback gnss_measurement_cb; - boolean intermediateFix; - AGpsStatusValue agps_status; - loc_eng_xtra_data_s_type xtra_module_data; - loc_eng_ni_data_s_type loc_eng_ni_data; - - // AGPS state machines - AgpsStateMachine* agnss_nif; - AgpsStateMachine* internet_nif; - //State machine for Data Services - AgpsStateMachine* ds_nif; - - // GPS engine status - GpsStatusValue engine_status; - GpsStatusValue fix_session_status; - - // Aiding data information to be deleted, aiding data can only be deleted when GPS engine is off - GpsAidingData aiding_data_for_deletion; - - // For muting session broadcast - loc_mute_session_e_type mute_session_state; - - // For nmea generation - boolean generateNmea; - uint32_t gps_used_mask; - uint32_t glo_used_mask; - float hdop; - float pdop; - float vdop; - - // Address buffers, for addressing setting before init - int supl_host_set; - char supl_host_buf[101]; - int supl_port_buf; - int c2k_host_set; - char c2k_host_buf[101]; - int c2k_port_buf; - int mpc_host_set; - char mpc_host_buf[101]; - int mpc_port_buf; - - loc_ext_parser location_ext_parser; - loc_ext_parser sv_ext_parser; -} loc_eng_data_s_type; - -//loc_eng functions -int loc_eng_init(loc_eng_data_s_type &loc_eng_data, - LocCallbacks* callbacks, - LOC_API_ADAPTER_EVENT_MASK_T event, - ContextBase* context); -int loc_eng_start(loc_eng_data_s_type &loc_eng_data); -int loc_eng_stop(loc_eng_data_s_type &loc_eng_data); -void loc_eng_cleanup(loc_eng_data_s_type &loc_eng_data); -int loc_eng_inject_time(loc_eng_data_s_type &loc_eng_data, - GpsUtcTime time, int64_t timeReference, - int uncertainty); -int loc_eng_inject_location(loc_eng_data_s_type &loc_eng_data, - double latitude, double longitude, - float accuracy); -void loc_eng_delete_aiding_data(loc_eng_data_s_type &loc_eng_data, - GpsAidingData f); -int loc_eng_set_position_mode(loc_eng_data_s_type &loc_eng_data, - LocPosMode ¶ms); -const void* loc_eng_get_extension(loc_eng_data_s_type &loc_eng_data, - const char* name); -int loc_eng_set_server_proxy(loc_eng_data_s_type &loc_eng_data, - LocServerType type, const char *hostname, int port); -void loc_eng_mute_one_session(loc_eng_data_s_type &loc_eng_data); -int loc_eng_read_config(void); - -//loc_eng_agps functions -void loc_eng_agps_init(loc_eng_data_s_type &loc_eng_data, - AGpsExtCallbacks* callbacks); -int loc_eng_agps_open(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType, - const char* apn, AGpsBearerType bearerType); -int loc_eng_agps_closed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType); -int loc_eng_agps_open_failed(loc_eng_data_s_type &loc_eng_data, AGpsExtType agpsType); -void loc_eng_agps_ril_update_network_availability(loc_eng_data_s_type &loc_eng_data, - int avaiable, const char* apn); -int loc_eng_agps_install_certificates(loc_eng_data_s_type &loc_eng_data, - const DerEncodedCertificate* certificates, - size_t length); - -//loc_eng_xtra functions -int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data, - GpsXtraExtCallbacks* callbacks); -int loc_eng_xtra_inject_data(loc_eng_data_s_type &loc_eng_data, - char* data, int length); -int loc_eng_xtra_request_server(loc_eng_data_s_type &loc_eng_data); -void loc_eng_xtra_version_check(loc_eng_data_s_type &loc_eng_data, int check); - -//loc_eng_ni functions -extern void loc_eng_ni_init(loc_eng_data_s_type &loc_eng_data, - GpsNiExtCallbacks *callbacks); -extern void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data, - int notif_id, GpsUserResponseType user_response); -extern void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data, - const GpsNiNotification *notif, - const void* passThrough); -extern void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data); - -void loc_eng_configuration_update (loc_eng_data_s_type &loc_eng_data, - const char* config_data, int32_t length); -int loc_eng_gps_measurement_init(loc_eng_data_s_type &loc_eng_data, - GpsMeasurementCallbacks* callbacks); -void loc_eng_gps_measurement_close(loc_eng_data_s_type &loc_eng_data); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif // LOC_ENG_H diff --git a/gps/loc_api/libloc_api_50001/loc_eng_agps.cpp b/gps/loc_api/libloc_api_50001/loc_eng_agps.cpp deleted file mode 100644 index 43af70f..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_agps.cpp +++ /dev/null @@ -1,969 +0,0 @@ -/* Copyright (c) 2011-2014, 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_eng" - -#include -#include -#include -#include -#include -#include - -//====================================================================== -// C callbacks -//====================================================================== - -// This is given to linked_list_add as the dealloc callback -// data -- an instance of Subscriber -static void deleteObj(void* data) -{ - delete (Subscriber*)data; -} - -// This is given to linked_list_search() as the comparison callback -// when the state manchine needs to process for particular subscriber -// fromCaller -- caller provides this obj -// fromList -- linked_list_search() function take this one from list -static bool hasSubscriber(void* fromCaller, void* fromList) -{ - Notification* notification = (Notification*)fromCaller; - Subscriber* s1 = (Subscriber*)fromList; - - return s1->forMe(*notification); -} - -// This is gvien to linked_list_search() to notify subscriber objs -// when the state machine needs to inform all subscribers of resource -// status changes, e.g. when resource is GRANTED. -// fromCaller -- caller provides this ptr to a Notification obj. -// fromList -- linked_list_search() function take this one from list -static bool notifySubscriber(void* fromCaller, void* fromList) -{ - Notification* notification = (Notification*)fromCaller; - Subscriber* s1 = (Subscriber*)fromList; - - // we notify every subscriber indiscriminatively - // each subscriber decides if this notification is interesting. - return s1->notifyRsrcStatus(*notification) && - // if we do not want to delete the subscriber from the - // the list, we must set this to false so this function - // returns false - notification->postNotifyDelete; -} - -//====================================================================== -// Notification -//====================================================================== -const int Notification::BROADCAST_ALL = 0x80000000; -const int Notification::BROADCAST_ACTIVE = 0x80000001; -const int Notification::BROADCAST_INACTIVE = 0x80000002; -const unsigned char DSStateMachine::MAX_START_DATA_CALL_RETRIES = 4; -const unsigned int DSStateMachine::DATA_CALL_RETRY_DELAY_MSEC = 500; -//====================================================================== -// Subscriber: BITSubscriber / ATLSubscriber / WIFISubscriber -//====================================================================== -bool Subscriber::forMe(Notification ¬ification) -{ - if (NULL != notification.rcver) { - return equals(notification.rcver); - } else { - return Notification::BROADCAST_ALL == notification.groupID || - (Notification::BROADCAST_ACTIVE == notification.groupID && - !isInactive()) || - (Notification::BROADCAST_INACTIVE == notification.groupID && - isInactive()); - } -} -bool BITSubscriber::equals(const Subscriber *s) const -{ - BITSubscriber* bitS = (BITSubscriber*)s; - - return (ID == bitS->ID && - (INADDR_NONE != (unsigned int)ID || - 0 == strncmp(mIPv6Addr, bitS->mIPv6Addr, sizeof(mIPv6Addr)))); -} - -bool BITSubscriber::notifyRsrcStatus(Notification ¬ification) -{ - bool notify = forMe(notification); - - if (notify) { - switch(notification.rsrcStatus) - { - case RSRC_UNSUBSCRIBE: - case RSRC_RELEASED: - loc_eng_dmn_conn_loc_api_server_data_conn( - LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, - GPSONE_LOC_API_IF_RELEASE_SUCCESS); - break; - case RSRC_DENIED: - loc_eng_dmn_conn_loc_api_server_data_conn( - LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, - GPSONE_LOC_API_IF_FAILURE); - break; - case RSRC_GRANTED: - loc_eng_dmn_conn_loc_api_server_data_conn( - LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, - GPSONE_LOC_API_IF_REQUEST_SUCCESS); - break; - default: - notify = false; - } - } - - return notify; -} - -bool ATLSubscriber::notifyRsrcStatus(Notification ¬ification) -{ - bool notify = forMe(notification); - - if (notify) { - switch(notification.rsrcStatus) - { - case RSRC_UNSUBSCRIBE: - case RSRC_RELEASED: - ((LocEngAdapter*)mLocAdapter)->atlCloseStatus(ID, 1); - break; - case RSRC_DENIED: - { - AGpsExtType type = mBackwardCompatibleMode ? - AGPS_TYPE_INVALID : mStateMachine->getType(); - ((LocEngAdapter*)mLocAdapter)->atlOpenStatus(ID, 0, - (char*)mStateMachine->getAPN(), - mStateMachine->getBearer(), - type); - } - break; - case RSRC_GRANTED: - { - AGpsExtType type = mBackwardCompatibleMode ? - AGPS_TYPE_INVALID : mStateMachine->getType(); - ((LocEngAdapter*)mLocAdapter)->atlOpenStatus(ID, 1, - (char*)mStateMachine->getAPN(), - mStateMachine->getBearer(), - type); - } - break; - default: - notify = false; - } - } - - return notify; -} - -bool WIFISubscriber::notifyRsrcStatus(Notification ¬ification) -{ - bool notify = forMe(notification); - - if (notify) { - switch(notification.rsrcStatus) - { - case RSRC_UNSUBSCRIBE: - break; - case RSRC_RELEASED: - loc_eng_dmn_conn_loc_api_server_data_conn( - senderId, - GPSONE_LOC_API_IF_RELEASE_SUCCESS); - break; - case RSRC_DENIED: - loc_eng_dmn_conn_loc_api_server_data_conn( - senderId, - GPSONE_LOC_API_IF_FAILURE); - break; - case RSRC_GRANTED: - loc_eng_dmn_conn_loc_api_server_data_conn( - senderId, - GPSONE_LOC_API_IF_REQUEST_SUCCESS); - break; - default: - notify = false; - } - } - - return notify; -} -bool DSSubscriber::notifyRsrcStatus(Notification ¬ification) -{ - bool notify = forMe(notification); - LOC_LOGD("DSSubscriber::notifyRsrcStatus. notify:%d \n",(int)(notify)); - if(notify) { - switch(notification.rsrcStatus) { - case RSRC_UNSUBSCRIBE: - case RSRC_RELEASED: - case RSRC_DENIED: - case RSRC_GRANTED: - ((DSStateMachine *)mStateMachine)->informStatus(notification.rsrcStatus, ID); - break; - default: - notify = false; - } - } - return notify; -} -void DSSubscriber :: setInactive() -{ - mIsInactive = true; - ((DSStateMachine *)mStateMachine)->informStatus(RSRC_UNSUBSCRIBE, ID); -} -//====================================================================== -// AgpsState: AgpsReleasedState / AgpsPendingState / AgpsAcquiredState -//====================================================================== - -// AgpsReleasedState -class AgpsReleasedState : public AgpsState -{ - friend class AgpsStateMachine; - - inline AgpsReleasedState(AgpsStateMachine* stateMachine) : - AgpsState(stateMachine) - { mReleasedState = this; } - - inline ~AgpsReleasedState() {} -public: - virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data); - inline virtual char* whoami() {return (char*)"AgpsReleasedState";} -}; - -AgpsState* AgpsReleasedState::onRsrcEvent(AgpsRsrcStatus event, void* data) -{ - LOC_LOGD("AgpsReleasedState::onRsrcEvent; event:%d\n", (int)event); - if (mStateMachine->hasSubscribers()) { - LOC_LOGE("Error: %s subscriber list not empty!!!", whoami()); - // I don't know how to recover from it. I am adding this rather - // for debugging purpose. - } - - AgpsState* nextState = this; - switch (event) - { - case RSRC_SUBSCRIBE: - { - // no notification until we get RSRC_GRANTED - // but we need to add subscriber to the list - mStateMachine->addSubscriber((Subscriber*)data); - // request from connecivity service for NIF - //The if condition is added so that if the data call setup fails - //for DS State Machine, we want to retry in released state. - //for AGps State Machine, sendRsrcRequest() will always return success - if(!mStateMachine->sendRsrcRequest(GPS_REQUEST_AGPS_DATA_CONN)) { - // move the state to PENDING - nextState = mPendingState; - } - } - break; - - case RSRC_UNSUBSCRIBE: - { - // the list should really be empty, nothing to remove. - // but we might as well just tell the client it is - // unsubscribed. False tolerance, right? - Subscriber* subscriber = (Subscriber*) data; - Notification notification(subscriber, event, false); - subscriber->notifyRsrcStatus(notification); - } - // break; - case RSRC_GRANTED: - case RSRC_RELEASED: - case RSRC_DENIED: - default: - LOC_LOGW("%s: unrecognized event %d", whoami(), event); - // no state change. - break; - } - - LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d", - whoami(), nextState->whoami(), event); - return nextState; -} - -// AgpsPendingState -class AgpsPendingState : public AgpsState -{ - friend class AgpsStateMachine; - - inline AgpsPendingState(AgpsStateMachine* stateMachine) : - AgpsState(stateMachine) - { mPendingState = this; } - - inline ~AgpsPendingState() {} -public: - virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data); - inline virtual char* whoami() {return (char*)"AgpsPendingState";} -}; - -AgpsState* AgpsPendingState::onRsrcEvent(AgpsRsrcStatus event, void* data) -{ - AgpsState* nextState = this;; - LOC_LOGD("AgpsPendingState::onRsrcEvent; event:%d\n", (int)event); - switch (event) - { - case RSRC_SUBSCRIBE: - { - // already requested for NIF resource, - // do nothing until we get RSRC_GRANTED indication - // but we need to add subscriber to the list - mStateMachine->addSubscriber((Subscriber*)data); - // no state change. - } - break; - - case RSRC_UNSUBSCRIBE: - { - Subscriber* subscriber = (Subscriber*) data; - if (subscriber->waitForCloseComplete()) { - subscriber->setInactive(); - } else { - // auto notify this subscriber of the unsubscribe - Notification notification(subscriber, event, true); - mStateMachine->notifySubscribers(notification); - } - - // now check if there is any subscribers left - if (!mStateMachine->hasSubscribers()) { - // no more subscribers, move to RELEASED state - nextState = mReleasedState; - - // tell connecivity service we can release NIF - mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN); - } else if (!mStateMachine->hasActiveSubscribers()) { - // only inactive subscribers, move to RELEASING state - nextState = mReleasingState; - - // tell connecivity service we can release NIF - mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN); - } - } - break; - - case RSRC_GRANTED: - { - nextState = mAcquiredState; - Notification notification(Notification::BROADCAST_ACTIVE, event, false); - // notify all subscribers NIF resource GRANTED - // by setting false, we keep subscribers on the linked list - mStateMachine->notifySubscribers(notification); - } - break; - - case RSRC_RELEASED: - // no state change. - // we are expecting either GRANTED or DENIED. Handling RELEASED - // may like break our state machine in race conditions. - break; - - case RSRC_DENIED: - { - nextState = mReleasedState; - Notification notification(Notification::BROADCAST_ALL, event, true); - // notify all subscribers NIF resource RELEASED or DENIED - // by setting true, we remove subscribers from the linked list - mStateMachine->notifySubscribers(notification); - } - break; - - default: - LOC_LOGE("%s: unrecognized event %d", whoami(), event); - // no state change. - } - - LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d", - whoami(), nextState->whoami(), event); - return nextState; -} - - -class AgpsAcquiredState : public AgpsState -{ - friend class AgpsStateMachine; - - inline AgpsAcquiredState(AgpsStateMachine* stateMachine) : - AgpsState(stateMachine) - { mAcquiredState = this; } - - inline ~AgpsAcquiredState() {} -public: - virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data); - inline virtual char* whoami() { return (char*)"AgpsAcquiredState"; } -}; - - -AgpsState* AgpsAcquiredState::onRsrcEvent(AgpsRsrcStatus event, void* data) -{ - AgpsState* nextState = this; - LOC_LOGD("AgpsAcquiredState::onRsrcEvent; event:%d\n", (int)event); - switch (event) - { - case RSRC_SUBSCRIBE: - { - // we already have the NIF resource, simply notify subscriber - Subscriber* subscriber = (Subscriber*) data; - // we have rsrc in hand, so grant it right away - Notification notification(subscriber, RSRC_GRANTED, false); - subscriber->notifyRsrcStatus(notification); - // add subscriber to the list - mStateMachine->addSubscriber(subscriber); - // no state change. - } - break; - - case RSRC_UNSUBSCRIBE: - { - Subscriber* subscriber = (Subscriber*) data; - if (subscriber->waitForCloseComplete()) { - subscriber->setInactive(); - } else { - // auto notify this subscriber of the unsubscribe - Notification notification(subscriber, event, true); - mStateMachine->notifySubscribers(notification); - } - - // now check if there is any subscribers left - if (!mStateMachine->hasSubscribers()) { - // no more subscribers, move to RELEASED state - nextState = mReleasedState; - - // tell connecivity service we can release NIF - mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN); - } else if (!mStateMachine->hasActiveSubscribers()) { - // only inactive subscribers, move to RELEASING state - nextState = mReleasingState; - - // tell connecivity service we can release NIF - mStateMachine->sendRsrcRequest(GPS_RELEASE_AGPS_DATA_CONN); - } - } - break; - - case RSRC_GRANTED: - LOC_LOGW("%s: %d, RSRC_GRANTED already received", whoami(), event); - // no state change. - break; - - case RSRC_RELEASED: - { - LOC_LOGW("%s: %d, a force rsrc release", whoami(), event); - nextState = mReleasedState; - Notification notification(Notification::BROADCAST_ALL, event, true); - // by setting true, we remove subscribers from the linked list - mStateMachine->notifySubscribers(notification); - } - break; - - case RSRC_DENIED: - // no state change. - // we are expecting RELEASED. Handling DENIED - // may like break our state machine in race conditions. - break; - - default: - LOC_LOGE("%s: unrecognized event %d", whoami(), event); - // no state change. - } - - LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d", - whoami(), nextState->whoami(), event); - return nextState; -} - -// AgpsPendingState -class AgpsReleasingState : public AgpsState -{ - friend class AgpsStateMachine; - - inline AgpsReleasingState(AgpsStateMachine* stateMachine) : - AgpsState(stateMachine) - { mReleasingState = this; } - - inline ~AgpsReleasingState() {} -public: - virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data); - inline virtual char* whoami() {return (char*)"AgpsReleasingState";} -}; - -AgpsState* AgpsReleasingState::onRsrcEvent(AgpsRsrcStatus event, void* data) -{ - AgpsState* nextState = this;; - LOC_LOGD("AgpsReleasingState::onRsrcEvent; event:%d\n", (int)event); - - switch (event) - { - case RSRC_SUBSCRIBE: - { - // already requested for NIF resource, - // do nothing until we get RSRC_GRANTED indication - // but we need to add subscriber to the list - mStateMachine->addSubscriber((Subscriber*)data); - // no state change. - } - break; - - case RSRC_UNSUBSCRIBE: - { - Subscriber* subscriber = (Subscriber*) data; - if (subscriber->waitForCloseComplete()) { - subscriber->setInactive(); - } else { - // auto notify this subscriber of the unsubscribe - Notification notification(subscriber, event, true); - mStateMachine->notifySubscribers(notification); - } - - // now check if there is any subscribers left - if (!mStateMachine->hasSubscribers()) { - // no more subscribers, move to RELEASED state - nextState = mReleasedState; - } - } - break; - - case RSRC_DENIED: - // A race condition subscriber unsubscribes before AFW denies resource. - case RSRC_RELEASED: - { - nextState = mAcquiredState; - Notification notification(Notification::BROADCAST_INACTIVE, event, true); - // notify all subscribers that are active NIF resource RELEASE - // by setting false, we keep subscribers on the linked list - mStateMachine->notifySubscribers(notification); - - if (mStateMachine->hasActiveSubscribers()) { - nextState = mPendingState; - // request from connecivity service for NIF - mStateMachine->sendRsrcRequest(GPS_REQUEST_AGPS_DATA_CONN); - } else { - nextState = mReleasedState; - } - } - break; - - case RSRC_GRANTED: - default: - LOC_LOGE("%s: unrecognized event %d", whoami(), event); - // no state change. - } - - LOC_LOGD("onRsrcEvent, old state %s, new state %s, event %d", - whoami(), nextState->whoami(), event); - return nextState; -} -//====================================================================== -//Servicer -//====================================================================== -Servicer* Servicer :: getServicer(servicerType type, void *cb_func) -{ - LOC_LOGD(" Enter getServicer type:%d\n", (int)type); - switch(type) { - case servicerTypeNoCbParam: - return (new Servicer(cb_func)); - case servicerTypeExt: - return (new ExtServicer(cb_func)); - case servicerTypeAgps: - return (new AGpsServicer(cb_func)); - default: - return NULL; - } -} - -int Servicer :: requestRsrc(void *cb_data) -{ - callback(); - return 0; -} - -int ExtServicer :: requestRsrc(void *cb_data) -{ - int ret=-1; - LOC_LOGD("Enter ExtServicer :: requestRsrc\n"); - ret = callbackExt(cb_data); - LOC_LOGD("Exit ExtServicer :: requestRsrc\n"); - return(ret); -} - -int AGpsServicer :: requestRsrc(void *cb_data) -{ - callbackAGps((AGpsStatus *)cb_data); - return 0; -} - -//====================================================================== -// AgpsStateMachine -//====================================================================== - -AgpsStateMachine::AgpsStateMachine(servicerType servType, - void *cb_func, - AGpsExtType type, - bool enforceSingleSubscriber) : - mStatePtr(new AgpsReleasedState(this)),mType(type), - mAPN(NULL), - mAPNLen(0), - mBearer(AGPS_APN_BEARER_INVALID), - mEnforceSingleSubscriber(enforceSingleSubscriber), - mServicer(Servicer :: getServicer(servType, (void *)cb_func)) -{ - linked_list_init(&mSubscribers); - - // setting up mReleasedState - mStatePtr->mPendingState = new AgpsPendingState(this); - mStatePtr->mAcquiredState = new AgpsAcquiredState(this); - mStatePtr->mReleasingState = new AgpsReleasingState(this); - - // setting up mAcquiredState - mStatePtr->mAcquiredState->mReleasedState = mStatePtr; - mStatePtr->mAcquiredState->mPendingState = mStatePtr->mPendingState; - mStatePtr->mAcquiredState->mReleasingState = mStatePtr->mReleasingState; - - // setting up mPendingState - mStatePtr->mPendingState->mAcquiredState = mStatePtr->mAcquiredState; - mStatePtr->mPendingState->mReleasedState = mStatePtr; - mStatePtr->mPendingState->mReleasingState = mStatePtr->mReleasingState; - - // setting up mReleasingState - mStatePtr->mReleasingState->mReleasedState = mStatePtr; - mStatePtr->mReleasingState->mPendingState = mStatePtr->mPendingState; - mStatePtr->mReleasingState->mAcquiredState = mStatePtr->mAcquiredState; -} - -AgpsStateMachine::~AgpsStateMachine() -{ - dropAllSubscribers(); - - // free the 3 states. We must read out all 3 pointers first. - // Otherwise we run the risk of getting pointers from already - // freed memory. - AgpsState* acquiredState = mStatePtr->mAcquiredState; - AgpsState* releasedState = mStatePtr->mReleasedState; - AgpsState* pendindState = mStatePtr->mPendingState; - AgpsState* releasingState = mStatePtr->mReleasingState; - - delete acquiredState; - delete releasedState; - delete pendindState; - delete releasingState; - delete mServicer; - linked_list_destroy(&mSubscribers); - - if (NULL != mAPN) { - delete[] mAPN; - mAPN = NULL; - } -} - -void AgpsStateMachine::setAPN(const char* apn, unsigned int len) -{ - if (NULL != mAPN) { - delete mAPN; - } - - if (NULL != apn) { - mAPN = new char[len+1]; - memcpy(mAPN, apn, len); - mAPN[len] = NULL; - - mAPNLen = len; - } else { - mAPN = NULL; - mAPNLen = 0; - } -} - -void AgpsStateMachine::onRsrcEvent(AgpsRsrcStatus event) -{ - switch (event) - { - case RSRC_GRANTED: - case RSRC_RELEASED: - case RSRC_DENIED: - mStatePtr = mStatePtr->onRsrcEvent(event, NULL); - break; - default: - LOC_LOGW("AgpsStateMachine: unrecognized event %d", event); - break; - } -} - -void AgpsStateMachine::notifySubscribers(Notification& notification) const -{ - if (notification.postNotifyDelete) { - // just any non NULL value to get started - Subscriber* s = (Subscriber*)~0; - while (NULL != s) { - s = NULL; - // if the last param sets to true, _search will delete - // the node from the list for us. But the problem is - // once that is done, _search returns, leaving the - // rest of the list unprocessed. So we need a loop. - linked_list_search(mSubscribers, (void**)&s, notifySubscriber, - (void*)¬ification, true); - delete s; - } - } else { - // no loop needed if it the last param sets to false, which - // mean nothing gets deleted from the list. - linked_list_search(mSubscribers, NULL, notifySubscriber, - (void*)¬ification, false); - } -} - -void AgpsStateMachine::addSubscriber(Subscriber* subscriber) const -{ - Subscriber* s = NULL; - Notification notification((const Subscriber*)subscriber); - linked_list_search(mSubscribers, (void**)&s, - hasSubscriber, (void*)¬ification, false); - - if (NULL == s) { - linked_list_add(mSubscribers, subscriber->clone(), deleteObj); - } -} - -int AgpsStateMachine::sendRsrcRequest(AGpsStatusValue action) const -{ - Subscriber* s = NULL; - Notification notification(Notification::BROADCAST_ACTIVE); - linked_list_search(mSubscribers, (void**)&s, hasSubscriber, - (void*)¬ification, false); - - if ((NULL == s) == (GPS_RELEASE_AGPS_DATA_CONN == action)) { - AGpsExtStatus nifRequest; - nifRequest.size = sizeof(nifRequest); - nifRequest.type = mType; - nifRequest.status = action; - - if (s == NULL) { - nifRequest.ipv4_addr = INADDR_NONE; - memset(&nifRequest.addr, 0, sizeof(nifRequest.addr)); - nifRequest.ssid[0] = '\0'; - nifRequest.password[0] = '\0'; - } else { - s->setIPAddresses(nifRequest.addr); - s->setWifiInfo(nifRequest.ssid, nifRequest.password); - } - - CALLBACK_LOG_CALLFLOW("agps_cb", %s, loc_get_agps_status_name(action)); - mServicer->requestRsrc((void *)&nifRequest); - } - return 0; -} - -void AgpsStateMachine::subscribeRsrc(Subscriber *subscriber) -{ - if (mEnforceSingleSubscriber && hasSubscribers()) { - Notification notification(Notification::BROADCAST_ALL, RSRC_DENIED, true); - notifySubscriber(¬ification, subscriber); - } else { - mStatePtr = mStatePtr->onRsrcEvent(RSRC_SUBSCRIBE, (void*)subscriber); - } -} - -bool AgpsStateMachine::unsubscribeRsrc(Subscriber *subscriber) -{ - Subscriber* s = NULL; - Notification notification((const Subscriber*)subscriber); - linked_list_search(mSubscribers, (void**)&s, - hasSubscriber, (void*)¬ification, false); - - if (NULL != s) { - mStatePtr = mStatePtr->onRsrcEvent(RSRC_UNSUBSCRIBE, (void*)s); - return true; - } - return false; -} - -bool AgpsStateMachine::hasActiveSubscribers() const -{ - Subscriber* s = NULL; - Notification notification(Notification::BROADCAST_ACTIVE); - linked_list_search(mSubscribers, (void**)&s, - hasSubscriber, (void*)¬ification, false); - return NULL != s; -} - -//====================================================================== -// DSStateMachine -//====================================================================== -void delay_callback(void *callbackData, int result) -{ - if(callbackData) { - DSStateMachine *DSSMInstance = (DSStateMachine *)callbackData; - DSSMInstance->retryCallback(); - } - else { - LOC_LOGE(" NULL argument received. Failing.\n"); - goto err; - } -err: - return; -} - -DSStateMachine :: DSStateMachine(servicerType type, void *cb_func, - LocEngAdapter* adapterHandle): - AgpsStateMachine(type, cb_func, AGPS_TYPE_INVALID,false), - mLocAdapter(adapterHandle) -{ - LOC_LOGD("%s:%d]: New DSStateMachine\n", __func__, __LINE__); - mRetries = 0; -} - -void DSStateMachine :: retryCallback(void) -{ - DSSubscriber *subscriber = NULL; - Notification notification(Notification::BROADCAST_ACTIVE); - linked_list_search(mSubscribers, (void**)&subscriber, hasSubscriber, - (void*)¬ification, false); - if(subscriber) - mLocAdapter->requestSuplES(subscriber->ID); - else - LOC_LOGE("DSStateMachine :: retryCallback: No subscriber found." \ - "Cannot retry data call\n"); - return; -} - -int DSStateMachine :: sendRsrcRequest(AGpsStatusValue action) const -{ - DSSubscriber* s = NULL; - dsCbData cbData; - int ret=-1; - int connHandle=-1; - LOC_LOGD("Enter DSStateMachine :: sendRsrcRequest\n"); - Notification notification(Notification::BROADCAST_ACTIVE); - linked_list_search(mSubscribers, (void**)&s, hasSubscriber, - (void*)¬ification, false); - if(s) { - connHandle = s->ID; - LOC_LOGD("DSStateMachine :: sendRsrcRequest - subscriber found\n"); - } - else - LOC_LOGD("DSStateMachine :: sendRsrcRequest - No subscriber found\n"); - - cbData.action = action; - cbData.mAdapter = mLocAdapter; - ret = mServicer->requestRsrc((void *)&cbData); - //Only the request to start data call returns a success/failure - //The request to stop data call will always succeed - //Hence, the below block will only be executed when the - //request to start the data call fails - switch(ret) { - case LOC_API_ADAPTER_ERR_ENGINE_BUSY: - LOC_LOGD("DSStateMachine :: sendRsrcRequest - Failure returned: %d\n",ret); - ((DSStateMachine *)this)->incRetries(); - if(mRetries > MAX_START_DATA_CALL_RETRIES) { - LOC_LOGE(" Failed to start Data call. Fallback to normal ATL SUPL\n"); - informStatus(RSRC_DENIED, connHandle); - } - else { - if(loc_timer_start(DATA_CALL_RETRY_DELAY_MSEC, delay_callback, (void *)this)) { - LOC_LOGE("Error: Could not start delay thread\n"); - ret = -1; - goto err; - } - } - break; - case LOC_API_ADAPTER_ERR_UNSUPPORTED: - LOC_LOGE("No profile found for emergency call. Fallback to normal SUPL ATL\n"); - informStatus(RSRC_DENIED, connHandle); - break; - case LOC_API_ADAPTER_ERR_SUCCESS: - LOC_LOGD("%s:%d]: Request to start data call sent\n", __func__, __LINE__); - break; - case -1: - //One of the ways this case can be encountered is if the callback function - //receives a null argument, it just exits with -1 error - LOC_LOGE("Error: Something went wrong somewhere. Falling back to normal SUPL ATL\n"); - informStatus(RSRC_DENIED, connHandle); - break; - default: - LOC_LOGE("%s:%d]: Unrecognized return value\n", __func__, __LINE__); - } -err: - LOC_LOGD("EXIT DSStateMachine :: sendRsrcRequest; ret = %d\n", ret); - return ret; -} - -void DSStateMachine :: onRsrcEvent(AgpsRsrcStatus event) -{ - void* currState = (void *)mStatePtr; - LOC_LOGD("Enter DSStateMachine :: onRsrcEvent. event = %d\n", (int)event); - switch (event) - { - case RSRC_GRANTED: - LOC_LOGD("DSStateMachine :: onRsrcEvent RSRC_GRANTED\n"); - mStatePtr = mStatePtr->onRsrcEvent(event, NULL); - break; - case RSRC_RELEASED: - LOC_LOGD("DSStateMachine :: onRsrcEvent RSRC_RELEASED\n"); - mStatePtr = mStatePtr->onRsrcEvent(event, NULL); - //To handle the case where we get a RSRC_RELEASED in - //pending state, we translate that to a RSRC_DENIED state - //since the callback from DSI is either RSRC_GRANTED or RSRC_RELEASED - //for when the call is connected or disconnected respectively. - if((void *)mStatePtr != currState) - break; - else { - event = RSRC_DENIED; - LOC_LOGE(" Switching event to RSRC_DENIED\n"); - } - case RSRC_DENIED: - mStatePtr = mStatePtr->onRsrcEvent(event, NULL); - break; - default: - LOC_LOGW("AgpsStateMachine: unrecognized event %d", event); - break; - } - LOC_LOGD("Exit DSStateMachine :: onRsrcEvent. event = %d\n", (int)event); -} - -void DSStateMachine :: informStatus(AgpsRsrcStatus status, int ID) const -{ - LOC_LOGD("DSStateMachine :: informStatus. Status=%d\n",(int)status); - switch(status) { - case RSRC_UNSUBSCRIBE: - mLocAdapter->atlCloseStatus(ID, 1); - break; - case RSRC_RELEASED: - mLocAdapter->closeDataCall(); - break; - case RSRC_DENIED: - ((DSStateMachine *)this)->mRetries = 0; - mLocAdapter->requestATL(ID, AGPS_TYPE_SUPL); - break; - case RSRC_GRANTED: - mLocAdapter->atlOpenStatus(ID, 1, - NULL, - AGPS_APN_BEARER_INVALID, - AGPS_TYPE_INVALID); - break; - default: - LOC_LOGW("DSStateMachine :: informStatus - unknown status"); - } - return; -} diff --git a/gps/loc_api/libloc_api_50001/loc_eng_agps.h b/gps/loc_api/libloc_api_50001/loc_eng_agps.h deleted file mode 100644 index 58ce084..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_agps.h +++ /dev/null @@ -1,435 +0,0 @@ -/* Copyright (c) 2011-2014, 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 __LOC_ENG_AGPS_H__ -#define __LOC_ENG_AGPS_H__ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#if defined(USE_GLIB) && !defined(OFF_TARGET) -#include -#endif /* USE_GLIB */ - -// forward declaration -class AgpsStateMachine; -struct Subscriber; - -// NIF resource events -typedef enum { - RSRC_SUBSCRIBE, - RSRC_UNSUBSCRIBE, - RSRC_GRANTED, - RSRC_RELEASED, - RSRC_DENIED, - RSRC_STATUS_MAX -} AgpsRsrcStatus; - -typedef enum { - servicerTypeNoCbParam, - servicerTypeAgps, - servicerTypeExt -}servicerType; - -//DS Callback struct -typedef struct { - LocEngAdapter *mAdapter; - AGpsStatusValue action; -}dsCbData; - -// information bundle for subscribers -struct Notification { - // goes to every subscriber - static const int BROADCAST_ALL; - // goes to every ACTIVE subscriber - static const int BROADCAST_ACTIVE; - // goes to every INACTIVE subscriber - static const int BROADCAST_INACTIVE; - - // go to a specific subscriber - const Subscriber* rcver; - // broadcast - const int groupID; - // the new resource status event - const AgpsRsrcStatus rsrcStatus; - // should the subscriber be deleted after the notification - const bool postNotifyDelete; - - // convenient constructor - inline Notification(const int broadcast, - const AgpsRsrcStatus status, - const bool deleteAfterwards) : - rcver(NULL), groupID(broadcast), rsrcStatus(status), - postNotifyDelete(deleteAfterwards) {} - - // convenient constructor - inline Notification(const Subscriber* subscriber, - const AgpsRsrcStatus status, - const bool deleteAfterwards) : - rcver(subscriber), groupID(-1), rsrcStatus(status), - postNotifyDelete(deleteAfterwards) {} - - // convenient constructor - inline Notification(const int broadcast) : - rcver(NULL), groupID(broadcast), rsrcStatus(RSRC_STATUS_MAX), - postNotifyDelete(false) {} - - // convenient constructor - inline Notification(const Subscriber* subscriber) : - rcver(subscriber), groupID(-1), rsrcStatus(RSRC_STATUS_MAX), - postNotifyDelete(false) {} -}; - -class AgpsState { - // allows AgpsStateMachine to access private data - // no class members are public. We don't want - // anyone but state machine to use state. - friend class AgpsStateMachine; - friend class DSStateMachine; - // state transitions are done here. - // Each state implements its own transitions (of course). - inline virtual AgpsState* onRsrcEvent(AgpsRsrcStatus event, void* data) = 0; - -protected: - // handle back to state machine - const AgpsStateMachine* mStateMachine; - // each state has pointers to all 3 states - // one of which is to itself. - AgpsState* mReleasedState; - AgpsState* mAcquiredState; - AgpsState* mPendingState; - AgpsState* mReleasingState; - - inline AgpsState(const AgpsStateMachine *stateMachine) : - mStateMachine(stateMachine), - mReleasedState(NULL), - mAcquiredState(NULL), - mPendingState(NULL), - mReleasingState(NULL) {} - virtual ~AgpsState() {} - -public: - // for logging purpose - inline virtual char* whoami() = 0; -}; - -class Servicer { - void (*callback)(void); -public: - static Servicer* getServicer(servicerType type, void *cb_func); - virtual int requestRsrc(void *cb_data); - Servicer() {} - Servicer(void *cb_func) - { callback = (void(*)(void))(cb_func); } - virtual ~Servicer(){} - inline virtual char *whoami() {return (char*)"Servicer";} -}; - -class ExtServicer : public Servicer { - int (*callbackExt)(void *cb_data); -public: - int requestRsrc(void *cb_data); - ExtServicer() {} - ExtServicer(void *cb_func) - { callbackExt = (int(*)(void *))(cb_func); } - virtual ~ExtServicer(){} - inline virtual char *whoami() {return (char*)"ExtServicer";} -}; - -class AGpsServicer : public Servicer { - void (*callbackAGps)(AGpsStatus* status); -public: - int requestRsrc(void *cb_data); - AGpsServicer() {} - AGpsServicer(void *cb_func) - { callbackAGps = (void(*)(AGpsStatus *))(cb_func); } - virtual ~AGpsServicer(){} - inline virtual char *whoami() {return (char*)"AGpsServicer";} -}; - -class AgpsStateMachine { -protected: - // a linked list of subscribers. - void* mSubscribers; - //handle to whoever provides the service - Servicer *mServicer; - // allows AgpsState to access private data - // each state is really internal data to the - // state machine, so it should be able to - // access anything within the state machine. - friend class AgpsState; - // pointer to the current state. - AgpsState* mStatePtr; -private: - // NIF type: AGNSS or INTERNET. - const AGpsExtType mType; - // apn to the NIF. Each state machine tracks - // resource state of a particular NIF. For each - // NIF, there is also an active APN. - char* mAPN; - // for convenience, we don't do strlen each time. - unsigned int mAPNLen; - // bear - AGpsBearerType mBearer; - // ipv4 address for routing - bool mEnforceSingleSubscriber; - -public: - AgpsStateMachine(servicerType servType, void *cb_func, - AGpsExtType type, bool enforceSingleSubscriber); - virtual ~AgpsStateMachine(); - - // self explanatory methods below - void setAPN(const char* apn, unsigned int len); - inline const char* getAPN() const { return (const char*)mAPN; } - inline void setBearer(AGpsBearerType bearer) { mBearer = bearer; } - inline AGpsBearerType getBearer() const { return mBearer; } - inline AGpsExtType getType() const { return (AGpsExtType)mType; } - - // someone, a ATL client or BIT, is asking for NIF - void subscribeRsrc(Subscriber *subscriber); - - // someone, a ATL client or BIT, is done with NIF - bool unsubscribeRsrc(Subscriber *subscriber); - - // add a subscriber in the linked list, if not already there. - void addSubscriber(Subscriber* subscriber) const; - - virtual void onRsrcEvent(AgpsRsrcStatus event); - - // put the data together and send the FW - virtual int sendRsrcRequest(AGpsStatusValue action) const; - - //if list is empty, linked_list_empty returns 1 - //else if list is not empty, returns 0 - //so hasSubscribers() returns 1 if list is not empty - //and returns 0 if list is empty - inline bool hasSubscribers() const - { return !linked_list_empty(mSubscribers); } - - bool hasActiveSubscribers() const; - - inline void dropAllSubscribers() const - { linked_list_flush(mSubscribers); } - - // private. Only a state gets to call this. - void notifySubscribers(Notification& notification) const; - -}; - -class DSStateMachine : public AgpsStateMachine { - static const unsigned char MAX_START_DATA_CALL_RETRIES; - static const unsigned int DATA_CALL_RETRY_DELAY_MSEC; - LocEngAdapter* mLocAdapter; - unsigned char mRetries; -public: - DSStateMachine(servicerType type, - void *cb_func, - LocEngAdapter* adapterHandle); - int sendRsrcRequest(AGpsStatusValue action) const; - void onRsrcEvent(AgpsRsrcStatus event); - void retryCallback(); - void informStatus(AgpsRsrcStatus status, int ID) const; - inline void incRetries() {mRetries++;} - inline virtual char *whoami() {return (char*)"DSStateMachine";} -}; - -// each subscriber is a AGPS client. In the case of ATL, there could be -// multiple clients from modem. In the case of BIT, there is only one -// cilent from BIT daemon. -struct Subscriber { - const uint32_t ID; - const AgpsStateMachine* mStateMachine; - inline Subscriber(const int id, - const AgpsStateMachine* stateMachine) : - ID(id), mStateMachine(stateMachine) {} - inline virtual ~Subscriber() {} - - virtual void setIPAddresses(uint32_t &v4, char* v6) = 0; - virtual void setIPAddresses(struct sockaddr_storage& addr) = 0; - inline virtual void setWifiInfo(char* ssid, char* password) - { ssid[0] = 0; password[0] = 0; } - - inline virtual bool equals(const Subscriber *s) const - { return ID == s->ID; } - - // notifies a subscriber a new NIF resource status, usually - // either GRANTE, DENIED, or RELEASED - virtual bool notifyRsrcStatus(Notification ¬ification) = 0; - - virtual bool waitForCloseComplete() { return false; } - virtual void setInactive() {} - virtual bool isInactive() { return false; } - - virtual Subscriber* clone() = 0; - // checks if this notification is for me, i.e. - // either has my id, or has a broadcast id. - bool forMe(Notification ¬ification); -}; - -// BITSubscriber, created with requests from BIT daemon -struct BITSubscriber : public Subscriber { - char mIPv6Addr[16]; - - inline BITSubscriber(const AgpsStateMachine* stateMachine, - unsigned int ipv4, char* ipv6) : - Subscriber(ipv4, stateMachine) - { - if (NULL == ipv6) { - mIPv6Addr[0] = 0; - } else { - memcpy(mIPv6Addr, ipv6, sizeof(mIPv6Addr)); - } - } - - virtual bool notifyRsrcStatus(Notification ¬ification); - - inline virtual void setIPAddresses(uint32_t &v4, char* v6) - { v4 = ID; memcpy(v6, mIPv6Addr, sizeof(mIPv6Addr)); } - - inline virtual void setIPAddresses(struct sockaddr_storage& addr) - { addr.ss_family = AF_INET6;/*todo: convert mIPv6Addr into addr */ } - - virtual Subscriber* clone() - { - return new BITSubscriber(mStateMachine, ID, mIPv6Addr); - } - - virtual bool equals(const Subscriber *s) const; - inline virtual ~BITSubscriber(){} -}; - -// ATLSubscriber, created with requests from ATL -struct ATLSubscriber : public Subscriber { - const LocEngAdapter* mLocAdapter; - const bool mBackwardCompatibleMode; - inline ATLSubscriber(const int id, - const AgpsStateMachine* stateMachine, - const LocEngAdapter* adapter, - const bool compatibleMode) : - Subscriber(id, stateMachine), mLocAdapter(adapter), - mBackwardCompatibleMode(compatibleMode){} - virtual bool notifyRsrcStatus(Notification ¬ification); - - inline virtual void setIPAddresses(uint32_t &v4, char* v6) - { v4 = INADDR_NONE; v6[0] = 0; } - - inline virtual void setIPAddresses(struct sockaddr_storage& addr) - { addr.ss_family = AF_INET6; } - - inline virtual Subscriber* clone() - { - return new ATLSubscriber(ID, mStateMachine, mLocAdapter, - mBackwardCompatibleMode); - } - inline virtual ~ATLSubscriber(){} -}; - -// WIFISubscriber, created with requests from MSAPM or QuIPC -struct WIFISubscriber : public Subscriber { - char * mSSID; - char * mPassword; - loc_if_req_sender_id_e_type senderId; - bool mIsInactive; - inline WIFISubscriber(const AgpsStateMachine* stateMachine, - char * ssid, char * password, loc_if_req_sender_id_e_type sender_id) : - Subscriber(sender_id, stateMachine), - mSSID(NULL == ssid ? NULL : new char[SSID_BUF_SIZE]), - mPassword(NULL == password ? NULL : new char[SSID_BUF_SIZE]), - senderId(sender_id) - { - if (NULL != mSSID) - strlcpy(mSSID, ssid, SSID_BUF_SIZE); - if (NULL != mPassword) - strlcpy(mPassword, password, SSID_BUF_SIZE); - mIsInactive = false; - } - - virtual bool notifyRsrcStatus(Notification ¬ification); - - inline virtual void setIPAddresses(uint32_t &v4, char* v6) {} - - inline virtual void setIPAddresses(struct sockaddr_storage& addr) - { addr.ss_family = AF_INET6; } - - inline virtual void setWifiInfo(char* ssid, char* password) - { - if (NULL != mSSID) - strlcpy(ssid, mSSID, SSID_BUF_SIZE); - else - ssid[0] = '\0'; - if (NULL != mPassword) - strlcpy(password, mPassword, SSID_BUF_SIZE); - else - password[0] = '\0'; - } - - inline virtual bool waitForCloseComplete() { return true; } - - inline virtual void setInactive() { mIsInactive = true; } - inline virtual bool isInactive() { return mIsInactive; } - - virtual Subscriber* clone() - { - return new WIFISubscriber(mStateMachine, mSSID, mPassword, senderId); - } - inline virtual ~WIFISubscriber(){} -}; - -struct DSSubscriber : public Subscriber { - bool mIsInactive; - inline DSSubscriber(const AgpsStateMachine *stateMachine, - const int id) : - Subscriber(id, stateMachine) - { - mIsInactive = false; - } - inline virtual void setIPAddresses(uint32_t &v4, char* v6) {} - inline virtual void setIPAddresses(struct sockaddr_storage& addr) - { addr.ss_family = AF_INET6; } - virtual Subscriber* clone() - {return new DSSubscriber(mStateMachine, ID);} - virtual bool notifyRsrcStatus(Notification ¬ification); - inline virtual bool waitForCloseComplete() { return true; } - virtual void setInactive(); - inline virtual bool isInactive() - { return mIsInactive; } - inline virtual ~DSSubscriber(){} - inline virtual char *whoami() {return (char*)"DSSubscriber";} -}; - -#endif //__LOC_ENG_AGPS_H__ diff --git a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp b/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp deleted file mode 100644 index 5510fc5..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn.cpp +++ /dev/null @@ -1,269 +0,0 @@ -/* Copyright (c) 2011-2012,2014 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. - * - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include "loc_eng_dmn_conn_glue_msg.h" -#include "loc_eng_dmn_conn_handler.h" -#include "loc_eng_dmn_conn.h" -#include "loc_eng_msg.h" - -static int loc_api_server_msgqid; -static int loc_api_resp_msgqid; -static int quipc_msgqid; -static int msapm_msgqid; -static int msapu_msgqid; - -static const char * global_loc_api_q_path = GPSONE_LOC_API_Q_PATH; -static const char * global_loc_api_resp_q_path = GPSONE_LOC_API_RESP_Q_PATH; -static const char * global_quipc_ctrl_q_path = QUIPC_CTRL_Q_PATH; -static const char * global_msapm_ctrl_q_path = MSAPM_CTRL_Q_PATH; -static const char * global_msapu_ctrl_q_path = MSAPU_CTRL_Q_PATH; - -static int loc_api_server_proc_init(void *context) -{ - loc_api_server_msgqid = loc_eng_dmn_conn_glue_msgget(global_loc_api_q_path, O_RDWR); - //change mode/group for the global_loc_api_q_path pipe - int result = chmod (global_loc_api_q_path, 0660); - if (result != 0) - { - LOC_LOGE("failed to change mode for %s, error = %s\n", global_loc_api_q_path, strerror(errno)); - } - - struct group * gps_group = getgrnam("gps"); - if (gps_group != NULL) - { - result = chown (global_loc_api_q_path, -1, gps_group->gr_gid); - if (result != 0) - { - LOC_LOGE("chown for pipe failed, pipe %s, gid = %d, result = %d, error = %s\n", - global_loc_api_q_path, gps_group->gr_gid, result, strerror(errno)); - } - } - else - { - LOC_LOGE("getgrnam for gps failed, error code = %d\n", errno); - } - - loc_api_resp_msgqid = loc_eng_dmn_conn_glue_msgget(global_loc_api_resp_q_path, O_RDWR); - - //change mode/group for the global_loc_api_resp_q_path pipe - result = chmod (global_loc_api_resp_q_path, 0660); - if (result != 0) - { - LOC_LOGE("failed to change mode for %s, error = %s\n", global_loc_api_resp_q_path, strerror(errno)); - } - - if (gps_group != NULL) - { - result = chown (global_loc_api_resp_q_path, -1, gps_group->gr_gid); - if (result != 0) - { - LOC_LOGE("chown for pipe failed, pipe %s, gid = %d, result = %d, error = %s\n", - global_loc_api_resp_q_path, - gps_group->gr_gid, result, strerror(errno)); - } - } - - quipc_msgqid = loc_eng_dmn_conn_glue_msgget(global_quipc_ctrl_q_path, O_RDWR); - msapm_msgqid = loc_eng_dmn_conn_glue_msgget(global_msapm_ctrl_q_path , O_RDWR); - msapu_msgqid = loc_eng_dmn_conn_glue_msgget(global_msapu_ctrl_q_path , O_RDWR); - - LOC_LOGD("%s:%d] loc_api_server_msgqid = %d\n", __func__, __LINE__, loc_api_server_msgqid); - return 0; -} - -static int loc_api_server_proc_pre(void *context) -{ - return 0; -} - -static int loc_api_server_proc(void *context) -{ - int length, sz; - int result = 0; - static int cnt = 0; - struct ctrl_msgbuf * p_cmsgbuf; - struct ctrl_msgbuf cmsg_resp; - - sz = sizeof(struct ctrl_msgbuf) + 256; - p_cmsgbuf = (struct ctrl_msgbuf *) malloc(sz); - - if (!p_cmsgbuf) { - LOC_LOGE("%s:%d] Out of memory\n", __func__, __LINE__); - return -1; - } - - cnt ++; - LOC_LOGD("%s:%d] %d listening on %s...\n", __func__, __LINE__, cnt, (char *) context); - length = loc_eng_dmn_conn_glue_msgrcv(loc_api_server_msgqid, p_cmsgbuf, sz); - if (length <= 0) { - free(p_cmsgbuf); - LOC_LOGE("%s:%d] fail receiving msg from gpsone_daemon, retry later\n", __func__, __LINE__); - usleep(1000); - return -1; - } - - LOC_LOGD("%s:%d] received ctrl_type = %d\n", __func__, __LINE__, p_cmsgbuf->ctrl_type); - switch(p_cmsgbuf->ctrl_type) { - case GPSONE_LOC_API_IF_REQUEST: - result = loc_eng_dmn_conn_loc_api_server_if_request_handler(p_cmsgbuf, length); - break; - - case GPSONE_LOC_API_IF_RELEASE: - result = loc_eng_dmn_conn_loc_api_server_if_release_handler(p_cmsgbuf, length); - break; - - case GPSONE_UNBLOCK: - LOC_LOGD("%s:%d] GPSONE_UNBLOCK\n", __func__, __LINE__); - break; - - default: - LOC_LOGE("%s:%d] unsupported ctrl_type = %d\n", - __func__, __LINE__, p_cmsgbuf->ctrl_type); - break; - } - - free(p_cmsgbuf); - return 0; -} - -static int loc_api_server_proc_post(void *context) -{ - LOC_LOGD("%s:%d]\n", __func__, __LINE__); - loc_eng_dmn_conn_glue_msgremove( global_loc_api_q_path, loc_api_server_msgqid); - loc_eng_dmn_conn_glue_msgremove( global_loc_api_resp_q_path, loc_api_resp_msgqid); - loc_eng_dmn_conn_glue_msgremove( global_quipc_ctrl_q_path, quipc_msgqid); - loc_eng_dmn_conn_glue_msgremove( global_msapm_ctrl_q_path, msapm_msgqid); - loc_eng_dmn_conn_glue_msgremove( global_msapu_ctrl_q_path, msapu_msgqid); - return 0; -} - -static int loc_eng_dmn_conn_unblock_proc(void) -{ - struct ctrl_msgbuf cmsgbuf; - cmsgbuf.ctrl_type = GPSONE_UNBLOCK; - LOC_LOGD("%s:%d]\n", __func__, __LINE__); - loc_eng_dmn_conn_glue_msgsnd(loc_api_server_msgqid, & cmsgbuf, sizeof(cmsgbuf)); - return 0; -} - -static struct loc_eng_dmn_conn_thelper thelper; - -int loc_eng_dmn_conn_loc_api_server_launch(thelper_create_thread create_thread_cb, - const char * loc_api_q_path, const char * resp_q_path, void *agps_handle) -{ - int result; - - loc_api_handle = agps_handle; - - if (loc_api_q_path) global_loc_api_q_path = loc_api_q_path; - if (resp_q_path) global_loc_api_resp_q_path = resp_q_path; - - result = loc_eng_dmn_conn_launch_thelper( &thelper, - loc_api_server_proc_init, - loc_api_server_proc_pre, - loc_api_server_proc, - loc_api_server_proc_post, - create_thread_cb, - (char *) global_loc_api_q_path); - if (result != 0) { - LOC_LOGE("%s:%d]\n", __func__, __LINE__); - return -1; - } - return 0; -} - -int loc_eng_dmn_conn_loc_api_server_unblock(void) -{ - loc_eng_dmn_conn_unblock_thelper(&thelper); - loc_eng_dmn_conn_unblock_proc(); - return 0; -} - -int loc_eng_dmn_conn_loc_api_server_join(void) -{ - loc_eng_dmn_conn_join_thelper(&thelper); - return 0; -} - -int loc_eng_dmn_conn_loc_api_server_data_conn(int sender_id, int status) { - struct ctrl_msgbuf cmsgbuf; - LOC_LOGD("%s:%d] quipc_msgqid = %d\n", __func__, __LINE__, quipc_msgqid); - cmsgbuf.ctrl_type = GPSONE_LOC_API_RESPONSE; - cmsgbuf.cmsg.cmsg_response.result = status; - switch (sender_id) { - case LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC: { - LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC", __func__, __LINE__); - if (loc_eng_dmn_conn_glue_msgsnd(quipc_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) { - LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__); - return -1; - } - break; - } - case LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM: { - LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM", __func__, __LINE__); - if (loc_eng_dmn_conn_glue_msgsnd(msapm_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) { - LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__); - return -1; - } - break; - } - case LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU: { - LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU", __func__, __LINE__); - if (loc_eng_dmn_conn_glue_msgsnd(msapu_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) { - LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__); - return -1; - } - break; - } - case LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON: { - LOC_LOGD("%s:%d] sender_id = LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON", __func__, __LINE__); - if (loc_eng_dmn_conn_glue_msgsnd(loc_api_resp_msgqid, & cmsgbuf, sizeof(struct ctrl_msgbuf)) < 0) { - LOC_LOGD("%s:%d] error! conn_glue_msgsnd failed\n", __func__, __LINE__); - return -1; - } - break; - } - default: { - LOC_LOGD("%s:%d] invalid sender ID!", __func__, __LINE__); - } - } - return 0; -} - diff --git a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c b/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c deleted file mode 100644 index e947fa1..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_msg.c +++ /dev/null @@ -1,222 +0,0 @@ -/* Copyright (c) 2011,2014 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. - * - */ -#include -#include - -#include - -#include -#include "loc_eng_dmn_conn_glue_msg.h" -#include "loc_eng_dmn_conn_handler.h" - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_msgget - -DESCRIPTION - This function get a message queue - - q_path - name path of the message queue - mode - - -DEPENDENCIES - None - -RETURN VALUE - message queue id - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_msgget(const char * q_path, int mode) -{ - int msgqid; - msgqid = loc_eng_dmn_conn_glue_pipeget(q_path, mode); - return msgqid; -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_msgremove - -DESCRIPTION - remove a message queue - - q_path - name path of the message queue - msgqid - message queue id - -DEPENDENCIES - None - -RETURN VALUE - 0: success or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_msgremove(const char * q_path, int msgqid) -{ - int result; - result = loc_eng_dmn_conn_glue_piperemove(q_path, msgqid); - return result; -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_msgsnd - -DESCRIPTION - Send a message - - msgqid - message queue id - msgp - pointer to the message to be sent - msgsz - size of the message - -DEPENDENCIES - None - -RETURN VALUE - number of bytes sent out or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_msgsnd(int msgqid, const void * msgp, size_t msgsz) -{ - int result; - struct ctrl_msgbuf *pmsg = (struct ctrl_msgbuf *) msgp; - pmsg->msgsz = msgsz; - - result = loc_eng_dmn_conn_glue_pipewrite(msgqid, msgp, msgsz); - if (result != (int) msgsz) { - LOC_LOGE("%s:%d] pipe broken %d, msgsz = %d\n", __func__, __LINE__, result, (int) msgsz); - return -1; - } - - return result; -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_msgrcv - -DESCRIPTION - receive a message - - msgqid - message queue id - msgp - pointer to the buffer to hold the message - msgsz - size of the buffer - -DEPENDENCIES - None - -RETURN VALUE - number of bytes received or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_msgrcv(int msgqid, void *msgp, size_t msgbufsz) -{ - int result; - struct ctrl_msgbuf *pmsg = (struct ctrl_msgbuf *) msgp; - - result = loc_eng_dmn_conn_glue_piperead(msgqid, &(pmsg->msgsz), sizeof(pmsg->msgsz)); - if (result != sizeof(pmsg->msgsz)) { - LOC_LOGE("%s:%d] pipe broken %d\n", __func__, __LINE__, result); - return -1; - } - - if (msgbufsz < pmsg->msgsz) { - LOC_LOGE("%s:%d] msgbuf is too small %d < %d\n", __func__, __LINE__, (int) msgbufsz, (int) pmsg->msgsz); - return -1; - } - - result = loc_eng_dmn_conn_glue_piperead(msgqid, (uint8_t *) msgp + sizeof(pmsg->msgsz), pmsg->msgsz - sizeof(pmsg->msgsz)); - if (result != (int) (pmsg->msgsz - sizeof(pmsg->msgsz))) { - LOC_LOGE("%s:%d] pipe broken %d, msgsz = %d\n", __func__, __LINE__, result, (int) pmsg->msgsz); - return -1; - } - - return pmsg->msgsz; -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_msgunblock - -DESCRIPTION - unblock a message queue - - msgqid - message queue id - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_msgunblock(int msgqid) -{ - return loc_eng_dmn_conn_glue_pipeunblock(msgqid); -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_msgflush - -DESCRIPTION - flush out the message in a queue - - msgqid - message queue id - -DEPENDENCIES - None - -RETURN VALUE - number of bytes that are flushed out. - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_msgflush(int msgqid) -{ - int length; - char buf[128]; - - do { - length = loc_eng_dmn_conn_glue_piperead(msgqid, buf, 128); - LOC_LOGD("%s:%d] %s\n", __func__, __LINE__, buf); - } while(length); - return length; -} - diff --git a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c b/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c deleted file mode 100644 index cbc4ea6..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.c +++ /dev/null @@ -1,215 +0,0 @@ -/* Copyright (c) 2011-2012,2014 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. - * - */ -#include -#include -#include - -// #include -#include -// #include -#include -#include - -#include "loc_eng_dmn_conn_glue_pipe.h" -#include -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_pipeget - -DESCRIPTION - create a named pipe. - - pipe_name - pipe name path - mode - mode - -DEPENDENCIES - None - -RETURN VALUE - 0: success or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_pipeget(const char * pipe_name, int mode) -{ - int fd; - int result; - - LOC_LOGD("%s, mode = %d\n", pipe_name, mode); - result = mkfifo(pipe_name, 0660); - - if ((result == -1) && (errno != EEXIST)) { - LOC_LOGE("failed: %s\n", strerror(errno)); - return result; - } - - // The mode in mkfifo is not honoured and does not provide the - // group permissions. Doing chmod to add group permissions. - result = chmod (pipe_name, 0660); - if (result != 0){ - LOC_LOGE ("%s failed to change mode for %s, error = %s\n", __func__, - pipe_name, strerror(errno)); - } - - fd = open(pipe_name, mode); - if (fd <= 0) - { - LOC_LOGE("failed: %s\n", strerror(errno)); - } - LOC_LOGD("fd = %d, %s\n", fd, pipe_name); - return fd; -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_piperemove - -DESCRIPTION - remove a pipe - - pipe_name - pipe name path - fd - fd for the pipe - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_piperemove(const char * pipe_name, int fd) -{ - close(fd); - if (pipe_name != NULL) { - unlink(pipe_name); - LOC_LOGD("fd = %d, %s\n", fd, pipe_name); - } - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_pipewrite - -DESCRIPTION - write to a pipe - - fd - fd of a pipe - buf - buffer for the data to write - sz - size of the data in buffer - -DEPENDENCIES - None - -RETURN VALUE - number of bytes written or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_pipewrite(int fd, const void * buf, size_t sz) -{ - int result; - - result = write(fd, buf, sz); - - /* @todo check for non EINTR & EAGAIN, shall not do select again, select_tut Law 7) */ - - /* LOC_LOGD("fd = %d, buf = 0x%lx, size = %d, result = %d\n", fd, (long) buf, (int) sz, (int) result); */ - return result; -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_piperead - -DESCRIPTION - read from a pipe - - fd - fd for the pipe - buf - buffer to hold the data read from pipe - sz - size of the buffer - -DEPENDENCIES - None - -RETURN VALUE - number of bytes read from pipe or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_piperead(int fd, void * buf, size_t sz) -{ - int len; - - len = read(fd, buf, sz); - - /* @todo check for non EINTR & EAGAIN, shall not do select again, select_tut Law 7) */ - - /* LOC_LOGD("fd = %d, buf = 0x%lx, size = %d, len = %d\n", fd, (long) buf, (int) sz, len); */ - return len; -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_glue_pipeunblock - -DESCRIPTION - unblock a pipe - - fd - fd for the pipe - -DEPENDENCIES - None - -RETURN VALUE - 0 for success or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_glue_pipeunblock(int fd) -{ - int result; - struct flock flock_v; - LOC_LOGD("\n"); -// result = fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NDELAY); - flock_v.l_type = F_UNLCK; - flock_v.l_len = 32; - result = fcntl(fd, F_SETLK, &flock_v); - if (result < 0) { - LOC_LOGE("fcntl failure, %s\n", strerror(errno)); - } - - return result; -} diff --git a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h b/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h deleted file mode 100644 index b2fa3a0..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_glue_pipe.h +++ /dev/null @@ -1,50 +0,0 @@ -/* Copyright (c) 2011, 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 LOC_ENG_DMN_CONN_GLUE_PIPE_H -#define LOC_ENG_DMN_CONN_GLUE_PIPE_H - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#include - -int loc_eng_dmn_conn_glue_pipeget(const char * pipe_name, int mode); -int loc_eng_dmn_conn_glue_piperemove(const char * pipe_name, int fd); -int loc_eng_dmn_conn_glue_pipewrite(int fd, const void * buf, size_t sz); -int loc_eng_dmn_conn_glue_piperead(int fd, void * buf, size_t sz); - -int loc_eng_dmn_conn_glue_pipeflush(int fd); -int loc_eng_dmn_conn_glue_pipeunblock(int fd); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* LOC_ENG_DMN_CONN_GLUE_PIPE_H */ diff --git a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp b/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp deleted file mode 100644 index 137f686..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.cpp +++ /dev/null @@ -1,236 +0,0 @@ -/* Copyright (c) 2011-2012,2014 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. - * - */ -#include -#include -#include -#include - -#include -#include "loc_eng_msg.h" -#include "loc_eng_dmn_conn.h" -#include "loc_eng_dmn_conn_handler.h" - -void* loc_api_handle = NULL; - -int loc_eng_dmn_conn_loc_api_server_if_request_handler(struct ctrl_msgbuf *pmsg, int len) -{ - LOC_LOGD("%s:%d]\n", __func__, __LINE__); -#ifndef DEBUG_DMN_LOC_API - if (NULL == loc_api_handle) { - LOC_LOGE("%s:%d] NO agps data handle\n", __func__, __LINE__); - return 1; - } - - if (NULL != loc_api_handle) { - AGpsExtType type; - switch (pmsg->cmsg.cmsg_if_request.type) { - case IF_REQUEST_TYPE_SUPL: - { - LOC_LOGD("IF_REQUEST_TYPE_SUPL"); - type = AGPS_TYPE_SUPL; - break; - } - case IF_REQUEST_TYPE_WIFI: - { - LOC_LOGD("IF_REQUEST_TYPE_WIFI"); - type = AGPS_TYPE_WIFI; - break; - } - case IF_REQUEST_TYPE_ANY: - { - LOC_LOGD("IF_REQUEST_TYPE_ANY"); - type = AGPS_TYPE_ANY; - break; - } - default: - { - LOC_LOGD("invalid IF_REQUEST_TYPE!"); - return -1; - } - } - switch (pmsg->cmsg.cmsg_if_request.sender_id) { - case IF_REQUEST_SENDER_ID_QUIPC: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_QUIPC"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - true); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_MSAPM: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPM"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - true); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_MSAPU: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPU"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - true); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_GPSONE_DAEMON: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_GPSONE_DAEMON"); - LocEngReqRelBIT* msg = - new LocEngReqRelBIT(loc_api_handle, - type, - pmsg->cmsg.cmsg_if_request.ipv4_addr, - (char*)pmsg->cmsg.cmsg_if_request.ipv6_addr, - true); - msg->send(); - break; - } - default: - { - LOC_LOGD("invalid IF_REQUEST_SENDER_ID!"); - return -1; - } - } - } - -#else - loc_eng_dmn_conn_loc_api_server_data_conn(LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, GPSONE_LOC_API_IF_REQUEST_SUCCESS); -#endif - return 0; -} - -int loc_eng_dmn_conn_loc_api_server_if_release_handler(struct ctrl_msgbuf *pmsg, int len) -{ - LOC_LOGD("%s:%d]\n", __func__, __LINE__); -#ifndef DEBUG_DMN_LOC_API - AGpsExtType type; - switch (pmsg->cmsg.cmsg_if_request.type) { - case IF_REQUEST_TYPE_SUPL: - { - LOC_LOGD("IF_REQUEST_TYPE_SUPL"); - type = AGPS_TYPE_SUPL; - break; - } - case IF_REQUEST_TYPE_WIFI: - { - LOC_LOGD("IF_REQUEST_TYPE_WIFI"); - type = AGPS_TYPE_WIFI; - break; - } - case IF_REQUEST_TYPE_ANY: - { - LOC_LOGD("IF_REQUEST_TYPE_ANY"); - type = AGPS_TYPE_ANY; - break; - } - default: - { - LOC_LOGD("invalid IF_REQUEST_TYPE!"); - return -1; - } - } - switch (pmsg->cmsg.cmsg_if_request.sender_id) { - case IF_REQUEST_SENDER_ID_QUIPC: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_QUIPC"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - false); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_MSAPM: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPM"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_MSAPM, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - false); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_MSAPU: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_MSAPU"); - LocEngReqRelWifi* msg = - new LocEngReqRelWifi(loc_api_handle, - type, - LOC_ENG_IF_REQUEST_SENDER_ID_MSAPU, - (char*)pmsg->cmsg.cmsg_if_request.ssid, - (char*)pmsg->cmsg.cmsg_if_request.password, - false); - msg->send(); - break; - } - case IF_REQUEST_SENDER_ID_GPSONE_DAEMON: - { - LOC_LOGD("IF_REQUEST_SENDER_ID_GPSONE_DAEMON"); - LocEngReqRelBIT* msg = - new LocEngReqRelBIT(loc_api_handle, - type, - pmsg->cmsg.cmsg_if_request.ipv4_addr, - (char*)pmsg->cmsg.cmsg_if_request.ipv6_addr, - false); - msg->send(); - break; - } - default: - { - LOC_LOGD("invalid IF_REQUEST_SENDER_ID!"); - return -1; - } - } -#else - loc_eng_dmn_conn_loc_api_server_data_conn(LOC_ENG_IF_REQUEST_SENDER_ID_GPSONE_DAEMON, GPSONE_LOC_API_IF_RELEASE_SUCCESS); -#endif - return 0; -} - diff --git a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h b/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h deleted file mode 100644 index 1c0edd5..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_handler.h +++ /dev/null @@ -1,106 +0,0 @@ -/* Copyright (c) 2011-2012, 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 LOC_ENG_DATA_SERVER_HANDLER -#define LOC_ENG_DATA_SERVER_HANDLER - -#include -#include - -//for SSID_BUF_SIZE -#include - -#ifndef SSID_BUF_SIZE - #define SSID_BUF_SIZE (32+1) -#endif - -enum { - /* 0x0 - 0xEF is reserved for daemon internal */ - GPSONE_LOC_API_IF_REQUEST = 0xF0, - GPSONE_LOC_API_IF_RELEASE, - GPSONE_LOC_API_RESPONSE, - GPSONE_UNBLOCK, -}; - -enum { - GPSONE_LOC_API_IF_REQUEST_SUCCESS = 0xF0, - GPSONE_LOC_API_IF_RELEASE_SUCCESS, - GPSONE_LOC_API_IF_FAILURE, -}; - - -struct ctrl_msg_response { - int result; -}; - -struct ctrl_msg_unblock { - int reserved; -}; - -typedef enum { - IF_REQUEST_TYPE_SUPL = 0, - IF_REQUEST_TYPE_WIFI, - IF_REQUEST_TYPE_ANY -} ctrl_if_req_type_e_type; - -typedef enum { - IF_REQUEST_SENDER_ID_QUIPC = 0, - IF_REQUEST_SENDER_ID_MSAPM, - IF_REQUEST_SENDER_ID_MSAPU, - IF_REQUEST_SENDER_ID_GPSONE_DAEMON, - IF_REQUEST_SENDER_ID_MODEM -} ctrl_if_req_sender_id_e_type; - -struct ctrl_msg_if_request { - ctrl_if_req_type_e_type type; - ctrl_if_req_sender_id_e_type sender_id; - unsigned long ipv4_addr; - unsigned char ipv6_addr[16]; - char ssid[SSID_BUF_SIZE]; - char password[SSID_BUF_SIZE]; -}; - -/* do not change this structure */ -struct ctrl_msgbuf { - size_t msgsz; - uint16_t reserved1; - uint32_t reserved2; - uint8_t ctrl_type; - union { - struct ctrl_msg_response cmsg_response; - struct ctrl_msg_unblock cmsg_unblock; - struct ctrl_msg_if_request cmsg_if_request; - } cmsg; -}; - -extern void* loc_api_handle; - -int loc_eng_dmn_conn_loc_api_server_if_request_handler(struct ctrl_msgbuf *pmsg, int len); -int loc_eng_dmn_conn_loc_api_server_if_release_handler(struct ctrl_msgbuf *pmsg, int len); - -#endif /* LOC_ENG_DATA_SERVER_HANDLER */ diff --git a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c b/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c deleted file mode 100644 index b30f6d7..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.c +++ /dev/null @@ -1,398 +0,0 @@ -/* Copyright (c) 2011,2014 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. - * - */ -#include - -#include -#include "loc_eng_dmn_conn_thread_helper.h" - -/*=========================================================================== -FUNCTION thelper_signal_init - -DESCRIPTION - This function will initialize the conditional variable resources. - - thelper - thelper instance - -DEPENDENCIES - None - -RETURN VALUE - 0: success or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int thelper_signal_init(struct loc_eng_dmn_conn_thelper * thelper) -{ - int result; - thelper->thread_exit = 0; - thelper->thread_ready = 0; - result = pthread_cond_init( &thelper->thread_cond, NULL); - if (result) { - return result; - } - - result = pthread_mutex_init(&thelper->thread_mutex, NULL); - if (result) { - pthread_cond_destroy(&thelper->thread_cond); - } - return result; -} - -/*=========================================================================== -FUNCTION - -DESCRIPTION - This function will destroy the conditional variable resources - - thelper - pointer to thelper instance - -DEPENDENCIES - None - -RETURN VALUE - 0: success or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int thelper_signal_destroy(struct loc_eng_dmn_conn_thelper * thelper) -{ - int result, ret_result = 0; - result = pthread_cond_destroy( &thelper->thread_cond); - if (result) { - ret_result = result; - } - - result = pthread_mutex_destroy(&thelper->thread_mutex); - if (result) { - ret_result = result; - } - - return ret_result; -} - -/*=========================================================================== -FUNCTION thelper_signal_wait - -DESCRIPTION - This function will be blocked on the conditional variable until thelper_signal_ready - is called - - thelper - pointer to thelper instance - -DEPENDENCIES - None - -RETURN VALUE - 0: success or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int thelper_signal_wait(struct loc_eng_dmn_conn_thelper * thelper) -{ - int result = 0; - - pthread_mutex_lock(&thelper->thread_mutex); - if (!thelper->thread_ready && !thelper->thread_exit) { - result = pthread_cond_wait(&thelper->thread_cond, &thelper->thread_mutex); - } - - if (thelper->thread_exit) { - result = -1; - } - pthread_mutex_unlock(&thelper->thread_mutex); - - return result; -} - -/*=========================================================================== -FUNCTION thelper_signal_ready - -DESCRIPTION - This function will wake up the conditional variable - - thelper - pointer to thelper instance - -DEPENDENCIES - None - -RETURN VALUE - 0: success or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int thelper_signal_ready(struct loc_eng_dmn_conn_thelper * thelper) -{ - int result; - - LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper); - - pthread_mutex_lock(&thelper->thread_mutex); - thelper->thread_ready = 1; - result = pthread_cond_signal(&thelper->thread_cond); - pthread_mutex_unlock(&thelper->thread_mutex); - - return result; -} - -/*=========================================================================== -FUNCTION thelper_signal_block - -DESCRIPTION - This function will set the thread ready to 0 to block the thelper_signal_wait - - thelper - pointer to thelper instance - -DEPENDENCIES - None - -RETURN VALUE - if thread_ready is set - -SIDE EFFECTS - N/A - -===========================================================================*/ -int thelper_signal_block(struct loc_eng_dmn_conn_thelper * thelper) -{ - int result = thelper->thread_ready; - - LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper); - - pthread_mutex_lock(&thelper->thread_mutex); - thelper->thread_ready = 0; - pthread_mutex_unlock(&thelper->thread_mutex); - - return result; -} - -/*=========================================================================== -FUNCTION thelper_main - -DESCRIPTION - This function is the main thread. It will be launched as a child thread - - data - pointer to the instance - -DEPENDENCIES - None - -RETURN VALUE - NULL - -SIDE EFFECTS - N/A - -===========================================================================*/ -static void * thelper_main(void *data) -{ - int result = 0; - struct loc_eng_dmn_conn_thelper * thelper = (struct loc_eng_dmn_conn_thelper *) data; - - if (thelper->thread_proc_init) { - result = thelper->thread_proc_init(thelper->thread_context); - if (result < 0) { - thelper->thread_exit = 1; - thelper_signal_ready(thelper); - LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper); - return NULL; - } - } - - thelper_signal_ready(thelper); - - if (thelper->thread_proc_pre) { - result = thelper->thread_proc_pre(thelper->thread_context); - if (result < 0) { - thelper->thread_exit = 1; - LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper); - return NULL; - } - } - - do { - if (thelper->thread_proc) { - result = thelper->thread_proc(thelper->thread_context); - if (result < 0) { - thelper->thread_exit = 1; - LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper); - } - } - } while (thelper->thread_exit == 0); - - if (thelper->thread_proc_post) { - result = thelper->thread_proc_post(thelper->thread_context); - } - - if (result != 0) { - LOC_LOGE("%s:%d] error: 0x%lx\n", __func__, __LINE__, (long) thelper); - } - return NULL; -} - -static void thelper_main_2(void *data) -{ - thelper_main(data); - return; -} - - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_launch_thelper - -DESCRIPTION - This function will initialize the thread context and launch the thelper_main - - thelper - pointer to thelper instance - thread_proc_init - The initialization function pointer - thread_proc_pre - The function to call before task loop and after initialization - thread_proc - The task loop - thread_proc_post - The function to call after the task loop - context - the context for the above four functions - -DEPENDENCIES - None - -RETURN VALUE - 0: success or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_launch_thelper(struct loc_eng_dmn_conn_thelper * thelper, - int (*thread_proc_init) (void * context), - int (*thread_proc_pre) (void * context), - int (*thread_proc) (void * context), - int (*thread_proc_post) (void * context), - thelper_create_thread create_thread_cb, - void * context) -{ - int result; - - thelper_signal_init(thelper); - - if (context) { - thelper->thread_context = context; - } - - thelper->thread_proc_init = thread_proc_init; - thelper->thread_proc_pre = thread_proc_pre; - thelper->thread_proc = thread_proc; - thelper->thread_proc_post = thread_proc_post; - - LOC_LOGD("%s:%d] 0x%lx call pthread_create\n", __func__, __LINE__, (long) thelper); - if (create_thread_cb) { - result = 0; - thelper->thread_id = create_thread_cb("loc_eng_dmn_conn", - thelper_main_2, (void *)thelper); - } else { - result = pthread_create(&thelper->thread_id, NULL, - thelper_main, (void *)thelper); - } - - if (result != 0) { - LOC_LOGE("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper); - return -1; - } - - LOC_LOGD("%s:%d] 0x%lx pthread_create done\n", __func__, __LINE__, (long) thelper); - - thelper_signal_wait(thelper); - - LOC_LOGD("%s:%d] 0x%lx pthread ready\n", __func__, __LINE__, (long) thelper); - return thelper->thread_exit; -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_unblock_thelper - -DESCRIPTION - This function unblocks thelper_main to release the thread - - thelper - pointer to thelper instance - -DEPENDENCIES - None - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_unblock_thelper(struct loc_eng_dmn_conn_thelper * thelper) -{ - LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper); - thelper->thread_exit = 1; - return 0; -} - -/*=========================================================================== -FUNCTION loc_eng_dmn_conn_join_thelper - - thelper - pointer to thelper instance - -DESCRIPTION - This function will wait for the thread of thelper_main to finish - -DEPENDENCIES - None - -RETURN VALUE - 0: success or negative value for failure - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_dmn_conn_join_thelper(struct loc_eng_dmn_conn_thelper * thelper) -{ - int result; - - LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper); - result = pthread_join(thelper->thread_id, NULL); - if (result != 0) { - LOC_LOGE("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper); - } - LOC_LOGD("%s:%d] 0x%lx\n", __func__, __LINE__, (long) thelper); - - thelper_signal_destroy(thelper); - - return result; -} - diff --git a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h b/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h deleted file mode 100644 index 89e598b..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_dmn_conn_thread_helper.h +++ /dev/null @@ -1,74 +0,0 @@ -/* Copyright (c) 2011, 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 __LOC_ENG_DMN_CONN_THREAD_HELPER_H__ -#define __LOC_ENG_DMN_CONN_THREAD_HELPER_H__ - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#include - -struct loc_eng_dmn_conn_thelper { - unsigned char thread_exit; - unsigned char thread_ready; - pthread_cond_t thread_cond; - pthread_mutex_t thread_mutex; - pthread_t thread_id; - void * thread_context; - int (*thread_proc_init) (void * context); - int (*thread_proc_pre) (void * context); - int (*thread_proc) (void * context); - int (*thread_proc_post) (void * context); -}; - -typedef pthread_t (* thelper_create_thread)(const char* name, void (*start)(void *), void* arg); -int loc_eng_dmn_conn_launch_thelper(struct loc_eng_dmn_conn_thelper * thelper, - int (*thread_proc_init) (void * context), - int (*thread_proc_pre) (void * context), - int (*thread_proc) (void * context), - int (*thread_proc_post) (void * context), - thelper_create_thread create_thread_cb, - void * context); - -int loc_eng_dmn_conn_unblock_thelper(struct loc_eng_dmn_conn_thelper * thelper); -int loc_eng_dmn_conn_join_thelper(struct loc_eng_dmn_conn_thelper * thelper); - -/* if only need to use signal */ -int thelper_signal_init(struct loc_eng_dmn_conn_thelper * thelper); -int thelper_signal_destroy(struct loc_eng_dmn_conn_thelper * thelper); -int thelper_signal_wait(struct loc_eng_dmn_conn_thelper * thelper); -int thelper_signal_ready(struct loc_eng_dmn_conn_thelper * thelper); -int thelper_signal_block(struct loc_eng_dmn_conn_thelper * thelper); - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* __LOC_ENG_DMN_CONN_THREAD_HELPER_H__ */ diff --git a/gps/loc_api/libloc_api_50001/loc_eng_msg.h b/gps/loc_api/libloc_api_50001/loc_eng_msg.h deleted file mode 100644 index 2fa9b42..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_msg.h +++ /dev/null @@ -1,306 +0,0 @@ -/* Copyright (c) 2011-2014, 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 LOC_ENG_MSG_H -#define LOC_ENG_MSG_H - - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#ifndef SSID_BUF_SIZE - #define SSID_BUF_SIZE (32+1) -#endif -#if defined(USE_GLIB) && !defined(OFF_TARGET) - -#include - -#endif /* USE_GLIB */ -#include "platform_lib_includes.h" - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -using namespace loc_core; - -struct LocEngPositionMode : public LocMsg { - LocEngAdapter* mAdapter; - const LocPosMode mPosMode; - LocEngPositionMode(LocEngAdapter* adapter, LocPosMode &mode); - virtual void proc() const; - virtual void log() const; - void send() const; -}; - - -struct LocEngStartFix : public LocMsg { - LocEngAdapter* mAdapter; - LocEngStartFix(LocEngAdapter* adapter); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngStopFix : public LocMsg { - LocEngAdapter* mAdapter; - LocEngStopFix(LocEngAdapter* adapter); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngReportPosition : public LocMsg { - LocAdapterBase* mAdapter; - const UlpLocation mLocation; - const GpsLocationExtended mLocationExtended; - const void* mLocationExt; - const enum loc_sess_status mStatus; - const LocPosTechMask mTechMask; - LocEngReportPosition(LocAdapterBase* adapter, - UlpLocation &loc, - GpsLocationExtended &locExtended, - void* locExt, - enum loc_sess_status st, - LocPosTechMask technology); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngReportSv : public LocMsg { - LocAdapterBase* mAdapter; - const GnssSvStatus mSvStatus; - const GpsLocationExtended mLocationExtended; - const void* mSvExt; - LocEngReportSv(LocAdapterBase* adapter, - GnssSvStatus &sv, - GpsLocationExtended &locExtended, - void* svExtended); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngReportStatus : public LocMsg { - LocAdapterBase* mAdapter; - const GpsStatusValue mStatus; - LocEngReportStatus(LocAdapterBase* adapter, - GpsStatusValue engineStatus); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngReportNmea : public LocMsg { - void* mLocEng; - char* const mNmea; - const int mLen; - LocEngReportNmea(void* locEng, - const char* data, int len); - inline virtual ~LocEngReportNmea() - { - delete[] mNmea; - } - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngReportXtraServer : public LocMsg { - void* mLocEng; - int mMaxLen; - char *mServers; - LocEngReportXtraServer(void* locEng, - const char *url1, const char *url2, - const char *url3, const int maxlength); - inline virtual ~LocEngReportXtraServer() - { - delete[] mServers; - } - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngSuplEsOpened : public LocMsg { - void* mLocEng; - LocEngSuplEsOpened(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngSuplEsClosed : public LocMsg { - void* mLocEng; - LocEngSuplEsClosed(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngRequestSuplEs : public LocMsg { - void* mLocEng; - const int mID; - LocEngRequestSuplEs(void* locEng, int id); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngRequestATL : public LocMsg { - void* mLocEng; - const int mID; - const AGpsExtType mType; - LocEngRequestATL(void* locEng, int id, - AGpsExtType agps_type); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngReleaseATL : public LocMsg { - void* mLocEng; - const int mID; - LocEngReleaseATL(void* locEng, int id); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngReqRelBIT : public LocMsg { - void* mLocEng; - const AGpsExtType mType; - const int mIPv4Addr; - char* const mIPv6Addr; - const bool mIsReq; - LocEngReqRelBIT(void* instance, AGpsExtType type, - int ipv4, char* ipv6, bool isReq); - virtual ~LocEngReqRelBIT(); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngReqRelWifi : public LocMsg { - void* mLocEng; - const AGpsExtType mType; - const loc_if_req_sender_id_e_type mSenderId; - char* const mSSID; - char* const mPassword; - const bool mIsReq; - LocEngReqRelWifi(void* locEng, AGpsExtType type, - loc_if_req_sender_id_e_type sender_id, - char* s, char* p, bool isReq); - virtual ~LocEngReqRelWifi(); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngRequestXtra : public LocMsg { - void* mLocEng; - LocEngRequestXtra(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngRequestTime : public LocMsg { - void* mLocEng; - LocEngRequestTime(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngRequestNi : public LocMsg { - void* mLocEng; - const GpsNiNotification mNotify; - const void *mPayload; - LocEngRequestNi(void* locEng, - GpsNiNotification ¬if, - const void* data); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngDown : public LocMsg { - void* mLocEng; - LocEngDown(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngUp : public LocMsg { - void* mLocEng; - LocEngUp(void* locEng); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -struct LocEngGetZpp : public LocMsg { - LocEngAdapter* mAdapter; - LocEngGetZpp(LocEngAdapter* adapter); - virtual void proc() const; - void locallog() const; - virtual void log() const; - void send() const; -}; - -struct LocEngReportGnssMeasurement : public LocMsg { - void* mLocEng; - const GnssData mGnssData; - LocEngReportGnssMeasurement(void* locEng, - GnssData &gnssData); - virtual void proc() const; - void locallog() const; - virtual void log() const; -}; - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* LOC_ENG_MSG_H */ diff --git a/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp b/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp deleted file mode 100644 index 9b454c6..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_ni.cpp +++ /dev/null @@ -1,413 +0,0 @@ -/* Copyright (c) 2009-2014, 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_eng" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include - -using namespace loc_core; - -/*============================================================================= - * - * DATA DECLARATION - * - *============================================================================*/ - -/*============================================================================= - * - * FUNCTION DECLARATIONS - * - *============================================================================*/ -static void* ni_thread_proc(void *args); - -struct LocEngInformNiResponse : public LocMsg { - LocEngAdapter* mAdapter; - const GpsUserResponseType mResponse; - const void *mPayload; - inline LocEngInformNiResponse(LocEngAdapter* adapter, - GpsUserResponseType resp, - const void* data) : - LocMsg(), mAdapter(adapter), - mResponse(resp), mPayload(data) - { - locallog(); - } - inline ~LocEngInformNiResponse() - { - // this is a bit weird since mPayload is not - // allocated by this class. But there is no better way. - // mPayload actually won't be NULL here. - free((void*)mPayload); - } - inline virtual void proc() const - { - mAdapter->informNiResponse(mResponse, mPayload); - } - inline void locallog() const - { - LOC_LOGV("LocEngInformNiResponse - " - "response: %s\n mPayload: %p", - loc_get_ni_response_name(mResponse), - mPayload); - } - inline virtual void log() const - { - locallog(); - } -}; - -/*=========================================================================== - -FUNCTION loc_eng_ni_request_handler - -DESCRIPTION - Displays the NI request and awaits user input. If a previous request is - in session, it is ignored. - -RETURN VALUE - none - -===========================================================================*/ -void loc_eng_ni_request_handler(loc_eng_data_s_type &loc_eng_data, - const GpsNiNotification *notif, - const void* passThrough) -{ - ENTRY_LOG(); - char lcs_addr[32]; // Decoded LCS address for UMTS CP NI - loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data; - loc_eng_ni_session_s_type* pSession = NULL; - - if (NULL == loc_eng_data.ni_notify_cb) { - EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet."); - return; - } - - if (notif->ni_type == GPS_NI_TYPE_EMERGENCY_SUPL) { - if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) { - LOC_LOGW("loc_eng_ni_request_handler, supl es NI in progress, new supl es NI ignored, type: %d", - notif->ni_type); - if (NULL != passThrough) { - free((void*)passThrough); - } - } else { - pSession = &loc_eng_ni_data_p->sessionEs; - } - } else { - if (NULL != loc_eng_ni_data_p->session.rawRequest || - NULL != loc_eng_ni_data_p->sessionEs.rawRequest) { - LOC_LOGW("loc_eng_ni_request_handler, supl NI in progress, new supl NI ignored, type: %d", - notif->ni_type); - if (NULL != passThrough) { - free((void*)passThrough); - } - } else { - pSession = &loc_eng_ni_data_p->session; - } - } - - - if (pSession) { - /* Save request */ - pSession->rawRequest = (void*)passThrough; - pSession->reqID = ++loc_eng_ni_data_p->reqIDCounter; - pSession->adapter = loc_eng_data.adapter; - - /* Fill in notification */ - ((GpsNiNotification*)notif)->notification_id = pSession->reqID; - - if (notif->notify_flags == GPS_NI_PRIVACY_OVERRIDE) - { - loc_eng_mute_one_session(loc_eng_data); - } - - /* Log requestor ID and text for debugging */ - LOC_LOGI("Notification: notif_type: %d, timeout: %d, default_resp: %d", notif->ni_type, notif->timeout, notif->default_response); - LOC_LOGI(" requestor_id: %s (encoding: %d)", notif->requestor_id, notif->requestor_id_encoding); - LOC_LOGI(" text: %s text (encoding: %d)", notif->text, notif->text_encoding); - if (notif->extras[0]) - { - LOC_LOGI(" extras: %s", notif->extras); - } - - /* For robustness, spawn a thread at this point to timeout to clear up the notification status, even though - * the OEM layer in java does not do so. - **/ - pSession->respTimeLeft = 5 + (notif->timeout != 0 ? notif->timeout : LOC_NI_NO_RESPONSE_TIME); - LOC_LOGI("Automatically sends 'no response' in %d seconds (to clear status)\n", pSession->respTimeLeft); - - int rc = 0; - rc = pthread_create(&pSession->thread, NULL, ni_thread_proc, pSession); - if (rc) - { - LOC_LOGE("Loc NI thread is not created.\n"); - } - rc = pthread_detach(pSession->thread); - if (rc) - { - LOC_LOGE("Loc NI thread is not detached.\n"); - } - - CALLBACK_LOG_CALLFLOW("ni_notify_cb - id", %d, notif->notification_id); - loc_eng_data.ni_notify_cb((GpsNiNotification*)notif, gps_conf.SUPL_ES != 0); - } - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== - -FUNCTION ni_thread_proc - -===========================================================================*/ -static void* ni_thread_proc(void *args) -{ - ENTRY_LOG(); - - loc_eng_ni_session_s_type* pSession = (loc_eng_ni_session_s_type*)args; - int rc = 0; /* return code from pthread calls */ - - struct timeval present_time; - struct timespec expire_time; - - LOC_LOGD("Starting Loc NI thread...\n"); - pthread_mutex_lock(&pSession->tLock); - /* Calculate absolute expire time */ - gettimeofday(&present_time, NULL); - expire_time.tv_sec = present_time.tv_sec + pSession->respTimeLeft; - expire_time.tv_nsec = present_time.tv_usec * 1000; - LOC_LOGD("ni_thread_proc-Time out set for abs time %ld with delay %d sec\n", - (long) expire_time.tv_sec, pSession->respTimeLeft ); - - while (!pSession->respRecvd) - { - rc = pthread_cond_timedwait(&pSession->tCond, - &pSession->tLock, - &expire_time); - if (rc == ETIMEDOUT) - { - pSession->resp = GPS_NI_RESPONSE_NORESP; - LOC_LOGD("ni_thread_proc-Thread time out after valting for specified time. Ret Val %d\n",rc ); - break; - } - } - LOC_LOGD("ni_thread_proc-Java layer has sent us a user response and return value from " - "pthread_cond_timedwait = %d\n",rc ); - pSession->respRecvd = FALSE; /* Reset the user response flag for the next session*/ - - LOC_LOGD("pSession->resp is %d\n",pSession->resp); - - // adding this check to support modem restart, in which case, we need the thread - // to exit without calling sending data. We made sure that rawRequest is NULL in - // loc_eng_ni_reset_on_engine_restart() - LocEngAdapter* adapter = pSession->adapter; - LocEngInformNiResponse *msg = NULL; - - if (NULL != pSession->rawRequest) { - if (pSession->resp != GPS_NI_RESPONSE_IGNORE) { - LOC_LOGD("pSession->resp != GPS_NI_RESPONSE_IGNORE \n"); - msg = new LocEngInformNiResponse(adapter, - pSession->resp, - pSession->rawRequest); - } else { - LOC_LOGD("this is the ignore reply for SUPL ES\n"); - free(pSession->rawRequest); - } - pSession->rawRequest = NULL; - } - pthread_mutex_unlock(&pSession->tLock); - - pSession->respTimeLeft = 0; - pSession->reqID = 0; - - if (NULL != msg) { - LOC_LOGD("ni_thread_proc: adapter->sendMsg(msg)\n"); - adapter->sendMsg(msg); - } - - EXIT_LOG(%s, VOID_RET); - return NULL; -} - -void loc_eng_ni_reset_on_engine_restart(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data; - - if (NULL == loc_eng_data.ni_notify_cb) { - EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet."); - return; - } - - // only if modem has requested but then died. - if (NULL != loc_eng_ni_data_p->sessionEs.rawRequest) { - free(loc_eng_ni_data_p->sessionEs.rawRequest); - loc_eng_ni_data_p->sessionEs.rawRequest = NULL; - - pthread_mutex_lock(&loc_eng_ni_data_p->sessionEs.tLock); - // the goal is to wake up ni_thread_proc - // and let it exit. - loc_eng_ni_data_p->sessionEs.respRecvd = TRUE; - pthread_cond_signal(&loc_eng_ni_data_p->sessionEs.tCond); - pthread_mutex_unlock(&loc_eng_ni_data_p->sessionEs.tLock); - } - - if (NULL != loc_eng_ni_data_p->session.rawRequest) { - free(loc_eng_ni_data_p->session.rawRequest); - loc_eng_ni_data_p->session.rawRequest = NULL; - - pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock); - // the goal is to wake up ni_thread_proc - // and let it exit. - loc_eng_ni_data_p->session.respRecvd = TRUE; - pthread_cond_signal(&loc_eng_ni_data_p->session.tCond); - pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock); - } - - EXIT_LOG(%s, VOID_RET); -} - -/*=========================================================================== -FUNCTION loc_eng_ni_init - -DESCRIPTION - This function initializes the NI interface - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_ni_init(loc_eng_data_s_type &loc_eng_data, GpsNiExtCallbacks *callbacks) -{ - ENTRY_LOG_CALLFLOW(); - - if(callbacks == NULL) - EXIT_LOG(%s, "loc_eng_ni_init: failed, cb is NULL"); - else if (NULL == callbacks->notify_cb) { - EXIT_LOG(%s, "loc_eng_ni_init: failed, no cb."); - } else if (NULL != loc_eng_data.ni_notify_cb) { - EXIT_LOG(%s, "loc_eng_ni_init: already inited."); - } else { - loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data; - loc_eng_ni_data_p->sessionEs.respTimeLeft = 0; - loc_eng_ni_data_p->sessionEs.respRecvd = FALSE; - loc_eng_ni_data_p->sessionEs.rawRequest = NULL; - loc_eng_ni_data_p->sessionEs.reqID = 0; - pthread_cond_init(&loc_eng_ni_data_p->sessionEs.tCond, NULL); - pthread_mutex_init(&loc_eng_ni_data_p->sessionEs.tLock, NULL); - - loc_eng_ni_data_p->session.respTimeLeft = 0; - loc_eng_ni_data_p->session.respRecvd = FALSE; - loc_eng_ni_data_p->session.rawRequest = NULL; - loc_eng_ni_data_p->session.reqID = 0; - pthread_cond_init(&loc_eng_ni_data_p->session.tCond, NULL); - pthread_mutex_init(&loc_eng_ni_data_p->session.tLock, NULL); - - loc_eng_data.ni_notify_cb = callbacks->notify_cb; - EXIT_LOG(%s, VOID_RET); - } -} - -/*=========================================================================== -FUNCTION loc_eng_ni_respond - -DESCRIPTION - This function receives user response from upper layer framework - -DEPENDENCIES - NONE - -RETURN VALUE - None - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_ni_respond(loc_eng_data_s_type &loc_eng_data, - int notif_id, GpsUserResponseType user_response) -{ - ENTRY_LOG_CALLFLOW(); - loc_eng_ni_data_s_type* loc_eng_ni_data_p = &loc_eng_data.loc_eng_ni_data; - loc_eng_ni_session_s_type* pSession = NULL; - - if (NULL == loc_eng_data.ni_notify_cb) { - EXIT_LOG(%s, "loc_eng_ni_init hasn't happened yet."); - return; - } - - if (notif_id == loc_eng_ni_data_p->sessionEs.reqID && - NULL != loc_eng_ni_data_p->sessionEs.rawRequest) { - pSession = &loc_eng_ni_data_p->sessionEs; - // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted - if (user_response == GPS_NI_RESPONSE_ACCEPT && - NULL != loc_eng_ni_data_p->session.rawRequest) { - pthread_mutex_lock(&loc_eng_ni_data_p->session.tLock); - loc_eng_ni_data_p->session.resp = GPS_NI_RESPONSE_IGNORE; - loc_eng_ni_data_p->session.respRecvd = TRUE; - pthread_cond_signal(&loc_eng_ni_data_p->session.tCond); - pthread_mutex_unlock(&loc_eng_ni_data_p->session.tLock); - } - } else if (notif_id == loc_eng_ni_data_p->session.reqID && - NULL != loc_eng_ni_data_p->session.rawRequest) { - pSession = &loc_eng_ni_data_p->session; - } - - if (pSession) { - LOC_LOGI("loc_eng_ni_respond: send user response %d for notif %d", user_response, notif_id); - pthread_mutex_lock(&pSession->tLock); - pSession->resp = user_response; - pSession->respRecvd = TRUE; - pthread_cond_signal(&pSession->tCond); - pthread_mutex_unlock(&pSession->tLock); - } - else { - LOC_LOGE("loc_eng_ni_respond: notif_id %d not an active session", notif_id); - } - - EXIT_LOG(%s, VOID_RET); -} diff --git a/gps/loc_api/libloc_api_50001/loc_eng_ni.h b/gps/loc_api/libloc_api_50001/loc_eng_ni.h deleted file mode 100644 index 068f5cd..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_ni.h +++ /dev/null @@ -1,59 +0,0 @@ -/* Copyright (c) 2009,2011,2014 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 LOC_ENG_NI_H -#define LOC_ENG_NI_H - -#include -#include - -#define LOC_NI_NO_RESPONSE_TIME 20 /* secs */ -#define LOC_NI_NOTIF_KEY_ADDRESS "Address" -#define GPS_NI_RESPONSE_IGNORE 4 - -typedef struct { - pthread_t thread; /* NI thread */ - int respTimeLeft; /* examine time for NI response */ - bool respRecvd; /* NI User reponse received or not from Java layer*/ - void* rawRequest; - int reqID; /* ID to check against response */ - GpsUserResponseType resp; - pthread_cond_t tCond; - pthread_mutex_t tLock; - LocEngAdapter* adapter; -} loc_eng_ni_session_s_type; - -typedef struct { - loc_eng_ni_session_s_type session; /* SUPL NI Session */ - loc_eng_ni_session_s_type sessionEs; /* Emergency SUPL NI Session */ - int reqIDCounter; -} loc_eng_ni_data_s_type; - - -#endif /* LOC_ENG_NI_H */ diff --git a/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp b/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp deleted file mode 100644 index 3d2336f..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_nmea.cpp +++ /dev/null @@ -1,924 +0,0 @@ -/* Copyright (c) 2012, 2016, 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_eng_nmea" -#include -#include -#include -#include - -/*=========================================================================== -FUNCTION loc_eng_nmea_send - -DESCRIPTION - send out NMEA sentence - -DEPENDENCIES - NONE - -RETURN VALUE - Total length of the nmea sentence - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_data_p) -{ - struct timeval tv; - gettimeofday(&tv, (struct timezone *) NULL); - int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000; - if (loc_eng_data_p->nmea_cb != NULL) - loc_eng_data_p->nmea_cb(now, pNmea, length); - LOC_LOGD("NMEA <%s", pNmea); -} - -/*=========================================================================== -FUNCTION loc_eng_nmea_put_checksum - -DESCRIPTION - Generate NMEA sentences generated based on position report - -DEPENDENCIES - NONE - -RETURN VALUE - Total length of the nmea sentence - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_nmea_put_checksum(char *pNmea, int maxSize) -{ - uint8_t checksum = 0; - int length = 0; - - pNmea++; //skip the $ - while (*pNmea != '\0') - { - checksum ^= *pNmea++; - length++; - } - - // length now contains nmea sentence string length not including $ sign. - int checksumLength = snprintf(pNmea,(maxSize-length-1),"*%02X\r\n", checksum); - - // total length of nmea sentence is length of nmea sentence inc $ sign plus - // length of checksum (+1 is to cover the $ character in the length). - return (length + checksumLength + 1); -} - -/*=========================================================================== -FUNCTION loc_eng_nmea_generate_pos - -DESCRIPTION - Generate NMEA sentences generated based on position report - Currently below sentences are generated within this function: - - $GPGSA : GPS DOP and active SVs - - $GNGSA : GLONASS DOP and active SVs - - $GPVTG : Track made good and ground speed - - $GPRMC : Recommended minimum navigation information - - $GPGGA : Time, position and fix related data - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, - const UlpLocation &location, - const GpsLocationExtended &locationExtended, - unsigned char generate_nmea) -{ - ENTRY_LOG(); - time_t utcTime(location.gpsLocation.timestamp/1000); - tm * pTm = gmtime(&utcTime); - if (NULL == pTm) { - LOC_LOGE("gmtime failed"); - return; - } - - char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0}; - char* pMarker = sentence; - int lengthRemaining = sizeof(sentence); - int length = 0; - int utcYear = pTm->tm_year % 100; // 2 digit year - int utcMonth = pTm->tm_mon + 1; // tm_mon starts at zero - int utcDay = pTm->tm_mday; - int utcHours = pTm->tm_hour; - int utcMinutes = pTm->tm_min; - int utcSeconds = pTm->tm_sec; - int utcMSeconds = (location.gpsLocation.timestamp)%1000; - - if (generate_nmea) { - // ------------------ - // ------$GPGSA------ - // ------------------ - - uint32_t svUsedCount = 0; - uint32_t svUsedList[32] = {0}; - uint32_t mask = loc_eng_data_p->gps_used_mask; - for (uint8_t i = 1; mask > 0 && svUsedCount < 32; i++) - { - if (mask & 1) - svUsedList[svUsedCount++] = i; - mask = mask >> 1; - } - // clear the cache so they can't be used again - loc_eng_data_p->gps_used_mask = 0; - - char fixType; - if (svUsedCount == 0) - fixType = '1'; // no fix - else if (svUsedCount <= 3) - fixType = '2'; // 2D fix - else - fixType = '3'; // 3D fix - - length = snprintf(pMarker, lengthRemaining, "$GPGSA,A,%c,", fixType); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - for (uint8_t i = 0; i < 12; i++) // only the first 12 sv go in sentence - { - if (i < svUsedCount) - length = snprintf(pMarker, lengthRemaining, "%02d,", svUsedList[i]); - else - length = snprintf(pMarker, lengthRemaining, ","); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - } - - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) - { // dop is in locationExtended, (QMI) - length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f", - locationExtended.pdop, - locationExtended.hdop, - locationExtended.vdop); - } - else if (loc_eng_data_p->pdop > 0 && loc_eng_data_p->hdop > 0 && loc_eng_data_p->vdop > 0) - { // dop was cached from sv report (RPC) - length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f", - loc_eng_data_p->pdop, - loc_eng_data_p->hdop, - loc_eng_data_p->vdop); - } - else - { // no dop - length = snprintf(pMarker, lengthRemaining, ",,"); - } - - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - // ------------------ - // ------$GNGSA------ - // ------------------ - uint32_t gloUsedCount = 0; - uint32_t gloUsedList[32] = {0}; - - // Reset locals for GNGSA sentence generation - pMarker = sentence; - lengthRemaining = sizeof(sentence); - mask = loc_eng_data_p->glo_used_mask; - fixType = '\0'; - - // Parse the glonass sv mask, and fetch glo sv ids - // Mask corresponds to the offset. - // GLONASS SV ids are from 65-96 - const int GLONASS_SV_ID_OFFSET = 64; - for (uint8_t i = 1; mask > 0 && gloUsedCount < 32; i++) - { - if (mask & 1) - gloUsedList[gloUsedCount++] = i + GLONASS_SV_ID_OFFSET; - mask = mask >> 1; - } - // clear the cache so they can't be used again - loc_eng_data_p->glo_used_mask = 0; - - if (gloUsedCount == 0) - fixType = '1'; // no fix - else if (gloUsedCount <= 3) - fixType = '2'; // 2D fix - else - fixType = '3'; // 3D fix - - // Start printing the sentence - // Format: $--GSA,a,x,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,p.p,h.h,v.v*cc - // GNGSA : for glonass SVs - // a : Mode : A : Automatic, allowed to automatically switch 2D/3D - // x : Fixtype : 1 (no fix), 2 (2D fix), 3 (3D fix) - // xx : 12 SV ID - // p.p : Position DOP (Dilution of Precision) - // h.h : Horizontal DOP - // v.v : Vertical DOP - // cc : Checksum value - length = snprintf(pMarker, lengthRemaining, "$GNGSA,A,%c,", fixType); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - // Add first 12 GLONASS satellite IDs - for (uint8_t i = 0; i < 12; i++) - { - if (i < gloUsedCount) - length = snprintf(pMarker, lengthRemaining, "%02d,", gloUsedList[i]); - else - length = snprintf(pMarker, lengthRemaining, ","); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - } - - // Add the position/horizontal/vertical DOP values - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) - { // dop is in locationExtended, (QMI) - length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f", - locationExtended.pdop, - locationExtended.hdop, - locationExtended.vdop); - } - else if (loc_eng_data_p->pdop > 0 && loc_eng_data_p->hdop > 0 && loc_eng_data_p->vdop > 0) - { // dop was cached from sv report (RPC) - length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f", - loc_eng_data_p->pdop, - loc_eng_data_p->hdop, - loc_eng_data_p->vdop); - } - else - { // no dop - length = snprintf(pMarker, lengthRemaining, ",,"); - } - - /* Sentence is ready, add checksum and broadcast */ - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - // ------------------ - // ------$GPVTG------ - // ------------------ - - pMarker = sentence; - lengthRemaining = sizeof(sentence); - - if (location.gpsLocation.flags & GPS_LOCATION_HAS_BEARING) - { - float magTrack = location.gpsLocation.bearing; - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV) - { - float magTrack = location.gpsLocation.bearing - locationExtended.magneticDeviation; - if (magTrack < 0.0) - magTrack += 360.0; - else if (magTrack > 360.0) - magTrack -= 360.0; - } - - length = snprintf(pMarker, lengthRemaining, "$GPVTG,%.1lf,T,%.1lf,M,", location.gpsLocation.bearing, magTrack); - } - else - { - length = snprintf(pMarker, lengthRemaining, "$GPVTG,,T,,M,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (location.gpsLocation.flags & GPS_LOCATION_HAS_SPEED) - { - float speedKnots = location.gpsLocation.speed * (3600.0/1852.0); - float speedKmPerHour = location.gpsLocation.speed * 3.6; - - length = snprintf(pMarker, lengthRemaining, "%.1lf,N,%.1lf,K,", speedKnots, speedKmPerHour); - } - else - { - length = snprintf(pMarker, lengthRemaining, ",N,,K,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (!(location.gpsLocation.flags & GPS_LOCATION_HAS_LAT_LONG)) - length = snprintf(pMarker, lengthRemaining, "%c", 'N'); // N means no fix - else if (LOC_POSITION_MODE_STANDALONE == loc_eng_data_p->adapter->getPositionMode().mode) - length = snprintf(pMarker, lengthRemaining, "%c", 'A'); // A means autonomous - else - length = snprintf(pMarker, lengthRemaining, "%c", 'D'); // D means differential - - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - // ------------------ - // ------$GPRMC------ - // ------------------ - - pMarker = sentence; - lengthRemaining = sizeof(sentence); - - length = snprintf(pMarker, lengthRemaining, "$GPRMC,%02d%02d%02d.%02d,A," , - utcHours, utcMinutes, utcSeconds,utcMSeconds/10); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (location.gpsLocation.flags & GPS_LOCATION_HAS_LAT_LONG) - { - double latitude = location.gpsLocation.latitude; - double longitude = location.gpsLocation.longitude; - char latHemisphere; - char lonHemisphere; - double latMinutes; - double lonMinutes; - - if (latitude > 0) - { - latHemisphere = 'N'; - } - else - { - latHemisphere = 'S'; - latitude *= -1.0; - } - - if (longitude < 0) - { - lonHemisphere = 'W'; - longitude *= -1.0; - } - else - { - lonHemisphere = 'E'; - } - - latMinutes = fmod(latitude * 60.0 , 60.0); - lonMinutes = fmod(longitude * 60.0 , 60.0); - - length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,", - (uint8_t)floor(latitude), latMinutes, latHemisphere, - (uint8_t)floor(longitude),lonMinutes, lonHemisphere); - } - else - { - length = snprintf(pMarker, lengthRemaining,",,,,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (location.gpsLocation.flags & GPS_LOCATION_HAS_SPEED) - { - float speedKnots = location.gpsLocation.speed * (3600.0/1852.0); - length = snprintf(pMarker, lengthRemaining, "%.1lf,", speedKnots); - } - else - { - length = snprintf(pMarker, lengthRemaining, ","); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (location.gpsLocation.flags & GPS_LOCATION_HAS_BEARING) - { - length = snprintf(pMarker, lengthRemaining, "%.1lf,", location.gpsLocation.bearing); - } - else - { - length = snprintf(pMarker, lengthRemaining, ","); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - length = snprintf(pMarker, lengthRemaining, "%2.2d%2.2d%2.2d,", - utcDay, utcMonth, utcYear); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV) - { - float magneticVariation = locationExtended.magneticDeviation; - char direction; - if (magneticVariation < 0.0) - { - direction = 'W'; - magneticVariation *= -1.0; - } - else - { - direction = 'E'; - } - - length = snprintf(pMarker, lengthRemaining, "%.1lf,%c,", - magneticVariation, direction); - } - else - { - length = snprintf(pMarker, lengthRemaining, ",,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (!(location.gpsLocation.flags & GPS_LOCATION_HAS_LAT_LONG)) - length = snprintf(pMarker, lengthRemaining, "%c", 'N'); // N means no fix - else if (LOC_POSITION_MODE_STANDALONE == loc_eng_data_p->adapter->getPositionMode().mode) - length = snprintf(pMarker, lengthRemaining, "%c", 'A'); // A means autonomous - else - length = snprintf(pMarker, lengthRemaining, "%c", 'D'); // D means differential - - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - // ------------------ - // ------$GPGGA------ - // ------------------ - - pMarker = sentence; - lengthRemaining = sizeof(sentence); - - length = snprintf(pMarker, lengthRemaining, "$GPGGA,%02d%02d%02d.%02d," , - utcHours, utcMinutes, utcSeconds, utcMSeconds/10); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (location.gpsLocation.flags & GPS_LOCATION_HAS_LAT_LONG) - { - double latitude = location.gpsLocation.latitude; - double longitude = location.gpsLocation.longitude; - char latHemisphere; - char lonHemisphere; - double latMinutes; - double lonMinutes; - - if (latitude > 0) - { - latHemisphere = 'N'; - } - else - { - latHemisphere = 'S'; - latitude *= -1.0; - } - - if (longitude < 0) - { - lonHemisphere = 'W'; - longitude *= -1.0; - } - else - { - lonHemisphere = 'E'; - } - - latMinutes = fmod(latitude * 60.0 , 60.0); - lonMinutes = fmod(longitude * 60.0 , 60.0); - - length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,", - (uint8_t)floor(latitude), latMinutes, latHemisphere, - (uint8_t)floor(longitude),lonMinutes, lonHemisphere); - } - else - { - length = snprintf(pMarker, lengthRemaining,",,,,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - char gpsQuality; - if (!(location.gpsLocation.flags & GPS_LOCATION_HAS_LAT_LONG)) - gpsQuality = '0'; // 0 means no fix - else if (LOC_POSITION_MODE_STANDALONE == loc_eng_data_p->adapter->getPositionMode().mode) - gpsQuality = '1'; // 1 means GPS fix - else - gpsQuality = '2'; // 2 means DGPS fix - - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) - { // dop is in locationExtended, (QMI) - length = snprintf(pMarker, lengthRemaining, "%c,%02d,%.1f,", - gpsQuality, svUsedCount, locationExtended.hdop); - } - else if (loc_eng_data_p->pdop > 0 && loc_eng_data_p->hdop > 0 && loc_eng_data_p->vdop > 0) - { // dop was cached from sv report (RPC) - length = snprintf(pMarker, lengthRemaining, "%c,%02d,%.1f,", - gpsQuality, svUsedCount, loc_eng_data_p->hdop); - } - else - { // no hdop - length = snprintf(pMarker, lengthRemaining, "%c,%02d,,", - gpsQuality, svUsedCount); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL) - { - length = snprintf(pMarker, lengthRemaining, "%.1lf,M,", - locationExtended.altitudeMeanSeaLevel); - } - else - { - length = snprintf(pMarker, lengthRemaining,",,"); - } - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if ((location.gpsLocation.flags & GPS_LOCATION_HAS_ALTITUDE) && - (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL)) - { - length = snprintf(pMarker, lengthRemaining, "%.1lf,M,,", - location.gpsLocation.altitude - locationExtended.altitudeMeanSeaLevel); - } - else - { - length = snprintf(pMarker, lengthRemaining,",,,"); - } - - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - } - //Send blank NMEA reports for non-final fixes - else { - strlcpy(sentence, "$GPGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - strlcpy(sentence, "$GNGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - strlcpy(sentence, "$GPVTG,,T,,M,,N,,K,N", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - strlcpy(sentence, "$GPRMC,,V,,,,,,,,,,N", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - - strlcpy(sentence, "$GPGGA,,,,,,0,,,,,,,,", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - } - // clear the dop cache so they can't be used again - loc_eng_data_p->pdop = 0; - loc_eng_data_p->hdop = 0; - loc_eng_data_p->vdop = 0; - - EXIT_LOG(%d, 0); -} - - - -/*=========================================================================== -FUNCTION loc_eng_nmea_generate_sv - -DESCRIPTION - Generate NMEA sentences generated based on sv report - -DEPENDENCIES - NONE - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, - const GnssSvStatus &svStatus, const GpsLocationExtended &locationExtended) -{ - ENTRY_LOG(); - - char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0}; - char* pMarker = sentence; - int lengthRemaining = sizeof(sentence); - int length = 0; - int svCount = svStatus.num_svs; - int sentenceCount = 0; - int sentenceNumber = 1; - int svNumber = 1; - int gpsCount = 0; - int glnCount = 0; - - //Count GPS SVs for saparating GPS from GLONASS and throw others - - loc_eng_data_p->gps_used_mask = 0; - loc_eng_data_p->glo_used_mask = 0; - for(svNumber=1; svNumber <= svCount; svNumber++) { - if (GNSS_CONSTELLATION_GPS == svStatus.gnss_sv_list[svNumber - 1].constellation) - { - // cache the used in fix mask, as it will be needed to send $GPGSA - // during the position report - if (GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & GNSS_SV_FLAGS_USED_IN_FIX)) - { - loc_eng_data_p->gps_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1)); - } - gpsCount++; - } - else if (GNSS_CONSTELLATION_GLONASS == svStatus.gnss_sv_list[svNumber - 1].constellation) - { - // cache the used in fix mask, as it will be needed to send $GNGSA - // during the position report - if (GNSS_SV_FLAGS_USED_IN_FIX == (svStatus.gnss_sv_list[svNumber - 1].flags & GNSS_SV_FLAGS_USED_IN_FIX)) - { - loc_eng_data_p->glo_used_mask |= (1 << (svStatus.gnss_sv_list[svNumber - 1].svid - 1)); - } - glnCount++; - } - } - - // ------------------ - // ------$GPGSV------ - // ------------------ - - if (gpsCount <= 0) - { - // no svs in view, so just send a blank $GPGSV sentence - strlcpy(sentence, "$GPGSV,1,1,0,", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - } - else - { - svNumber = 1; - sentenceNumber = 1; - sentenceCount = gpsCount/4 + (gpsCount % 4 != 0); - - while (sentenceNumber <= sentenceCount) - { - pMarker = sentence; - lengthRemaining = sizeof(sentence); - - length = snprintf(pMarker, lengthRemaining, "$GPGSV,%d,%d,%02d", - sentenceCount, sentenceNumber, gpsCount); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - for (int i=0; (svNumber <= svCount) && (i < 4); svNumber++) - { - if (GNSS_CONSTELLATION_GPS == svStatus.gnss_sv_list[svNumber - 1].constellation) - { - length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,", - svStatus.gnss_sv_list[svNumber-1].svid, - (int)(0.5 + svStatus.gnss_sv_list[svNumber-1].elevation), //float to int - (int)(0.5 + svStatus.gnss_sv_list[svNumber-1].azimuth)); //float to int - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (svStatus.gnss_sv_list[svNumber-1].c_n0_dbhz > 0) - { - length = snprintf(pMarker, lengthRemaining,"%02d", - (int)(0.5 + svStatus.gnss_sv_list[svNumber-1].c_n0_dbhz)); //float to int - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - } - - i++; - } - - } - - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - sentenceNumber++; - - } //while - - } //if - - // ------------------ - // ------$GLGSV------ - // ------------------ - - if (glnCount <= 0) - { - // no svs in view, so just send a blank $GLGSV sentence - strlcpy(sentence, "$GLGSV,1,1,0,", sizeof(sentence)); - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - } - else - { - svNumber = 1; - sentenceNumber = 1; - sentenceCount = glnCount/4 + (glnCount % 4 != 0); - - while (sentenceNumber <= sentenceCount) - { - pMarker = sentence; - lengthRemaining = sizeof(sentence); - - length = snprintf(pMarker, lengthRemaining, "$GLGSV,%d,%d,%02d", - sentenceCount, sentenceNumber, glnCount); - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - for (int i=0; (svNumber <= svCount) && (i < 4); svNumber++) - { - if (GNSS_CONSTELLATION_GLONASS == svStatus.gnss_sv_list[svNumber - 1].constellation) - { - - length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,", - svStatus.gnss_sv_list[svNumber - 1].svid, - (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].elevation), //float to int - (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].azimuth)); //float to int - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - - if (svStatus.gnss_sv_list[svNumber - 1].c_n0_dbhz > 0) - { - length = snprintf(pMarker, lengthRemaining,"%02d", - (int)(0.5 + svStatus.gnss_sv_list[svNumber - 1].c_n0_dbhz)); //float to int - - if (length < 0 || length >= lengthRemaining) - { - LOC_LOGE("NMEA Error in string formatting"); - return; - } - pMarker += length; - lengthRemaining -= length; - } - - i++; - } - - } - - length = loc_eng_nmea_put_checksum(sentence, sizeof(sentence)); - loc_eng_nmea_send(sentence, length, loc_eng_data_p); - sentenceNumber++; - - } //while - - }//if - - // For RPC, the DOP are sent during sv report, so cache them - // now to be sent during position report. - // For QMI, the DOP will be in position report. - if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) - { - loc_eng_data_p->pdop = locationExtended.pdop; - loc_eng_data_p->hdop = locationExtended.hdop; - loc_eng_data_p->vdop = locationExtended.vdop; - } - else - { - loc_eng_data_p->pdop = 0; - loc_eng_data_p->hdop = 0; - loc_eng_data_p->vdop = 0; - } - - EXIT_LOG(%d, 0); -} diff --git a/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp b/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp deleted file mode 100644 index b5bf4e7..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_xtra.cpp +++ /dev/null @@ -1,219 +0,0 @@ -/* Copyright (c) 2009-2014, 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_eng" - -#include -#include -#include - -using namespace loc_core; - -struct LocEngRequestXtraServer : public LocMsg { - LocEngAdapter* mAdapter; - inline LocEngRequestXtraServer(LocEngAdapter* adapter) : - LocMsg(), mAdapter(adapter) - { - locallog(); - } - inline virtual void proc() const { - mAdapter->requestXtraServer(); - } - inline void locallog() const { - LOC_LOGV("LocEngRequestXtraServer"); - } - inline virtual void log() const { - locallog(); - } -}; - -struct LocEngInjectXtraData : public LocMsg { - LocEngAdapter* mAdapter; - char* mData; - const int mLen; - inline LocEngInjectXtraData(LocEngAdapter* adapter, - char* data, int len): - LocMsg(), mAdapter(adapter), - mData(new char[len]), mLen(len) - { - memcpy((void*)mData, (void*)data, len); - locallog(); - } - inline ~LocEngInjectXtraData() - { - delete[] mData; - } - inline virtual void proc() const { - mAdapter->setXtraData(mData, mLen); - } - inline void locallog() const { - LOC_LOGV("length: %d\n data: %p", mLen, mData); - } - inline virtual void log() const { - locallog(); - } -}; - -struct LocEngSetXtraVersionCheck : public LocMsg { - LocEngAdapter *mAdapter; - int mCheck; - inline LocEngSetXtraVersionCheck(LocEngAdapter* adapter, - int check): - mAdapter(adapter), mCheck(check) {} - inline virtual void proc() const { - locallog(); - mAdapter->setXtraVersionCheck(mCheck); - } - inline void locallog() const { - LOC_LOGD("%s:%d]: mCheck: %d", - __func__, __LINE__, mCheck); - } - inline virtual void log() const { - locallog(); - } -}; - -/*=========================================================================== -FUNCTION loc_eng_xtra_init - -DESCRIPTION - Initialize XTRA module. - -DEPENDENCIES - N/A - -RETURN VALUE - 0: success - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_xtra_init (loc_eng_data_s_type &loc_eng_data, - GpsXtraExtCallbacks* callbacks) -{ - int ret_val = -1; - loc_eng_xtra_data_s_type *xtra_module_data_ptr; - ENTRY_LOG(); - - if(!loc_eng_data.adapter->mSupportsTimeInjection - || loc_eng_data.adapter->hasNativeXtraClient()) { - LOC_LOGD("XTRA is already supported. disable it here.\n"); - EXIT_LOG(%d, 1); // return 1 denote failure - return 1; - } - - if(callbacks == NULL) { - LOC_LOGE("loc_eng_xtra_init: failed, cb is NULL"); - } else { - xtra_module_data_ptr = &loc_eng_data.xtra_module_data; - xtra_module_data_ptr->download_request_cb = callbacks->download_request_cb; - xtra_module_data_ptr->report_xtra_server_cb = callbacks->report_xtra_server_cb; - - ret_val = 0; - } - EXIT_LOG(%d, ret_val); - return ret_val; -} - -/*=========================================================================== -FUNCTION loc_eng_xtra_inject_data - -DESCRIPTION - Injects XTRA file into the engine but buffers the data if engine is busy. - -DEPENDENCIES - N/A - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_xtra_inject_data(loc_eng_data_s_type &loc_eng_data, - char* data, int length) -{ - ENTRY_LOG(); - LocEngAdapter* adapter = loc_eng_data.adapter; - adapter->sendMsg(new LocEngInjectXtraData(adapter, data, length)); - EXIT_LOG(%d, 0); - return 0; -} -/*=========================================================================== -FUNCTION loc_eng_xtra_request_server - -DESCRIPTION - Request the Xtra server url from the modem - -DEPENDENCIES - N/A - -RETURN VALUE - 0 - -SIDE EFFECTS - N/A - -===========================================================================*/ -int loc_eng_xtra_request_server(loc_eng_data_s_type &loc_eng_data) -{ - ENTRY_LOG(); - LocEngAdapter* adapter = loc_eng_data.adapter; - adapter->sendMsg(new LocEngRequestXtraServer(adapter)); - EXIT_LOG(%d, 0); - return 0; -} -/*=========================================================================== -FUNCTION loc_eng_xtra_version_check - -DESCRIPTION - Injects the enable/disable value for checking XTRA version - that is specified in gps.conf - -DEPENDENCIES - N/A - -RETURN VALUE - none - -SIDE EFFECTS - N/A - -===========================================================================*/ -void loc_eng_xtra_version_check(loc_eng_data_s_type &loc_eng_data, - int check) -{ - ENTRY_LOG(); - LocEngAdapter *adapter = loc_eng_data.adapter; - adapter->sendMsg(new LocEngSetXtraVersionCheck(adapter, check)); - EXIT_LOG(%d, 0); -} diff --git a/gps/loc_api/libloc_api_50001/loc_eng_xtra.h b/gps/loc_api/libloc_api_50001/loc_eng_xtra.h deleted file mode 100644 index 175f497..0000000 --- a/gps/loc_api/libloc_api_50001/loc_eng_xtra.h +++ /dev/null @@ -1,47 +0,0 @@ -/* Copyright (c) 2009,2011 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 LOC_ENG_XTRA_H -#define LOC_ENG_XTRA_H - -#include - -// Module data -typedef struct -{ - // loc_eng_ioctl_cb_data_s_type ioctl_cb_data; - gps_xtra_download_request download_request_cb; - report_xtra_server report_xtra_server_cb; - - // XTRA data buffer - char *xtra_data_for_injection; // NULL if no pending data - int xtra_data_len; -} loc_eng_xtra_data_s_type; - -#endif // LOC_ENG_XTRA_H diff --git a/gps/location/Android.mk b/gps/location/Android.mk new file mode 100644 index 0000000..6ac8e36 --- /dev/null +++ b/gps/location/Android.mk @@ -0,0 +1,42 @@ +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_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib +LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64 +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 new file mode 100644 index 0000000..21d2de0 --- /dev/null +++ b/gps/location/LocationAPI.cpp @@ -0,0 +1,644 @@ +/* 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 +#include +#include +#include +#include + +typedef void* (getLocationInterface)(); +typedef std::map 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 new file mode 100644 index 0000000..f5cc75a --- /dev/null +++ b/gps/location/LocationAPI.h @@ -0,0 +1,973 @@ +/* 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 +#include +#include +#include + +#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, + BATCHING_MODE_TRIP +} 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 mSatelliteInfo; +} GnssDebugReport; + +/* Provides the capabilities of the system + capabilities callback is called once soon after createInstance is called */ +typedef std::function capabilitiesCallback; + +/* Used by tracking, batching, and miscellanous APIs + responseCallback is called for every Tracking, Batching API, and Miscellanous API */ +typedef std::function 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 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 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 batchingCallback; + +typedef std::function & 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 gnssLocationInfoCallback; + +/* Used for addGeofences API, optional can be NULL + geofenceBreachCallback is called when any number of geofences have a state change */ +typedef std::function geofenceBreachCallback; + +/* Used for addGeofences API, optional can be NULL + geofenceStatusCallback is called when any number of geofences have a status change */ +typedef std::function geofenceStatusCallback; + +/* Network Initiated request, optional can be NULL + This callback should be responded to by calling gnssNiResponse */ +typedef std::function 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 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 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 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 new file mode 100644 index 0000000..070c585 --- /dev/null +++ b/gps/location/LocationAPIClientBase.cpp @@ -0,0 +1,929 @@ +/* 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 +#include +#include +#include "LocationAPIClientBase.h" + +#define FLP_CONF_FILE "/etc/flp.conf" +#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 session = 0; + 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 & 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(FLP_CONF_FILE, 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 if ((sessionMode == SESSION_MODE_ON_FULL) || + (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED)) { + // Fill in the batch mode + BatchingOptions batchOptions = {}; + batchOptions.size = sizeof(BatchingOptions); + batchOptions.batchingMode = BATCHING_MODE_ROUTINE; + if (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED) { + batchOptions.batchingMode = BATCHING_MODE_TRIP; + } + + 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_FULL || + (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED)) ? + 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 if ((sMode == SESSION_MODE_ON_FULL) || + (sMode == SESSION_MODE_ON_TRIP_COMPLETED)) { + mRequestQueues[REQUEST_SESSION].push(new StopBatchingRequest(*this)); + mLocationAPI->stopBatching(batchingSession); + } else { + LOC_LOGE("%s:%d] unknown mode %d.", __FUNCTION__, __LINE__, sMode); + } + + 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 if ((sMode == SESSION_MODE_ON_FULL) || + (sMode == SESSION_MODE_ON_TRIP_COMPLETED)) { + // 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 { + LOC_LOGE("%s:%d] unknown mode %d", __FUNCTION__, __LINE__, sMode); + } + } else if ((sessionMode == SESSION_MODE_ON_FULL) || + (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED)) { + // 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); + batchOptions.batchingMode = BATCHING_MODE_ROUTINE; + if (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED) { + batchOptions.batchingMode = BATCHING_MODE_TRIP; + } + + 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 if ((sMode == SESSION_MODE_ON_FULL) || + (sMode == SESSION_MODE_ON_TRIP_COMPLETED)) { + mLocationAPI->updateBatchingOptions(batchingSession, options, batchOptions); + } else { + LOC_LOGE("%s:%d] unknown mode %d", __FUNCTION__, __LINE__, sMode); + } + + } else { + LOC_LOGE("%s:%d] unknown mode %d.", __FUNCTION__, __LINE__, sessionMode); + } + + uint32_t session = ((sessionMode == SESSION_MODE_ON_FULL) || + (sessionMode == SESSION_MODE_ON_TRIP_COMPLETED) ? + 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; +} + +void LocationAPIClientBase::locAPIGetBatchedLocations(uint32_t id, size_t count) +{ + pthread_mutex_lock(&mMutex); + if (mLocationAPI) { + uint32_t session = 0; + session = mRequestQueues[REQUEST_SESSION].getSession(); + if (session > 0) { + SessionEntity entity = mSessionBiDict.getExtById(id); + uint32_t batchingSession = entity.batchingSession; + mRequestQueues[REQUEST_SESSION].push(new GetBatchedLocationsRequest(*this)); + mLocationAPI->getBatchedLocations(batchingSession, count); + } else { + LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, session); + } + } + pthread_mutex_unlock(&mMutex); +} + +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) { + 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 RemoveGeofencesRequest(*this)); + mLocationAPI->removeGeofences(j, sessions); + } + } 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() +{ + pthread_mutex_lock(&mMutex); + if (mLocationAPI) { + std::vector sessionsVec = mGeofenceBiDict.getAllSessions(); + size_t count = sessionsVec.size(); + 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] = sessionsVec[i]; + if (sessions[j] > 0) { + j++; + } + } + if (j > 0) { + mRequestQueues[REQUEST_GEOFENCE].push(new RemoveGeofencesRequest(*this)); + mLocationAPI->removeGeofences(j, sessions); + } + } else { + LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, + mRequestQueues[REQUEST_GEOFENCE].getSession()); + } + + free(sessions); + } + pthread_mutex_unlock(&mMutex); +} + +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 & tripCompletedList) { + + // map the trip ids to the client ids + std::list 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 new file mode 100644 index 0000000..a856054 --- /dev/null +++ b/gps/location/LocationAPIClientBase.h @@ -0,0 +1,545 @@ +/* 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 +#include +#include +#include +#include + +#include "LocationAPI.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 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); + void 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 &/*listOfCompletedTrips*/) {} + void beforeBatchingStatusCb(BatchingStatusInfo batchStatus, + std::list & 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 + 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 getAllSessions() { + std::vector 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 mForwardMap; + // mBackwardMap mapping session->id + std::map mBackwardMap; + // mExtMap mapping session->ext + std::map mExtMap; + }; + + class StartTrackingRequest : public LocationAPIRequest { + public: + StartTrackingRequest(LocationAPIClientBase& API) : mAPI(API) {} + inline void onResponse(LocationError error, uint32_t /*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*/) { + 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) : 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.mGeofenceBiDict.rmBySession(sessions[i]); + } + mAPI.onRemoveGeofencesCb(count, errors, ids); + free(ids); + } + LocationAPIClientBase& mAPI; + }; + + 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 mGeofenceBiDict; + BiDict mSessionBiDict; + int32_t mBatchSize; + bool mTracking; +}; + +#endif /* LOCATION_API_CLINET_BASE_H */ diff --git a/gps/location/Makefile.am b/gps/location/Makefile.am new file mode 100644 index 0000000..d1d0131 --- /dev/null +++ b/gps/location/Makefile.am @@ -0,0 +1,40 @@ +AM_CFLAGS = \ + $(LOCPLA_CFLAGS) \ + $(GPSUTILS_CFLAGS) \ + $(LOCHAL_CFLAGS) \ + -I./ \ + -I../utils \ + -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++ -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 = -lpthread -shared -version-info 1:0:0 +liblocation_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) +endif + +liblocation_api_la_LIBADD = -lstdc++ $(LOCPLA_LIBS) $(GPSUTILS_LIBS) $(LOCHAL_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/location_interface.h b/gps/location/location_interface.h new file mode 100644 index 0000000..33ec29e --- /dev/null +++ b/gps/location/location_interface.h @@ -0,0 +1,94 @@ +/* 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 +#include + +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 (*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, uint8_t type); +}; + +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 */ diff --git a/gps/utils/Android.mk b/gps/utils/Android.mk index ef1b7a2..3f3b83a 100644 --- a/gps/utils/Android.mk +++ b/gps/utils/Android.mk @@ -1,3 +1,4 @@ +ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) ifneq ($(BUILD_TINY_ANDROID),true) #Compile this library only for builds with the latest modem image @@ -24,7 +25,8 @@ LOCAL_SRC_FILES += \ LocTimer.cpp \ LocThread.cpp \ MsgTask.cpp \ - loc_misc_utils.cpp + loc_misc_utils.cpp \ + loc_nmea.cpp # Flag -std=c++11 is not accepted by compiler when LOCAL_CLANG is set to true LOCAL_CFLAGS += \ @@ -38,32 +40,26 @@ endif LOCAL_LDFLAGS += -Wl,--export-dynamic ## Includes -LOCAL_C_INCLUDES:= \ - $(TARGET_OUT_HEADERS)/libloc_pla - -LOCAL_COPY_HEADERS_TO:= gps.utils/ -LOCAL_COPY_HEADERS:= \ - loc_log.h \ - loc_cfg.h \ - log_util.h \ - linked_list.h \ - msg_q.h \ - MsgTask.h \ - LocHeap.h \ - LocThread.h \ - LocTimer.h \ - loc_target.h \ - loc_timer.h \ - LocSharedLock.h \ - loc_misc_utils.h +LOCAL_HEADER_LIBRARIES := \ + libloc_pla_headers \ + liblocation_api_headers LOCAL_MODULE := libgps.utils - +LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib +LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64 LOCAL_MODULE_TAGS := optional LOCAL_PRELINK_MODULE := false +LOCAL_CFLAGS += $(GNSS_CFLAGS) + include $(BUILD_SHARED_LIBRARY) +include $(CLEAR_VARS) +LOCAL_MODULE := libgps.utils_headers +LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH) +include $(BUILD_HEADER_LIBRARY) + include $(addsuffix /Android.mk, $(addprefix $(LOCAL_PATH)/, platform_lib_abstractions)) endif # not BUILD_TINY_ANDROID +endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE diff --git a/gps/utils/LocThread.cpp b/gps/utils/LocThread.cpp index 685841e..d112f61 100644 --- a/gps/utils/LocThread.cpp +++ b/gps/utils/LocThread.cpp @@ -65,7 +65,7 @@ public: // threashold approprietly for destroy(), e.g. mRefCount. LocThreadDelegate::LocThreadDelegate(LocThread::tCreate creator, const char* threadName, LocRunnable* runnable, bool joinable) : - mRunnable(runnable), mJoinable(joinable), mThandle(NULL), + mRunnable(runnable), mJoinable(joinable), mThandle((pthread_t)NULL), mMutex(PTHREAD_MUTEX_INITIALIZER), mRefCount(2) { // set up thread name, if nothing is passed in @@ -79,7 +79,7 @@ LocThreadDelegate::LocThreadDelegate(LocThread::tCreate creator, mThandle = creator(threadName, threadMain, this); } else if (pthread_create(&mThandle, NULL, threadMain, this)) { // pthread_create() failed - mThandle = NULL; + mThandle = (pthread_t)NULL; } if (mThandle) { diff --git a/gps/utils/LocTimer.cpp b/gps/utils/LocTimer.cpp index 4de6b40..5b653eb 100644 --- a/gps/utils/LocTimer.cpp +++ b/gps/utils/LocTimer.cpp @@ -183,7 +183,7 @@ class LocTimerDelegate : public LocRankable { : mClient(NULL), mLock(NULL), mFutureTime(delay), mContainer(NULL) {} inline ~LocTimerDelegate() { if (mLock) { mLock->drop(); mLock = NULL; } } public: - LocTimerDelegate(LocTimer& client, struct timespec& futureTime, bool wakeOnExpire); + LocTimerDelegate(LocTimer& client, struct timespec& futureTime, LocTimerContainer* container); void destroyLocked(); // LocRankable virtual method virtual int ranks(LocRankable& rankable); @@ -283,7 +283,8 @@ void LocTimerContainer::updateSoonestTime(LocTimerDelegate* priorTop) { // check if top has changed if (curTop != priorTop) { - struct itimerspec delay = {0}; + struct itimerspec delay; + memset(&delay, 0, sizeof(struct itimerspec)); bool toSetTime = false; // if tree is empty now, we remove poll and disarm timer if (!curTop) { @@ -374,7 +375,8 @@ void LocTimerContainer::expire() { } }; - struct itimerspec delay = {0}; + struct itimerspec delay; + memset(&delay, 0, sizeof(struct itimerspec)); timerfd_settime(getTimerFd(), TFD_TIMER_ABSTIME, &delay, NULL); mPollTask->removePoll(*this); mMsgTask->sendMsg(new MsgTimerExpire(*this)); @@ -472,11 +474,13 @@ bool LocTimerPollTask::run() { /***************************LocTimerDelegate methods***************************/ inline -LocTimerDelegate::LocTimerDelegate(LocTimer& client, struct timespec& futureTime, bool wakeOnExpire) +LocTimerDelegate::LocTimerDelegate(LocTimer& client, + struct timespec& futureTime, + LocTimerContainer* container) : mClient(&client), mLock(mClient->mLock->share()), mFutureTime(futureTime), - mContainer(LocTimerContainer::get(wakeOnExpire)) { + mContainer(container) { // adding the timer into the container mContainer->add(*this); } @@ -556,8 +560,13 @@ bool LocTimer::start(unsigned int timeOutInMs, bool wakeOnExpire) { futureTime.tv_sec += futureTime.tv_nsec / 1000000000; futureTime.tv_nsec %= 1000000000; } - mTimer = new LocTimerDelegate(*this, futureTime, wakeOnExpire); - // if mTimer is non 0, success should be 0; or vice versa + + LocTimerContainer* container; + container = LocTimerContainer::get(wakeOnExpire); + if (NULL != container) { + mTimer = new LocTimerDelegate(*this, futureTime, container); + // if mTimer is non 0, success should be 0; or vice versa + } success = (NULL != mTimer); } mLock->unlock(); diff --git a/gps/utils/Makefile.am b/gps/utils/Makefile.am new file mode 100644 index 0000000..33a87da --- /dev/null +++ b/gps/utils/Makefile.am @@ -0,0 +1,64 @@ +AM_CFLAGS = -Wundef \ + -I./ \ + -std=c++11 \ + $(LOCPLA_CFLAGS) + +AM_CPPFLAGS = -Wundef \ + -I./ \ + -std=c++11 \ + $(LOCPLA_CFLAGS) + +libgps_utils_so_la_h_sources = \ + msg_q.h \ + linked_list.h \ + loc_cfg.h \ + loc_log.h \ + loc_target.h \ + loc_timer.h \ + MsgTask.h \ + LocHeap.h \ + LocThread.h \ + LocTimer.h \ + loc_misc_utils.h \ + loc_nmea.h \ + gps_extended_c.h \ + gps_extended.h \ + loc_gps.h + +libgps_utils_so_la_c_sources = \ + linked_list.c \ + msg_q.c \ + loc_cfg.cpp \ + loc_log.cpp \ + loc_target.cpp \ + LocHeap.cpp \ + LocTimer.cpp \ + LocThread.cpp \ + MsgTask.cpp \ + loc_misc_utils.cpp \ + loc_nmea.cpp + + +library_include_HEADERS = $(libgps_utils_so_la_h_sources) + +libgps_utils_so_la_SOURCES = $(libgps_utils_so_la_c_sources) + +if USE_GLIB +libgps_utils_so_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ +libgps_utils_so_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 +libgps_utils_so_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ +else +libgps_utils_so_la_CFLAGS = $(AM_CFLAGS) +libgps_utils_so_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0 +libgps_utils_so_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) +endif + +libgps_utils_so_la_LIBADD = -lcutils -lstdc++ -llog $(LOCPLA_LIBS) + +#Create and Install libraries +lib_LTLIBRARIES = libgps_utils_so.la +library_includedir = $(pkgincludedir) +pkgconfigdir = $(libdir)/pkgconfig + +pkgconfig_DATA = gps-utils.pc +EXTRA_DIST = $(pkgconfig_DATA) diff --git a/gps/utils/MsgTask.cpp b/gps/utils/MsgTask.cpp index 78a3fe0..80abeec 100644 --- a/gps/utils/MsgTask.cpp +++ b/gps/utils/MsgTask.cpp @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2013,2015 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2013, 2015, 2017The 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 @@ -26,7 +26,7 @@ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ -#define LOG_NDDEBUG 0 +#define LOG_NDEBUG 0 #define LOG_TAG "LocSvc_MsgTask" #include @@ -62,9 +62,9 @@ MsgTask::~MsgTask() { } void MsgTask::destroy() { + LocThread* thread = mThread; msg_q_unblock((void*)mQ); - if (mThread) { - LocThread* thread = mThread; + if (thread) { mThread = NULL; delete thread; } else { @@ -73,7 +73,11 @@ void MsgTask::destroy() { } void MsgTask::sendMsg(const LocMsg* msg) const { - msg_q_snd((void*)mQ, (void*)msg, LocMsgDestroy); + if (msg) { + msg_q_snd((void*)mQ, (void*)msg, LocMsgDestroy); + } else { + LOC_LOGE("%s: msg is NULL", __func__); + } } void MsgTask::prerun() { @@ -82,7 +86,6 @@ void MsgTask::prerun() { } bool MsgTask::run() { - LOC_LOGV("MsgTask::loop() listening ...\n"); LocMsg* msg; msq_q_err_type result = msg_q_rcv((void*)mQ, (void **)&msg); if (eMSG_Q_SUCCESS != result) { diff --git a/gps/utils/configure.ac b/gps/utils/configure.ac new file mode 100644 index 0000000..a7ab9b4 --- /dev/null +++ b/gps/utils/configure.ac @@ -0,0 +1,59 @@ +# configure.ac -- Autoconf script for gps gps-utils +# +# Process this file with autoconf to produce a configure script + +# Requires autoconf tool later than 2.61 +AC_PREREQ(2.61) +# Initialize the gps gps-utils package version 1.0.0 +AC_INIT([gps-utils],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([Makefile.am]) +# 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 + +PKG_CHECK_MODULES([LOCPLA], [loc-pla]) +AC_SUBST([LOCPLA_CFLAGS]) +AC_SUBST([LOCPLA_LIBS]) + +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 \ + gps-utils.pc + ]) + +AC_OUTPUT diff --git a/gps/utils/gps-utils.pc.in b/gps/utils/gps-utils.pc.in new file mode 100644 index 0000000..3ed3d90 --- /dev/null +++ b/gps/utils/gps-utils.pc.in @@ -0,0 +1,10 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: gps-utils +Description: QTI GPS Location utils +Version: @VERSION +Libs: -L${libdir} -lgps_utils_so +Cflags: -I${includedir}/gps-utils diff --git a/gps/core/gps_extended.h b/gps/utils/gps_extended.h similarity index 93% rename from gps/core/gps_extended.h rename to gps/utils/gps_extended.h index 9460d4e..dc6ad1e 100644 --- a/gps/core/gps_extended.h +++ b/gps/utils/gps_extended.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-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 @@ -29,31 +29,33 @@ #ifndef GPS_EXTENDED_H #define GPS_EXTENDED_H -#include /** * @file * @brief C++ declarations for GPS types */ -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - +#include #if defined(USE_GLIB) || defined(OFF_TARGET) #include #endif +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + + + struct LocPosMode { LocPositionMode mode; - GpsPositionRecurrence recurrence; + LocGpsPositionRecurrence recurrence; uint32_t min_interval; uint32_t preferred_accuracy; uint32_t preferred_time; bool share_position; char credentials[14]; char provider[8]; - LocPosMode(LocPositionMode m, GpsPositionRecurrence recr, + LocPosMode(LocPositionMode m, LocGpsPositionRecurrence recr, uint32_t gap, uint32_t accu, uint32_t time, bool sp, const char* cred, const char* prov) : mode(m), recurrence(recr), @@ -73,7 +75,7 @@ struct LocPosMode inline LocPosMode() : mode(LOC_POSITION_MODE_MS_BASED), - recurrence(GPS_POSITION_RECURRENCE_PERIODIC), + recurrence(LOC_GPS_POSITION_RECURRENCE_PERIODIC), min_interval(GPS_DEFAULT_FIX_INTERVAL_MS), preferred_accuracy(50), preferred_time(120000), share_position(true) { diff --git a/gps/core/gps_extended_c.h b/gps/utils/gps_extended_c.h similarity index 78% rename from gps/core/gps_extended_c.h rename to gps/utils/gps_extended_c.h index e16d758..f87a942 100644 --- a/gps/core/gps_extended_c.h +++ b/gps/utils/gps_extended_c.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2013-2015, 2016 The Linux Foundation. All rights reserved. +/* Copyright (c) 2013-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 @@ -33,7 +33,8 @@ #include #include #include -#include +#include +#include #include /** @@ -47,14 +48,14 @@ extern "C" { /** Location has valid source information. */ #define LOCATION_HAS_SOURCE_INFO 0x0020 -/** GpsLocation has valid "is indoor?" flag */ -#define GPS_LOCATION_HAS_IS_INDOOR 0x0040 -/** GpsLocation has valid floor number */ -#define GPS_LOCATION_HAS_FLOOR_NUMBER 0x0080 -/** GpsLocation has valid map URL*/ -#define GPS_LOCATION_HAS_MAP_URL 0x0100 -/** GpsLocation has valid map index */ -#define GPS_LOCATION_HAS_MAP_INDEX 0x0200 +/** LocGpsLocation has valid "is indoor?" flag */ +#define LOC_GPS_LOCATION_HAS_IS_INDOOR 0x0040 +/** LocGpsLocation has valid floor number */ +#define LOC_GPS_LOCATION_HAS_FLOOR_NUMBER 0x0080 +/** LocGpsLocation has valid map URL*/ +#define LOC_GPS_LOCATION_HAS_MAP_URL 0x0100 +/** LocGpsLocation has valid map index */ +#define LOC_GPS_LOCATION_HAS_MAP_INDEX 0x0200 /** Sizes for indoor fields */ #define GPS_LOCATION_MAP_URL_SIZE 400 @@ -76,31 +77,54 @@ extern "C" { #define ULP_LOCATION_IS_FROM_PIP 0x0040 /** Position is from external DR solution*/ #define ULP_LOCATION_IS_FROM_EXT_DR 0X0080 +/** Raw GNSS position fixes */ +#define ULP_LOCATION_IS_FROM_GNSS_RAW 0X0100 + +typedef uint32_t LocSvInfoSource; +/** SVinfo source is GNSS/DR */ +#define ULP_SVINFO_IS_FROM_GNSS ((LocSvInfoSource)0x0001) +/** Raw SVinfo from GNSS */ +#define ULP_SVINFO_IS_FROM_DR ((LocSvInfoSource)0x0002) #define ULP_MIN_INTERVAL_INVALID 0xffffffff +#define ULP_MAX_NMEA_STRING_SIZE 201 /*Emergency SUPL*/ -#define GPS_NI_TYPE_EMERGENCY_SUPL 4 +#define LOC_GPS_NI_TYPE_EMERGENCY_SUPL 4 -#define AGPS_CERTIFICATE_MAX_LENGTH 2000 -#define AGPS_CERTIFICATE_MAX_SLOTS 10 +#define LOC_AGPS_CERTIFICATE_MAX_LENGTH 2000 +#define LOC_AGPS_CERTIFICATE_MAX_SLOTS 10 + +typedef uint32_t LocPosTechMask; +#define LOC_POS_TECH_MASK_DEFAULT ((LocPosTechMask)0x00000000) +#define LOC_POS_TECH_MASK_SATELLITE ((LocPosTechMask)0x00000001) +#define LOC_POS_TECH_MASK_CELLID ((LocPosTechMask)0x00000002) +#define LOC_POS_TECH_MASK_WIFI ((LocPosTechMask)0x00000004) +#define LOC_POS_TECH_MASK_SENSORS ((LocPosTechMask)0x00000008) +#define LOC_POS_TECH_MASK_REFERENCE_LOCATION ((LocPosTechMask)0x00000010) +#define LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION ((LocPosTechMask)0x00000020) +#define LOC_POS_TECH_MASK_AFLT ((LocPosTechMask)0x00000040) +#define LOC_POS_TECH_MASK_HYBRID ((LocPosTechMask)0x00000080) enum loc_registration_mask_status { LOC_REGISTRATION_MASK_ENABLED, - LOC_REGISTRATION_MASK_DISABLED + LOC_REGISTRATION_MASK_DISABLED, + LOC_REGISTRATION_MASK_SET }; typedef enum { LOC_SUPPORTED_FEATURE_ODCPI_2_V02 = 0, /**< Support ODCPI version 2 feature */ - LOC_SUPPORTED_FEATURE_WIFI_AP_DATA_INJECT_2_V02 /**< Support Wifi AP data inject version 2 feature */ + LOC_SUPPORTED_FEATURE_WIFI_AP_DATA_INJECT_2_V02, /**< Support Wifi AP data inject version 2 feature */ + LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02 /**< Support debug NMEA feature */ } loc_supported_feature_enum; typedef struct { /** set to sizeof(UlpLocation) */ size_t size; - GpsLocation gpsLocation; + LocGpsLocation gpsLocation; /* Provider indicator for HYBRID or GPS */ uint16_t position_source; + LocPosTechMask tech_mask; /*allows HAL to pass additional information related to the location */ int rawDataSize; /* in # of bytes */ void * rawData; @@ -110,34 +134,53 @@ typedef struct { unsigned char map_index[GPS_LOCATION_MAP_INDEX_SIZE]; } UlpLocation; +typedef struct { + /** set to sizeof(UlpNmea) */ + size_t size; + char nmea_str[ULP_MAX_NMEA_STRING_SIZE]; + unsigned int len; +} UlpNmea; + + /** AGPS type */ -typedef int16_t AGpsExtType; -#define AGPS_TYPE_INVALID -1 -#define AGPS_TYPE_ANY 0 -#define AGPS_TYPE_SUPL 1 -#define AGPS_TYPE_C2K 2 -#define AGPS_TYPE_WWAN_ANY 3 -#define AGPS_TYPE_WIFI 4 -#define AGPS_TYPE_SUPL_ES 5 +typedef int8_t AGpsExtType; +#define LOC_AGPS_TYPE_INVALID -1 +#define LOC_AGPS_TYPE_ANY 0 +#define LOC_AGPS_TYPE_SUPL 1 +#define LOC_AGPS_TYPE_C2K 2 +#define LOC_AGPS_TYPE_WWAN_ANY 3 +#define LOC_AGPS_TYPE_WIFI 4 +#define LOC_AGPS_TYPE_SUPL_ES 5 /** SSID length */ #define SSID_BUF_SIZE (32+1) typedef int16_t AGpsBearerType; -#define AGPS_APN_BEARER_INVALID -1 -#define AGPS_APN_BEARER_IPV4 0 -#define AGPS_APN_BEARER_IPV6 1 -#define AGPS_APN_BEARER_IPV4V6 2 +#define AGPS_APN_BEARER_INVALID 0 +#define AGPS_APN_BEARER_IPV4 1 +#define AGPS_APN_BEARER_IPV6 2 +#define AGPS_APN_BEARER_IPV4V6 3 + +typedef enum { + AGPS_CB_PRIORITY_LOW = 1, + AGPS_CB_PRIORITY_MED = 2, + AGPS_CB_PRIORITY_HIGH = 3 +} AgpsCbPriority; + +typedef struct { + void* statusV4Cb; + AgpsCbPriority cbPriority; +} AgpsCbInfo; /** GPS extended callback structure. */ typedef struct { - /** set to sizeof(GpsCallbacks) */ + /** set to sizeof(LocGpsCallbacks) */ size_t size; - gps_set_capabilities set_capabilities_cb; - gps_acquire_wakelock acquire_wakelock_cb; - gps_release_wakelock release_wakelock_cb; - gps_create_thread create_thread_cb; - gps_request_utc_time request_utc_time_cb; + loc_gps_set_capabilities set_capabilities_cb; + loc_gps_acquire_wakelock acquire_wakelock_cb; + loc_gps_release_wakelock release_wakelock_cb; + loc_gps_create_thread create_thread_cb; + loc_gps_request_utc_time request_utc_time_cb; } GpsExtCallbacks; /** Callback to report the xtra server url to the client. @@ -148,8 +191,8 @@ typedef void (* report_xtra_server)(const char*, const char*, const char*); /** Callback structure for the XTRA interface. */ typedef struct { - gps_xtra_download_request download_request_cb; - gps_create_thread create_thread_cb; + loc_gps_xtra_download_request download_request_cb; + loc_gps_create_thread create_thread_cb; report_xtra_server report_xtra_server_cb; } GpsXtraExtCallbacks; @@ -159,7 +202,7 @@ typedef struct { size_t size; AGpsExtType type; - AGpsStatusValue status; + LocAGpsStatusValue status; uint32_t ipv4_addr; struct sockaddr_storage addr; char ssid[SSID_BUF_SIZE]; @@ -174,11 +217,11 @@ typedef void (* agps_status_extended)(AGpsExtStatus* status); /** Callback structure for the AGPS interface. */ typedef struct { agps_status_extended status_cb; - gps_create_thread create_thread_cb; + loc_gps_create_thread create_thread_cb; } AGpsExtCallbacks; -typedef void (*loc_ni_notify_callback)(GpsNiNotification *notification, bool esEnalbed); +typedef void (*loc_ni_notify_callback)(LocGpsNiNotification *notification, bool esEnalbed); /** GPS NI callback structure. */ typedef struct { @@ -228,7 +271,7 @@ typedef enum loc_position_mode_type { #define GPS_DEFAULT_FIX_INTERVAL_MS 1000 /** Flags to indicate which values are valid in a GpsLocationExtended. */ -typedef uint16_t GpsLocationExtendedFlags; +typedef uint32_t GpsLocationExtendedFlags; /** GpsLocationExtended has valid pdop, hdop, vdop. */ #define GPS_LOCATION_EXTENDED_HAS_DOP 0x0001 /** GpsLocationExtended has valid altitude mean sea level. */ @@ -253,6 +296,63 @@ typedef uint16_t GpsLocationExtendedFlags; #define GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MINOR 0x0400 /** GpsLocationExtended has valid Elliptical Horizontal Uncertainty Azimuth */ #define GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_AZIMUTH 0x0800 +/** GpsLocationExtended has valid gnss sv used in position data */ +#define GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA 0x1000 +/** GpsLocationExtended has valid navSolutionMask */ +#define GPS_LOCATION_EXTENDED_HAS_NAV_SOLUTION_MASK 0x2000 +/** GpsLocationExtended has valid LocPosTechMask */ +#define GPS_LOCATION_EXTENDED_HAS_POS_TECH_MASK 0x4000 +/** GpsLocationExtended has valid LocSvInfoSource */ +#define GPS_LOCATION_EXTENDED_HAS_SV_SOURCE_INFO 0x8000 +/** GpsLocationExtended has valid position dynamics data */ +#define GPS_LOCATION_EXTENDED_HAS_POS_DYNAMICS_DATA 0x10000 +/** GpsLocationExtended has GPS Time */ +#define GPS_LOCATION_EXTENDED_HAS_GPS_TIME 0x20000 + +typedef uint32_t LocNavSolutionMask; +/* Bitmask to specify whether SBAS ionospheric correction is used */ +#define LOC_NAV_MASK_SBAS_CORRECTION_IONO ((LocNavSolutionMask)0x0001) +/* Bitmask to specify whether SBAS fast correction is used */ +#define LOC_NAV_MASK_SBAS_CORRECTION_FAST ((LocNavSolutionMask)0x0002) +/**< Bitmask to specify whether SBAS long-tem correction is used */ +#define LOC_NAV_MASK_SBAS_CORRECTION_LONG ((LocNavSolutionMask)0x0004) +/**< Bitmask to specify whether SBAS integrity information is used */ +#define LOC_NAV_MASK_SBAS_INTEGRITY ((LocNavSolutionMask)0x0008) + +typedef uint32_t LocPosDataMask; +/* Bitmask to specify whether Navigation data has Forward Acceleration */ +#define LOC_NAV_DATA_HAS_LONG_ACCEL ((LocPosDataMask)0x0001) +/* Bitmask to specify whether Navigation data has Sideward Acceleration */ +#define LOC_NAV_DATA_HAS_LAT_ACCEL ((LocPosDataMask)0x0002) +/* Bitmask to specify whether Navigation data has Vertical Acceleration */ +#define LOC_NAV_DATA_HAS_VERT_ACCEL ((LocPosDataMask)0x0004) +/* Bitmask to specify whether Navigation data has Heading Rate */ +#define LOC_NAV_DATA_HAS_YAW_RATE ((LocPosDataMask)0x0008) +/* Bitmask to specify whether Navigation data has Body pitch */ +#define LOC_NAV_DATA_HAS_PITCH ((LocPosDataMask)0x0010) + +/** GPS PRN Range */ +#define GPS_SV_PRN_MIN 1 +#define GPS_SV_PRN_MAX 32 +#define GLO_SV_PRN_MIN 65 +#define GLO_SV_PRN_MAX 96 +#define QZSS_SV_PRN_MIN 193 +#define QZSS_SV_PRN_MAX 197 +#define BDS_SV_PRN_MIN 201 +#define BDS_SV_PRN_MAX 235 +#define GAL_SV_PRN_MIN 301 +#define GAL_SV_PRN_MAX 336 + +typedef uint32_t LocPosTechMask; +#define LOC_POS_TECH_MASK_DEFAULT ((LocPosTechMask)0x00000000) +#define LOC_POS_TECH_MASK_SATELLITE ((LocPosTechMask)0x00000001) +#define LOC_POS_TECH_MASK_CELLID ((LocPosTechMask)0x00000002) +#define LOC_POS_TECH_MASK_WIFI ((LocPosTechMask)0x00000004) +#define LOC_POS_TECH_MASK_SENSORS ((LocPosTechMask)0x00000008) +#define LOC_POS_TECH_MASK_REFERENCE_LOCATION ((LocPosTechMask)0x00000010) +#define LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION ((LocPosTechMask)0x00000020) +#define LOC_POS_TECH_MASK_AFLT ((LocPosTechMask)0x00000040) +#define LOC_POS_TECH_MASK_HYBRID ((LocPosTechMask)0x00000080) typedef enum { LOC_RELIABILITY_NOT_SET = 0, @@ -269,12 +369,48 @@ typedef struct { /* timestamp uncertainty in milli seconds */ }Gnss_ApTimeStampStructType; +typedef struct { + uint64_t gps_sv_used_ids_mask; + uint64_t glo_sv_used_ids_mask; + uint64_t gal_sv_used_ids_mask; + uint64_t bds_sv_used_ids_mask; + uint64_t qzss_sv_used_ids_mask; +} GnssSvUsedInPosition; + +/* Body Frame parameters */ +typedef struct { + /** Contains Body frame LocPosDataMask bits. */ + uint32_t bodyFrameDatamask; + /* Forward Acceleration in body frame (m/s2)*/ + float longAccel; + /* Sideward Acceleration in body frame (m/s2)*/ + float latAccel; + /* Vertical Acceleration in body frame (m/s2)*/ + float vertAccel; + /* Heading Rate (Radians/second) */ + float yawRate; + /* Body pitch (Radians) */ + float pitch; +}LocPositionDynamics; + +/* GPS Time structure */ +typedef struct { + + /**< Current GPS week as calculated from midnight, Jan. 6, 1980. \n + - Units: Weeks */ + uint16_t gpsWeek; + + /**< Amount of time into the current GPS week. \n + - Units: Milliseconds */ + uint32_t gpsTimeOfWeekMs; +}GPSTimeStruct; + /** Represents gps location extended. */ typedef struct { /** set to sizeof(GpsLocationExtended) */ size_t size; /** Contains GpsLocationExtendedFlags bits. */ - uint16_t flags; + uint32_t flags; /** Contains the Altitude wrt mean sea level */ float altitudeMeanSeaLevel; /** Contains Position Dilusion of Precision. */ @@ -303,6 +439,18 @@ typedef struct { float horUncEllipseOrientAzimuth; Gnss_ApTimeStampStructType timeStamp; + /** Gnss sv used in position data */ + GnssSvUsedInPosition gnss_sv_used_ids; + /** Nav solution mask to indicate sbas corrections */ + LocNavSolutionMask navSolutionMask; + /** Position technology used in computing this fix */ + LocPosTechMask tech_mask; + /** SV Info source used in computing this fix */ + LocSvInfoSource sv_source; + /** Body Frame Dynamics: 4wayAcceleration and pitch set with validity */ + LocPositionDynamics bodyFrameData; + /** GPS Time */ + GPSTimeStruct gpsTime; } GpsLocationExtended; enum loc_sess_status { @@ -311,17 +459,6 @@ enum loc_sess_status { LOC_SESS_FAILURE }; -typedef uint32_t LocPosTechMask; -#define LOC_POS_TECH_MASK_DEFAULT ((LocPosTechMask)0x00000000) -#define LOC_POS_TECH_MASK_SATELLITE ((LocPosTechMask)0x00000001) -#define LOC_POS_TECH_MASK_CELLID ((LocPosTechMask)0x00000002) -#define LOC_POS_TECH_MASK_WIFI ((LocPosTechMask)0x00000004) -#define LOC_POS_TECH_MASK_SENSORS ((LocPosTechMask)0x00000008) -#define LOC_POS_TECH_MASK_REFERENCE_LOCATION ((LocPosTechMask)0x00000010) -#define LOC_POS_TECH_MASK_INJECTED_COARSE_POSITION ((LocPosTechMask)0x00000020) -#define LOC_POS_TECH_MASK_AFLT ((LocPosTechMask)0x00000040) -#define LOC_POS_TECH_MASK_HYBRID ((LocPosTechMask)0x00000080) - // Nmea sentence types mask typedef uint32_t NmeaSentenceTypesMask; #define LOC_NMEA_MASK_GGA_V02 ((NmeaSentenceTypesMask)0x00000001) /**< Enable GGA type */ @@ -341,14 +478,15 @@ typedef uint32_t NmeaSentenceTypesMask; #define LOC_NMEA_MASK_GAGGA_V02 ((NmeaSentenceTypesMask)0x00004000) /**< Enable GAGGA type */ #define LOC_NMEA_MASK_PQGSA_V02 ((NmeaSentenceTypesMask)0x00008000) /**< Enable PQGSA type */ #define LOC_NMEA_MASK_PQGSV_V02 ((NmeaSentenceTypesMask)0x00010000) /**< Enable PQGSV type */ -#define LOC_NMEA_ALL_SUPPORTED_MASK (LOC_NMEA_MASK_GGA_V02 | LOC_NMEA_MASK_RMC_V02 | \ +#define LOC_NMEA_MASK_DEBUG_V02 ((NmeaSentenceTypesMask)0x00020000) /**< Enable DEBUG type */ + +// all bitmasks of general supported NMEA sentenses - debug is not part of this +#define LOC_NMEA_ALL_GENERAL_SUPPORTED_MASK (LOC_NMEA_MASK_GGA_V02 | LOC_NMEA_MASK_RMC_V02 | \ LOC_NMEA_MASK_GSV_V02 | LOC_NMEA_MASK_GSA_V02 | LOC_NMEA_MASK_VTG_V02 | \ LOC_NMEA_MASK_PQXFI_V02 | LOC_NMEA_MASK_PSTIS_V02 | LOC_NMEA_MASK_GLGSV_V02 | \ LOC_NMEA_MASK_GNGSA_V02 | LOC_NMEA_MASK_GNGNS_V02 | LOC_NMEA_MASK_GARMC_V02 | \ LOC_NMEA_MASK_GAGSV_V02 | LOC_NMEA_MASK_GAGSA_V02 | LOC_NMEA_MASK_GAVTG_V02 | \ - LOC_NMEA_MASK_GAGGA_V02 | LOC_NMEA_MASK_PQGSA_V02 | LOC_NMEA_MASK_PQGSV_V02 ) - - + LOC_NMEA_MASK_GAGGA_V02 | LOC_NMEA_MASK_PQGSA_V02 | LOC_NMEA_MASK_PQGSV_V02) typedef enum { LOC_ENG_IF_REQUEST_SENDER_ID_QUIPC = 0, @@ -419,6 +557,9 @@ enum loc_api_adapter_event_index { LOC_API_ADAPTER_GNSS_MEASUREMENT, // GNSS Measurement report LOC_API_ADAPTER_REQUEST_TIMEZONE, // Timezone injection request LOC_API_ADAPTER_REPORT_GENFENCE_DWELL_REPORT, // Geofence dwell report + LOC_API_ADAPTER_REQUEST_SRN_DATA, // request srn data from AP + LOC_API_ADAPTER_REQUEST_POSITION_INJECTION, // Position injection request + LOC_API_ADAPTER_BATCH_STATUS, // batch status LOC_API_ADAPTER_EVENT_MAX }; @@ -451,6 +592,10 @@ enum loc_api_adapter_event_index { #define LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT (1< diff --git a/gps/utils/loc_cfg.h b/gps/utils/loc_cfg.h index 9045e1d..0a0f100 100644 --- a/gps/utils/loc_cfg.h +++ b/gps/utils/loc_cfg.h @@ -56,10 +56,10 @@ typedef struct { const char *param_name; void *param_ptr; - uint8_t *param_set; /* was this value set by config file? */ + uint8_t *param_set; /* indicate value set by config file */ char param_type; /* 'n' for number, 's' for string, - 'f' for float */ + 'f' for double */ } loc_param_s_type; /*============================================================================= diff --git a/gps/utils/loc_gps.h b/gps/utils/loc_gps.h new file mode 100644 index 0000000..5e915a3 --- /dev/null +++ b/gps/utils/loc_gps.h @@ -0,0 +1,2209 @@ +/* + * Copyright (C) 2010 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LOC_GPS_H +#define LOC_GPS_H + +#include +#include +#include +#include +#include +#include + +__BEGIN_DECLS + +#define LOC_FLP_STATUS_LOCATION_AVAILABLE 0 +#define LOC_FLP_STATUS_LOCATION_UNAVAILABLE 1 +#define LOC_CAPABILITY_GNSS (1U<<0) +#define LOC_CAPABILITY_WIFI (1U<<1) +#define LOC_CAPABILITY_CELL (1U<<3) + +/** Milliseconds since January 1, 1970 */ +typedef int64_t LocGpsUtcTime; + +/** Maximum number of SVs for loc_gps_sv_status_callback(). */ +#define LOC_GPS_MAX_SVS 32 +/** Maximum number of SVs for loc_gps_sv_status_callback(). */ +#define LOC_GNSS_MAX_SVS 64 + +/** Maximum number of Measurements in loc_gps_measurement_callback(). */ +#define LOC_GPS_MAX_MEASUREMENT 32 + +/** Maximum number of Measurements in loc_gnss_measurement_callback(). */ +#define LOC_GNSS_MAX_MEASUREMENT 64 + +/** Requested operational mode for GPS operation. */ +typedef uint32_t LocGpsPositionMode; +/* IMPORTANT: Note that the following values must match + * constants in GpsLocationProvider.java. */ +/** Mode for running GPS standalone (no assistance). */ +#define LOC_GPS_POSITION_MODE_STANDALONE 0 +/** AGPS MS-Based mode. */ +#define LOC_GPS_POSITION_MODE_MS_BASED 1 +/** + * AGPS MS-Assisted mode. This mode is not maintained by the platform anymore. + * It is strongly recommended to use LOC_GPS_POSITION_MODE_MS_BASED instead. + */ +#define LOC_GPS_POSITION_MODE_MS_ASSISTED 2 + +/** Requested recurrence mode for GPS operation. */ +typedef uint32_t LocGpsPositionRecurrence; +/* IMPORTANT: Note that the following values must match + * constants in GpsLocationProvider.java. */ +/** Receive GPS fixes on a recurring basis at a specified period. */ +#define LOC_GPS_POSITION_RECURRENCE_PERIODIC 0 +/** Request a single shot GPS fix. */ +#define LOC_GPS_POSITION_RECURRENCE_SINGLE 1 + +/** GPS status event values. */ +typedef uint16_t LocGpsStatusValue; +/* IMPORTANT: Note that the following values must match + * constants in GpsLocationProvider.java. */ +/** GPS status unknown. */ +#define LOC_GPS_STATUS_NONE 0 +/** GPS has begun navigating. */ +#define LOC_GPS_STATUS_SESSION_BEGIN 1 +/** GPS has stopped navigating. */ +#define LOC_GPS_STATUS_SESSION_END 2 +/** GPS has powered on but is not navigating. */ +#define LOC_GPS_STATUS_ENGINE_ON 3 +/** GPS is powered off. */ +#define LOC_GPS_STATUS_ENGINE_OFF 4 + +/** Flags to indicate which values are valid in a LocGpsLocation. */ +typedef uint16_t LocGpsLocationFlags; +/* IMPORTANT: Note that the following values must match + * constants in GpsLocationProvider.java. */ +/** LocGpsLocation has valid latitude and longitude. */ +#define LOC_GPS_LOCATION_HAS_LAT_LONG 0x0001 +/** LocGpsLocation has valid altitude. */ +#define LOC_GPS_LOCATION_HAS_ALTITUDE 0x0002 +/** LocGpsLocation has valid speed. */ +#define LOC_GPS_LOCATION_HAS_SPEED 0x0004 +/** LocGpsLocation has valid bearing. */ +#define LOC_GPS_LOCATION_HAS_BEARING 0x0008 +/** LocGpsLocation has valid accuracy. */ +#define LOC_GPS_LOCATION_HAS_ACCURACY 0x0010 +/** LocGpsLocation has valid vertical uncertainity */ +#define LOC_GPS_LOCATION_HAS_VERT_UNCERTAINITY 0x0040 + +/** Flags for the loc_gps_set_capabilities callback. */ + +/** + * GPS HAL schedules fixes for LOC_GPS_POSITION_RECURRENCE_PERIODIC mode. If this is + * not set, then the framework will use 1000ms for min_interval and will start + * and call start() and stop() to schedule the GPS. + */ +#define LOC_GPS_CAPABILITY_SCHEDULING (1 << 0) +/** GPS supports MS-Based AGPS mode */ +#define LOC_GPS_CAPABILITY_MSB (1 << 1) +/** GPS supports MS-Assisted AGPS mode */ +#define LOC_GPS_CAPABILITY_MSA (1 << 2) +/** GPS supports single-shot fixes */ +#define LOC_GPS_CAPABILITY_SINGLE_SHOT (1 << 3) +/** GPS supports on demand time injection */ +#define LOC_GPS_CAPABILITY_ON_DEMAND_TIME (1 << 4) +/** GPS supports Geofencing */ +#define LOC_GPS_CAPABILITY_GEOFENCING (1 << 5) +/** GPS supports Measurements. */ +#define LOC_GPS_CAPABILITY_MEASUREMENTS (1 << 6) +/** GPS supports Navigation Messages */ +#define LOC_GPS_CAPABILITY_NAV_MESSAGES (1 << 7) + +/** + * Flags used to specify which aiding data to delete when calling + * delete_aiding_data(). + */ +typedef uint16_t LocGpsAidingData; +/* IMPORTANT: Note that the following values must match + * constants in GpsLocationProvider.java. */ +#define LOC_GPS_DELETE_EPHEMERIS 0x0001 +#define LOC_GPS_DELETE_ALMANAC 0x0002 +#define LOC_GPS_DELETE_POSITION 0x0004 +#define LOC_GPS_DELETE_TIME 0x0008 +#define LOC_GPS_DELETE_IONO 0x0010 +#define LOC_GPS_DELETE_UTC 0x0020 +#define LOC_GPS_DELETE_HEALTH 0x0040 +#define LOC_GPS_DELETE_SVDIR 0x0080 +#define LOC_GPS_DELETE_SVSTEER 0x0100 +#define LOC_GPS_DELETE_SADATA 0x0200 +#define LOC_GPS_DELETE_RTI 0x0400 +#define LOC_GPS_DELETE_CELLDB_INFO 0x8000 +#define LOC_GPS_DELETE_ALL 0xFFFF + +/** AGPS type */ +typedef uint16_t LocAGpsType; +#define LOC_AGPS_TYPE_SUPL 1 +#define LOC_AGPS_TYPE_C2K 2 + +typedef uint16_t LocAGpsSetIDType; +#define LOC_AGPS_SETID_TYPE_NONE 0 +#define LOC_AGPS_SETID_TYPE_IMSI 1 +#define LOC_AGPS_SETID_TYPE_MSISDN 2 + +typedef uint16_t LocApnIpType; +#define LOC_APN_IP_INVALID 0 +#define LOC_APN_IP_IPV4 1 +#define LOC_APN_IP_IPV6 2 +#define LOC_APN_IP_IPV4V6 3 + +/** + * String length constants + */ +#define LOC_GPS_NI_SHORT_STRING_MAXLEN 256 +#define LOC_GPS_NI_LONG_STRING_MAXLEN 2048 + +/** + * LocGpsNiType constants + */ +typedef uint32_t LocGpsNiType; +#define LOC_GPS_NI_TYPE_VOICE 1 +#define LOC_GPS_NI_TYPE_UMTS_SUPL 2 +#define LOC_GPS_NI_TYPE_UMTS_CTRL_PLANE 3 +/*Emergency SUPL*/ +#define LOC_GPS_NI_TYPE_EMERGENCY_SUPL 4 + +/** + * LocGpsNiNotifyFlags constants + */ +typedef uint32_t LocGpsNiNotifyFlags; +/** NI requires notification */ +#define LOC_GPS_NI_NEED_NOTIFY 0x0001 +/** NI requires verification */ +#define LOC_GPS_NI_NEED_VERIFY 0x0002 +/** NI requires privacy override, no notification/minimal trace */ +#define LOC_GPS_NI_PRIVACY_OVERRIDE 0x0004 + +/** + * GPS NI responses, used to define the response in + * NI structures + */ +typedef int LocGpsUserResponseType; +#define LOC_GPS_NI_RESPONSE_ACCEPT 1 +#define LOC_GPS_NI_RESPONSE_DENY 2 +#define LOC_GPS_NI_RESPONSE_NORESP 3 + +/** + * NI data encoding scheme + */ +typedef int LocGpsNiEncodingType; +#define LOC_GPS_ENC_NONE 0 +#define LOC_GPS_ENC_SUPL_GSM_DEFAULT 1 +#define LOC_GPS_ENC_SUPL_UTF8 2 +#define LOC_GPS_ENC_SUPL_UCS2 3 +#define LOC_GPS_ENC_UNKNOWN -1 + +/** AGPS status event values. */ +typedef uint8_t LocAGpsStatusValue; +/** GPS requests data connection for AGPS. */ +#define LOC_GPS_REQUEST_AGPS_DATA_CONN 1 +/** GPS releases the AGPS data connection. */ +#define LOC_GPS_RELEASE_AGPS_DATA_CONN 2 +/** AGPS data connection initiated */ +#define LOC_GPS_AGPS_DATA_CONNECTED 3 +/** AGPS data connection completed */ +#define LOC_GPS_AGPS_DATA_CONN_DONE 4 +/** AGPS data connection failed */ +#define LOC_GPS_AGPS_DATA_CONN_FAILED 5 + +typedef uint16_t LocAGpsRefLocationType; +#define LOC_AGPS_REF_LOCATION_TYPE_GSM_CELLID 1 +#define LOC_AGPS_REF_LOCATION_TYPE_UMTS_CELLID 2 +#define LOC_AGPS_REF_LOCATION_TYPE_MAC 3 +#define LOC_AGPS_REF_LOCATION_TYPE_LTE_CELLID 4 + +/* Deprecated, to be removed in the next Android release. */ +#define LOC_AGPS_REG_LOCATION_TYPE_MAC 3 + +/** Network types for update_network_state "type" parameter */ +#define LOC_AGPS_RIL_NETWORK_TYPE_MOBILE 0 +#define LOC_AGPS_RIL_NETWORK_TYPE_WIFI 1 +#define LOC_AGPS_RIL_NETWORK_TYPE_MOBILE_MMS 2 +#define LOC_AGPS_RIL_NETWORK_TYPE_MOBILE_SUPL 3 +#define LOC_AGPS_RIL_NETWORK_TTYPE_MOBILE_DUN 4 +#define LOC_AGPS_RIL_NETWORK_TTYPE_MOBILE_HIPRI 5 +#define LOC_AGPS_RIL_NETWORK_TTYPE_WIMAX 6 + +/* The following typedef together with its constants below are deprecated, and + * will be removed in the next release. */ +typedef uint16_t LocGpsClockFlags; +#define LOC_GPS_CLOCK_HAS_LEAP_SECOND (1<<0) +#define LOC_GPS_CLOCK_HAS_TIME_UNCERTAINTY (1<<1) +#define LOC_GPS_CLOCK_HAS_FULL_BIAS (1<<2) +#define LOC_GPS_CLOCK_HAS_BIAS (1<<3) +#define LOC_GPS_CLOCK_HAS_BIAS_UNCERTAINTY (1<<4) +#define LOC_GPS_CLOCK_HAS_DRIFT (1<<5) +#define LOC_GPS_CLOCK_HAS_DRIFT_UNCERTAINTY (1<<6) + +/** + * Flags to indicate what fields in LocGnssClock are valid. + */ +typedef uint16_t LocGnssClockFlags; +/** A valid 'leap second' is stored in the data structure. */ +#define LOC_GNSS_CLOCK_HAS_LEAP_SECOND (1<<0) +/** A valid 'time uncertainty' is stored in the data structure. */ +#define LOC_GNSS_CLOCK_HAS_TIME_UNCERTAINTY (1<<1) +/** A valid 'full bias' is stored in the data structure. */ +#define LOC_GNSS_CLOCK_HAS_FULL_BIAS (1<<2) +/** A valid 'bias' is stored in the data structure. */ +#define LOC_GNSS_CLOCK_HAS_BIAS (1<<3) +/** A valid 'bias uncertainty' is stored in the data structure. */ +#define LOC_GNSS_CLOCK_HAS_BIAS_UNCERTAINTY (1<<4) +/** A valid 'drift' is stored in the data structure. */ +#define LOC_GNSS_CLOCK_HAS_DRIFT (1<<5) +/** A valid 'drift uncertainty' is stored in the data structure. */ +#define LOC_GNSS_CLOCK_HAS_DRIFT_UNCERTAINTY (1<<6) + +/* The following typedef together with its constants below are deprecated, and + * will be removed in the next release. */ +typedef uint8_t LocGpsClockType; +#define LOC_GPS_CLOCK_TYPE_UNKNOWN 0 +#define LOC_GPS_CLOCK_TYPE_LOCAL_HW_TIME 1 +#define LOC_GPS_CLOCK_TYPE_GPS_TIME 2 + +/* The following typedef together with its constants below are deprecated, and + * will be removed in the next release. */ +typedef uint32_t LocGpsMeasurementFlags; +#define LOC_GPS_MEASUREMENT_HAS_SNR (1<<0) +#define LOC_GPS_MEASUREMENT_HAS_ELEVATION (1<<1) +#define LOC_GPS_MEASUREMENT_HAS_ELEVATION_UNCERTAINTY (1<<2) +#define LOC_GPS_MEASUREMENT_HAS_AZIMUTH (1<<3) +#define LOC_GPS_MEASUREMENT_HAS_AZIMUTH_UNCERTAINTY (1<<4) +#define LOC_GPS_MEASUREMENT_HAS_PSEUDORANGE (1<<5) +#define LOC_GPS_MEASUREMENT_HAS_PSEUDORANGE_UNCERTAINTY (1<<6) +#define LOC_GPS_MEASUREMENT_HAS_CODE_PHASE (1<<7) +#define LOC_GPS_MEASUREMENT_HAS_CODE_PHASE_UNCERTAINTY (1<<8) +#define LOC_GPS_MEASUREMENT_HAS_CARRIER_FREQUENCY (1<<9) +#define LOC_GPS_MEASUREMENT_HAS_CARRIER_CYCLES (1<<10) +#define LOC_GPS_MEASUREMENT_HAS_CARRIER_PHASE (1<<11) +#define LOC_GPS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY (1<<12) +#define LOC_GPS_MEASUREMENT_HAS_BIT_NUMBER (1<<13) +#define LOC_GPS_MEASUREMENT_HAS_TIME_FROM_LAST_BIT (1<<14) +#define LOC_GPS_MEASUREMENT_HAS_DOPPLER_SHIFT (1<<15) +#define LOC_GPS_MEASUREMENT_HAS_DOPPLER_SHIFT_UNCERTAINTY (1<<16) +#define LOC_GPS_MEASUREMENT_HAS_USED_IN_FIX (1<<17) +#define LOC_GPS_MEASUREMENT_HAS_UNCORRECTED_PSEUDORANGE_RATE (1<<18) + +/** + * Flags to indicate what fields in LocGnssMeasurement are valid. + */ +typedef uint32_t LocGnssMeasurementFlags; +/** A valid 'snr' is stored in the data structure. */ +#define LOC_GNSS_MEASUREMENT_HAS_SNR (1<<0) +/** A valid 'carrier frequency' is stored in the data structure. */ +#define LOC_GNSS_MEASUREMENT_HAS_CARRIER_FREQUENCY (1<<9) +/** A valid 'carrier cycles' is stored in the data structure. */ +#define LOC_GNSS_MEASUREMENT_HAS_CARRIER_CYCLES (1<<10) +/** A valid 'carrier phase' is stored in the data structure. */ +#define LOC_GNSS_MEASUREMENT_HAS_CARRIER_PHASE (1<<11) +/** A valid 'carrier phase uncertainty' is stored in the data structure. */ +#define LOC_GNSS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY (1<<12) + +/* The following typedef together with its constants below are deprecated, and + * will be removed in the next release. */ +typedef uint8_t LocGpsLossOfLock; +#define LOC_GPS_LOSS_OF_LOCK_UNKNOWN 0 +#define LOC_GPS_LOSS_OF_LOCK_OK 1 +#define LOC_GPS_LOSS_OF_LOCK_CYCLE_SLIP 2 + +/* The following typedef together with its constants below are deprecated, and + * will be removed in the next release. Use LocGnssMultipathIndicator instead. + */ +typedef uint8_t LocGpsMultipathIndicator; +#define LOC_GPS_MULTIPATH_INDICATOR_UNKNOWN 0 +#define LOC_GPS_MULTIPATH_INDICATOR_DETECTED 1 +#define LOC_GPS_MULTIPATH_INDICATOR_NOT_USED 2 + +/** + * Enumeration of available values for the GNSS Measurement's multipath + * indicator. + */ +typedef uint8_t LocGnssMultipathIndicator; +/** The indicator is not available or unknown. */ +#define LOC_GNSS_MULTIPATH_INDICATOR_UNKNOWN 0 +/** The measurement is indicated to be affected by multipath. */ +#define LOC_GNSS_MULTIPATH_INDICATOR_PRESENT 1 +/** The measurement is indicated to be not affected by multipath. */ +#define LOC_GNSS_MULTIPATH_INDICATOR_NOT_PRESENT 2 + +/* The following typedef together with its constants below are deprecated, and + * will be removed in the next release. */ +typedef uint16_t LocGpsMeasurementState; +#define LOC_GPS_MEASUREMENT_STATE_UNKNOWN 0 +#define LOC_GPS_MEASUREMENT_STATE_CODE_LOCK (1<<0) +#define LOC_GPS_MEASUREMENT_STATE_BIT_SYNC (1<<1) +#define LOC_GPS_MEASUREMENT_STATE_SUBFRAME_SYNC (1<<2) +#define LOC_GPS_MEASUREMENT_STATE_TOW_DECODED (1<<3) +#define LOC_GPS_MEASUREMENT_STATE_MSEC_AMBIGUOUS (1<<4) + +/** + * Flags indicating the GNSS measurement state. + * + * The expected behavior here is for GPS HAL to set all the flags that applies. + * For example, if the state for a satellite is only C/A code locked and bit + * synchronized, and there is still millisecond ambiguity, the state should be + * set as: + * + * LOC_GNSS_MEASUREMENT_STATE_CODE_LOCK | LOC_GNSS_MEASUREMENT_STATE_BIT_SYNC | + * LOC_GNSS_MEASUREMENT_STATE_MSEC_AMBIGUOUS + * + * If GNSS is still searching for a satellite, the corresponding state should be + * set to LOC_GNSS_MEASUREMENT_STATE_UNKNOWN(0). + */ +typedef uint32_t LocGnssMeasurementState; +#define LOC_GNSS_MEASUREMENT_STATE_UNKNOWN 0 +#define LOC_GNSS_MEASUREMENT_STATE_CODE_LOCK (1<<0) +#define LOC_GNSS_MEASUREMENT_STATE_BIT_SYNC (1<<1) +#define LOC_GNSS_MEASUREMENT_STATE_SUBFRAME_SYNC (1<<2) +#define LOC_GNSS_MEASUREMENT_STATE_TOW_DECODED (1<<3) +#define LOC_GNSS_MEASUREMENT_STATE_MSEC_AMBIGUOUS (1<<4) +#define LOC_GNSS_MEASUREMENT_STATE_SYMBOL_SYNC (1<<5) +#define LOC_GNSS_MEASUREMENT_STATE_GLO_STRING_SYNC (1<<6) +#define LOC_GNSS_MEASUREMENT_STATE_GLO_TOD_DECODED (1<<7) +#define LOC_GNSS_MEASUREMENT_STATE_BDS_D2_BIT_SYNC (1<<8) +#define LOC_GNSS_MEASUREMENT_STATE_BDS_D2_SUBFRAME_SYNC (1<<9) +#define LOC_GNSS_MEASUREMENT_STATE_GAL_E1BC_CODE_LOCK (1<<10) +#define LOC_GNSS_MEASUREMENT_STATE_GAL_E1C_2ND_CODE_LOCK (1<<11) +#define LOC_GNSS_MEASUREMENT_STATE_GAL_E1B_PAGE_SYNC (1<<12) +#define LOC_GNSS_MEASUREMENT_STATE_SBAS_SYNC (1<<13) + +/* The following typedef together with its constants below are deprecated, and + * will be removed in the next release. */ +typedef uint16_t LocGpsAccumulatedDeltaRangeState; +#define LOC_GPS_ADR_STATE_UNKNOWN 0 +#define LOC_GPS_ADR_STATE_VALID (1<<0) +#define LOC_GPS_ADR_STATE_RESET (1<<1) +#define LOC_GPS_ADR_STATE_CYCLE_SLIP (1<<2) + +/** + * Flags indicating the Accumulated Delta Range's states. + */ +typedef uint16_t LocGnssAccumulatedDeltaRangeState; +#define LOC_GNSS_ADR_STATE_UNKNOWN 0 +#define LOC_GNSS_ADR_STATE_VALID (1<<0) +#define LOC_GNSS_ADR_STATE_RESET (1<<1) +#define LOC_GNSS_ADR_STATE_CYCLE_SLIP (1<<2) + +#if 0 +/* The following typedef together with its constants below are deprecated, and + * will be removed in the next release. */ +typedef uint8_t GpsNavigationMessageType; +#define GPS_NAVIGATION_MESSAGE_TYPE_UNKNOWN 0 +#define GPS_NAVIGATION_MESSAGE_TYPE_L1CA 1 +#define GPS_NAVIGATION_MESSAGE_TYPE_L2CNAV 2 +#define GPS_NAVIGATION_MESSAGE_TYPE_L5CNAV 3 +#define GPS_NAVIGATION_MESSAGE_TYPE_CNAV2 4 + +/** + * Enumeration of available values to indicate the GNSS Navigation message + * types. + * + * For convenience, first byte is the LocGnssConstellationType on which that signal + * is typically transmitted + */ +typedef int16_t GnssNavigationMessageType; + +#define GNSS_NAVIGATION_MESSAGE_TYPE_UNKNOWN 0 +/** GPS L1 C/A message contained in the structure. */ +#define GNSS_NAVIGATION_MESSAGE_TYPE_GPS_L1CA 0x0101 +/** GPS L2-CNAV message contained in the structure. */ +#define GNSS_NAVIGATION_MESSAGE_TYPE_GPS_L2CNAV 0x0102 +/** GPS L5-CNAV message contained in the structure. */ +#define GNSS_NAVIGATION_MESSAGE_TYPE_GPS_L5CNAV 0x0103 +/** GPS CNAV-2 message contained in the structure. */ +#define GNSS_NAVIGATION_MESSAGE_TYPE_GPS_CNAV2 0x0104 +/** Glonass L1 CA message contained in the structure. */ +#define GNSS_NAVIGATION_MESSAGE_TYPE_GLO_L1CA 0x0301 +/** Beidou D1 message contained in the structure. */ +#define GNSS_NAVIGATION_MESSAGE_TYPE_BDS_D1 0x0501 +/** Beidou D2 message contained in the structure. */ +#define GNSS_NAVIGATION_MESSAGE_TYPE_BDS_D2 0x0502 +/** Galileo I/NAV message contained in the structure. */ +#define GNSS_NAVIGATION_MESSAGE_TYPE_GAL_I 0x0601 +/** Galileo F/NAV message contained in the structure. */ +#define GNSS_NAVIGATION_MESSAGE_TYPE_GAL_F 0x0602 + +/** + * Status of Navigation Message + * When a message is received properly without any parity error in its navigation words, the + * status should be set to NAV_MESSAGE_STATUS_PARITY_PASSED. But if a message is received + * with words that failed parity check, but GPS is able to correct those words, the status + * should be set to NAV_MESSAGE_STATUS_PARITY_REBUILT. + * No need to send any navigation message that contains words with parity error and cannot be + * corrected. + */ +typedef uint16_t NavigationMessageStatus; +#define NAV_MESSAGE_STATUS_UNKNOWN 0 +#define NAV_MESSAGE_STATUS_PARITY_PASSED (1<<0) +#define NAV_MESSAGE_STATUS_PARITY_REBUILT (1<<1) + +/* This constant is deprecated, and will be removed in the next release. */ +#define NAV_MESSAGE_STATUS_UNKONW 0 +#endif + +/** + * Flags that indicate information about the satellite + */ +typedef uint8_t LocGnssSvFlags; +#define LOC_GNSS_SV_FLAGS_NONE 0 +#define LOC_GNSS_SV_FLAGS_HAS_EPHEMERIS_DATA (1 << 0) +#define LOC_GNSS_SV_FLAGS_HAS_ALMANAC_DATA (1 << 1) +#define LOC_GNSS_SV_FLAGS_USED_IN_FIX (1 << 2) + +/** + * Constellation type of LocGnssSvInfo + */ +typedef uint8_t LocGnssConstellationType; +#define LOC_GNSS_CONSTELLATION_UNKNOWN 0 +#define LOC_GNSS_CONSTELLATION_GPS 1 +#define LOC_GNSS_CONSTELLATION_SBAS 2 +#define LOC_GNSS_CONSTELLATION_GLONASS 3 +#define LOC_GNSS_CONSTELLATION_QZSS 4 +#define LOC_GNSS_CONSTELLATION_BEIDOU 5 +#define LOC_GNSS_CONSTELLATION_GALILEO 6 + +/** + * Name for the GPS XTRA interface. + */ +#define LOC_GPS_XTRA_INTERFACE "gps-xtra" + +/** + * Name for the GPS DEBUG interface. + */ +#define LOC_GPS_DEBUG_INTERFACE "gps-debug" + +/** + * Name for the AGPS interface. + */ + +#define LOC_AGPS_INTERFACE "agps" + +/** + * Name of the Supl Certificate interface. + */ +#define LOC_SUPL_CERTIFICATE_INTERFACE "supl-certificate" + +/** + * Name for NI interface + */ +#define LOC_GPS_NI_INTERFACE "gps-ni" + +/** + * Name for the AGPS-RIL interface. + */ +#define LOC_AGPS_RIL_INTERFACE "agps_ril" + +/** + * Name for the GPS_Geofencing interface. + */ +#define LOC_GPS_GEOFENCING_INTERFACE "gps_geofencing" + +/** + * Name of the GPS Measurements interface. + */ +#define LOC_GPS_MEASUREMENT_INTERFACE "gps_measurement" + +/** + * Name of the GPS navigation message interface. + */ +#define LOC_GPS_NAVIGATION_MESSAGE_INTERFACE "gps_navigation_message" + +/** + * Name of the GNSS/GPS configuration interface. + */ +#define LOC_GNSS_CONFIGURATION_INTERFACE "gnss_configuration" + +/** Represents a location. */ +typedef struct { + /** set to sizeof(LocGpsLocation) */ + size_t size; + /** Contains LocGpsLocationFlags bits. */ + uint16_t flags; + /** Represents latitude in degrees. */ + double latitude; + /** Represents longitude in degrees. */ + double longitude; + /** + * Represents altitude in meters above the WGS 84 reference ellipsoid. + */ + double altitude; + /** Represents horizontal speed in meters per second. */ + float speed; + /** Represents heading in degrees. */ + float bearing; + /** Represents expected accuracy in meters. */ + float accuracy; + /** Represents the expected vertical uncertainity in meters*/ + float vertUncertainity; + /** Timestamp for the location fix. */ + LocGpsUtcTime timestamp; +} LocGpsLocation; + +/** Represents the status. */ +typedef struct { + /** set to sizeof(LocGpsStatus) */ + size_t size; + LocGpsStatusValue status; +} LocGpsStatus; + +/** + * Legacy struct to represents SV information. + * Deprecated, to be removed in the next Android release. + * Use LocGnssSvInfo instead. + */ +typedef struct { + /** set to sizeof(LocGpsSvInfo) */ + size_t size; + /** Pseudo-random number for the SV. */ + int prn; + /** Signal to noise ratio. */ + float snr; + /** Elevation of SV in degrees. */ + float elevation; + /** Azimuth of SV in degrees. */ + float azimuth; +} LocGpsSvInfo; + +typedef struct { + /** set to sizeof(LocGnssSvInfo) */ + size_t size; + + /** + * Pseudo-random number for the SV, or FCN/OSN number for Glonass. The + * distinction is made by looking at constellation field. Values should be + * in the range of: + * + * - GPS: 1-32 + * - SBAS: 120-151, 183-192 + * - GLONASS: 1-24, the orbital slot number (OSN), if known. Or, if not: + * 93-106, the frequency channel number (FCN) (-7 to +6) offset by + 100 + * i.e. report an FCN of -7 as 93, FCN of 0 as 100, and FCN of +6 as 106. + * - QZSS: 193-200 + * - Galileo: 1-36 + * - Beidou: 1-37 + */ + int16_t svid; + + /** + * Defines the constellation of the given SV. Value should be one of those + * LOC_GNSS_CONSTELLATION_* constants + */ + LocGnssConstellationType constellation; + + /** + * Carrier-to-noise density in dB-Hz, typically in the range [0, 63]. + * It contains the measured C/N0 value for the signal at the antenna port. + * + * This is a mandatory value. + */ + float c_n0_dbhz; + + /** Elevation of SV in degrees. */ + float elevation; + + /** Azimuth of SV in degrees. */ + float azimuth; + + /** + * Contains additional data about the given SV. Value should be one of those + * LOC_GNSS_SV_FLAGS_* constants + */ + LocGnssSvFlags flags; + +} LocGnssSvInfo; + +/** + * Legacy struct to represents SV status. + * Deprecated, to be removed in the next Android release. + * Use LocGnssSvStatus instead. + */ +typedef struct { + /** set to sizeof(LocGpsSvStatus) */ + size_t size; + int num_svs; + LocGpsSvInfo sv_list[LOC_GPS_MAX_SVS]; + uint32_t ephemeris_mask; + uint32_t almanac_mask; + uint32_t used_in_fix_mask; +} LocGpsSvStatus; + +/** + * Represents SV status. + */ +typedef struct { + /** set to sizeof(LocGnssSvStatus) */ + size_t size; + + /** Number of GPS SVs currently visible, refers to the SVs stored in sv_list */ + int num_svs; + /** + * Pointer to an array of SVs information for all GNSS constellations, + * except GPS, which is reported using sv_list + */ + LocGnssSvInfo gnss_sv_list[LOC_GNSS_MAX_SVS]; + +} LocGnssSvStatus; + +/* CellID for 2G, 3G and LTE, used in AGPS. */ +typedef struct { + LocAGpsRefLocationType type; + /** Mobile Country Code. */ + uint16_t mcc; + /** Mobile Network Code .*/ + uint16_t mnc; + /** Location Area Code in 2G, 3G and LTE. In 3G lac is discarded. In LTE, + * lac is populated with tac, to ensure that we don't break old clients that + * might rely in the old (wrong) behavior. + */ + uint16_t lac; + /** Cell id in 2G. Utran Cell id in 3G. Cell Global Id EUTRA in LTE. */ + uint32_t cid; + /** Tracking Area Code in LTE. */ + uint16_t tac; + /** Physical Cell id in LTE (not used in 2G and 3G) */ + uint16_t pcid; +} LocAGpsRefLocationCellID; + +typedef struct { + uint8_t mac[6]; +} LocAGpsRefLocationMac; + +/** Represents ref locations */ +typedef struct { + LocAGpsRefLocationType type; + union { + LocAGpsRefLocationCellID cellID; + LocAGpsRefLocationMac mac; + } u; +} LocAGpsRefLocation; + +/** + * Callback with location information. Can only be called from a thread created + * by create_thread_cb. + */ +typedef void (* loc_gps_location_callback)(LocGpsLocation* location); + +/** + * Callback with status information. Can only be called from a thread created by + * create_thread_cb. + */ +typedef void (* loc_gps_status_callback)(LocGpsStatus* status); +/** + * Legacy callback with SV status information. + * Can only be called from a thread created by create_thread_cb. + * + * This callback is deprecated, and will be removed in the next release. Use + * loc_gnss_sv_status_callback() instead. + */ +typedef void (* loc_gps_sv_status_callback)(LocGpsSvStatus* sv_info); + +/** + * Callback with SV status information. + * Can only be called from a thread created by create_thread_cb. + */ +typedef void (* loc_gnss_sv_status_callback)(LocGnssSvStatus* sv_info); + +/** + * Callback for reporting NMEA sentences. Can only be called from a thread + * created by create_thread_cb. + */ +typedef void (* loc_gps_nmea_callback)(LocGpsUtcTime timestamp, const char* nmea, int length); + +/** + * Callback to inform framework of the GPS engine's capabilities. Capability + * parameter is a bit field of LOC_GPS_CAPABILITY_* flags. + */ +typedef void (* loc_gps_set_capabilities)(uint32_t capabilities); + +/** + * Callback utility for acquiring the GPS wakelock. This can be used to prevent + * the CPU from suspending while handling GPS events. + */ +typedef void (* loc_gps_acquire_wakelock)(); + +/** Callback utility for releasing the GPS wakelock. */ +typedef void (* loc_gps_release_wakelock)(); + +/** Callback for requesting NTP time */ +typedef void (* loc_gps_request_utc_time)(); + +/** + * Callback for creating a thread that can call into the Java framework code. + * This must be used to create any threads that report events up to the + * framework. + */ +typedef pthread_t (* loc_gps_create_thread)(const char* name, void (*start)(void *), void* arg); + +/** + * Provides information about how new the underlying GPS/GNSS hardware and + * software is. + * + * This information will be available for Android Test Applications. If a GPS + * HAL does not provide this information, it will be considered "2015 or + * earlier". + * + * If a GPS HAL does provide this information, then newer years will need to + * meet newer CTS standards. E.g. if the date are 2016 or above, then N+ level + * LocGpsMeasurement support will be verified. + */ +typedef struct { + /** Set to sizeof(LocGnssSystemInfo) */ + size_t size; + /* year in which the last update was made to the underlying hardware/firmware + * used to capture GNSS signals, e.g. 2016 */ + uint16_t year_of_hw; +} LocGnssSystemInfo; + +/** + * Callback to inform framework of the engine's hardware version information. + */ +typedef void (*loc_gnss_set_system_info)(const LocGnssSystemInfo* info); + +/** New GPS callback structure. */ +typedef struct { + /** set to sizeof(LocGpsCallbacks) */ + size_t size; + loc_gps_location_callback location_cb; + loc_gps_status_callback status_cb; + loc_gps_sv_status_callback sv_status_cb; + loc_gps_nmea_callback nmea_cb; + loc_gps_set_capabilities set_capabilities_cb; + loc_gps_acquire_wakelock acquire_wakelock_cb; + loc_gps_release_wakelock release_wakelock_cb; + loc_gps_create_thread create_thread_cb; + loc_gps_request_utc_time request_utc_time_cb; + + loc_gnss_set_system_info set_system_info_cb; + loc_gnss_sv_status_callback gnss_sv_status_cb; +} LocGpsCallbacks; + +/** Represents the standard GPS interface. */ +typedef struct { + /** set to sizeof(LocGpsInterface) */ + size_t size; + /** + * Opens the interface and provides the callback routines + * to the implementation of this interface. + */ + int (*init)( LocGpsCallbacks* callbacks ); + + /** Starts navigating. */ + int (*start)( void ); + + /** Stops navigating. */ + int (*stop)( void ); + + /** Closes the interface. */ + void (*cleanup)( void ); + + /** Injects the current time. */ + int (*inject_time)(LocGpsUtcTime time, int64_t timeReference, + int uncertainty); + + /** + * Injects current location from another location provider (typically cell + * ID). Latitude and longitude are measured in degrees expected accuracy is + * measured in meters + */ + int (*inject_location)(double latitude, double longitude, float accuracy); + + /** + * Specifies that the next call to start will not use the + * information defined in the flags. LOC_GPS_DELETE_ALL is passed for + * a cold start. + */ + void (*delete_aiding_data)(LocGpsAidingData flags); + + /** + * min_interval represents the time between fixes in milliseconds. + * preferred_accuracy represents the requested fix accuracy in meters. + * preferred_time represents the requested time to first fix in milliseconds. + * + * 'mode' parameter should be one of LOC_GPS_POSITION_MODE_MS_BASED + * or LOC_GPS_POSITION_MODE_STANDALONE. + * It is allowed by the platform (and it is recommended) to fallback to + * LOC_GPS_POSITION_MODE_MS_BASED if LOC_GPS_POSITION_MODE_MS_ASSISTED is passed in, and + * LOC_GPS_POSITION_MODE_MS_BASED is supported. + */ + int (*set_position_mode)(LocGpsPositionMode mode, LocGpsPositionRecurrence recurrence, + uint32_t min_interval, uint32_t preferred_accuracy, uint32_t preferred_time); + + /** Get a pointer to extension information. */ + const void* (*get_extension)(const char* name); +} LocGpsInterface; + +/** + * Callback to request the client to download XTRA data. The client should + * download XTRA data and inject it by calling inject_xtra_data(). Can only be + * called from a thread created by create_thread_cb. + */ +typedef void (* loc_gps_xtra_download_request)(); + +/** Callback structure for the XTRA interface. */ +typedef struct { + loc_gps_xtra_download_request download_request_cb; + loc_gps_create_thread create_thread_cb; +} LocGpsXtraCallbacks; + +/** Extended interface for XTRA support. */ +typedef struct { + /** set to sizeof(LocGpsXtraInterface) */ + size_t size; + /** + * Opens the XTRA interface and provides the callback routines + * to the implementation of this interface. + */ + int (*init)( LocGpsXtraCallbacks* callbacks ); + /** Injects XTRA data into the GPS. */ + int (*inject_xtra_data)( char* data, int length ); +} LocGpsXtraInterface; + +#if 0 +/** Extended interface for DEBUG support. */ +typedef struct { + /** set to sizeof(LocGpsDebugInterface) */ + size_t size; + + /** + * This function should return any information that the native + * implementation wishes to include in a bugreport. + */ + size_t (*get_internal_state)(char* buffer, size_t bufferSize); +} LocGpsDebugInterface; +#endif + +/* + * Represents the status of AGPS augmented to support IPv4 and IPv6. + */ +typedef struct { + /** set to sizeof(LocAGpsStatus) */ + size_t size; + + LocAGpsType type; + LocAGpsStatusValue status; + + /** + * Must be set to a valid IPv4 address if the field 'addr' contains an IPv4 + * address, or set to INADDR_NONE otherwise. + */ + uint32_t ipaddr; + + /** + * Must contain the IPv4 (AF_INET) or IPv6 (AF_INET6) address to report. + * Any other value of addr.ss_family will be rejected. + */ + struct sockaddr_storage addr; +} LocAGpsStatus; + +/** + * Callback with AGPS status information. Can only be called from a thread + * created by create_thread_cb. + */ +typedef void (* loc_agps_status_callback)(LocAGpsStatus* status); + +/** Callback structure for the AGPS interface. */ +typedef struct { + loc_agps_status_callback status_cb; + loc_gps_create_thread create_thread_cb; +} LocAGpsCallbacks; + +/** + * Extended interface for AGPS support, it is augmented to enable to pass + * extra APN data. + */ +typedef struct { + /** set to sizeof(LocAGpsInterface) */ + size_t size; + + /** + * Opens the AGPS interface and provides the callback routines to the + * implementation of this interface. + */ + void (*init)(LocAGpsCallbacks* callbacks); + /** + * Deprecated. + * If the HAL supports LocAGpsInterface_v2 this API will not be used, see + * data_conn_open_with_apn_ip_type for more information. + */ + int (*data_conn_open)(const char* apn); + /** + * Notifies that the AGPS data connection has been closed. + */ + int (*data_conn_closed)(); + /** + * Notifies that a data connection is not available for AGPS. + */ + int (*data_conn_failed)(); + /** + * Sets the hostname and port for the AGPS server. + */ + int (*set_server)(LocAGpsType type, const char* hostname, int port); + + /** + * Notifies that a data connection is available and sets the name of the + * APN, and its IP type, to be used for SUPL connections. + */ + int (*data_conn_open_with_apn_ip_type)( + const char* apn, + LocApnIpType apnIpType); +} LocAGpsInterface; + +/** Error codes associated with certificate operations */ +#define LOC_AGPS_CERTIFICATE_OPERATION_SUCCESS 0 +#define LOC_AGPS_CERTIFICATE_ERROR_GENERIC -100 +#define LOC_AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES -101 + +/** A data structure that represents an X.509 certificate using DER encoding */ +typedef struct { + size_t length; + u_char* data; +} LocDerEncodedCertificate; + +/** + * A type definition for SHA1 Fingerprints used to identify X.509 Certificates + * The Fingerprint is a digest of the DER Certificate that uniquely identifies it. + */ +typedef struct { + u_char data[20]; +} LocSha1CertificateFingerprint; + +/** AGPS Interface to handle SUPL certificate operations */ +typedef struct { + /** set to sizeof(LocSuplCertificateInterface) */ + size_t size; + + /** + * Installs a set of Certificates used for SUPL connections to the AGPS server. + * If needed the HAL should find out internally any certificates that need to be removed to + * accommodate the certificates to install. + * The certificates installed represent a full set of valid certificates needed to connect to + * AGPS SUPL servers. + * The list of certificates is required, and all must be available at the same time, when trying + * to establish a connection with the AGPS Server. + * + * Parameters: + * certificates - A pointer to an array of DER encoded certificates that are need to be + * installed in the HAL. + * length - The number of certificates to install. + * Returns: + * LOC_AGPS_CERTIFICATE_OPERATION_SUCCESS if the operation is completed successfully + * LOC_AGPS_CERTIFICATE_ERROR_TOO_MANY_CERTIFICATES if the HAL cannot store the number of + * certificates attempted to be installed, the state of the certificates stored should + * remain the same as before on this error case. + * + * IMPORTANT: + * If needed the HAL should find out internally the set of certificates that need to be + * removed to accommodate the certificates to install. + */ + int (*install_certificates) ( const LocDerEncodedCertificate* certificates, size_t length ); + + /** + * Notifies the HAL that a list of certificates used for SUPL connections are revoked. It is + * expected that the given set of certificates is removed from the internal store of the HAL. + * + * Parameters: + * fingerprints - A pointer to an array of SHA1 Fingerprints to identify the set of + * certificates to revoke. + * length - The number of fingerprints provided. + * Returns: + * LOC_AGPS_CERTIFICATE_OPERATION_SUCCESS if the operation is completed successfully. + * + * IMPORTANT: + * If any of the certificates provided (through its fingerprint) is not known by the HAL, + * it should be ignored and continue revoking/deleting the rest of them. + */ + int (*revoke_certificates) ( const LocSha1CertificateFingerprint* fingerprints, size_t length ); +} LocSuplCertificateInterface; + +/** Represents an NI request */ +typedef struct { + /** set to sizeof(LocGpsNiNotification) */ + size_t size; + + /** + * An ID generated by HAL to associate NI notifications and UI + * responses + */ + int notification_id; + + /** + * An NI type used to distinguish different categories of NI + * events, such as LOC_GPS_NI_TYPE_VOICE, LOC_GPS_NI_TYPE_UMTS_SUPL, ... + */ + LocGpsNiType ni_type; + + /** + * Notification/verification options, combinations of LocGpsNiNotifyFlags constants + */ + LocGpsNiNotifyFlags notify_flags; + + /** + * Timeout period to wait for user response. + * Set to 0 for no time out limit. + */ + int timeout; + + /** + * Default response when time out. + */ + LocGpsUserResponseType default_response; + + /** + * Requestor ID + */ + char requestor_id[LOC_GPS_NI_SHORT_STRING_MAXLEN]; + + /** + * Notification message. It can also be used to store client_id in some cases + */ + char text[LOC_GPS_NI_LONG_STRING_MAXLEN]; + + /** + * Client name decoding scheme + */ + LocGpsNiEncodingType requestor_id_encoding; + + /** + * Client name decoding scheme + */ + LocGpsNiEncodingType text_encoding; + + /** + * A pointer to extra data. Format: + * key_1 = value_1 + * key_2 = value_2 + */ + char extras[LOC_GPS_NI_LONG_STRING_MAXLEN]; + +} LocGpsNiNotification; + +/** + * Callback with NI notification. Can only be called from a thread created by + * create_thread_cb. + */ +typedef void (*loc_gps_ni_notify_callback)(LocGpsNiNotification *notification); + +/** GPS NI callback structure. */ +typedef struct +{ + /** + * Sends the notification request from HAL to GPSLocationProvider. + */ + loc_gps_ni_notify_callback notify_cb; + loc_gps_create_thread create_thread_cb; +} LocGpsNiCallbacks; + +/** + * Extended interface for Network-initiated (NI) support. + */ +typedef struct +{ + /** set to sizeof(LocGpsNiInterface) */ + size_t size; + + /** Registers the callbacks for HAL to use. */ + void (*init) (LocGpsNiCallbacks *callbacks); + + /** Sends a response to HAL. */ + void (*respond) (int notif_id, LocGpsUserResponseType user_response); +} LocGpsNiInterface; + +#define LOC_AGPS_RIL_REQUEST_SETID_IMSI (1<<0L) +#define LOC_AGPS_RIL_REQUEST_SETID_MSISDN (1<<1L) + +#define LOC_AGPS_RIL_REQUEST_REFLOC_CELLID (1<<0L) +#define LOC_AGPS_RIL_REQUEST_REFLOC_MAC (1<<1L) + +typedef void (*loc_agps_ril_request_set_id)(uint32_t flags); +typedef void (*loc_agps_ril_request_ref_loc)(uint32_t flags); + +typedef struct { + loc_agps_ril_request_set_id request_setid; + loc_agps_ril_request_ref_loc request_refloc; + loc_gps_create_thread create_thread_cb; +} LocAGpsRilCallbacks; + +/** Extended interface for AGPS_RIL support. */ +typedef struct { + /** set to sizeof(LocAGpsRilInterface) */ + size_t size; + /** + * Opens the AGPS interface and provides the callback routines + * to the implementation of this interface. + */ + void (*init)( LocAGpsRilCallbacks* callbacks ); + + /** + * Sets the reference location. + */ + void (*set_ref_location) (const LocAGpsRefLocation *agps_reflocation, size_t sz_struct); + /** + * Sets the set ID. + */ + void (*set_set_id) (LocAGpsSetIDType type, const char* setid); + + /** + * Send network initiated message. + */ + void (*ni_message) (uint8_t *msg, size_t len); + + /** + * Notify GPS of network status changes. + * These parameters match values in the android.net.NetworkInfo class. + */ + void (*update_network_state) (int connected, int type, int roaming, const char* extra_info); + + /** + * Notify GPS of network status changes. + * These parameters match values in the android.net.NetworkInfo class. + */ + void (*update_network_availability) (int avaiable, const char* apn); +} LocAGpsRilInterface; + +/** + * GPS Geofence. + * There are 3 states associated with a Geofence: Inside, Outside, Unknown. + * There are 3 transitions: ENTERED, EXITED, UNCERTAIN. + * + * An example state diagram with confidence level: 95% and Unknown time limit + * set as 30 secs is shown below. (confidence level and Unknown time limit are + * explained latter) + * ____________________________ + * | Unknown (30 secs) | + * """""""""""""""""""""""""""" + * ^ | | ^ + * UNCERTAIN| |ENTERED EXITED| |UNCERTAIN + * | v v | + * ________ EXITED _________ + * | Inside | -----------> | Outside | + * | | <----------- | | + * """""""" ENTERED """"""""" + * + * Inside state: We are 95% confident that the user is inside the geofence. + * Outside state: We are 95% confident that the user is outside the geofence + * Unknown state: Rest of the time. + * + * The Unknown state is better explained with an example: + * + * __________ + * | c| + * | ___ | _______ + * | |a| | | b | + * | """ | """"""" + * | | + * """""""""" + * In the diagram above, "a" and "b" are 2 geofences and "c" is the accuracy + * circle reported by the GPS subsystem. Now with regard to "b", the system is + * confident that the user is outside. But with regard to "a" is not confident + * whether it is inside or outside the geofence. If the accuracy remains the + * same for a sufficient period of time, the UNCERTAIN transition would be + * triggered with the state set to Unknown. If the accuracy improves later, an + * appropriate transition should be triggered. This "sufficient period of time" + * is defined by the parameter in the add_geofence_area API. + * In other words, Unknown state can be interpreted as a state in which the + * GPS subsystem isn't confident enough that the user is either inside or + * outside the Geofence. It moves to Unknown state only after the expiry of the + * timeout. + * + * The geofence callback needs to be triggered for the ENTERED and EXITED + * transitions, when the GPS system is confident that the user has entered + * (Inside state) or exited (Outside state) the Geofence. An implementation + * which uses a value of 95% as the confidence is recommended. The callback + * should be triggered only for the transitions requested by the + * add_geofence_area call. + * + * Even though the diagram and explanation talks about states and transitions, + * the callee is only interested in the transistions. The states are mentioned + * here for illustrative purposes. + * + * Startup Scenario: When the device boots up, if an application adds geofences, + * and then we get an accurate GPS location fix, it needs to trigger the + * appropriate (ENTERED or EXITED) transition for every Geofence it knows about. + * By default, all the Geofences will be in the Unknown state. + * + * When the GPS system is unavailable, loc_gps_geofence_status_callback should be + * called to inform the upper layers of the same. Similarly, when it becomes + * available the callback should be called. This is a global state while the + * UNKNOWN transition described above is per geofence. + * + * An important aspect to note is that users of this API (framework), will use + * other subsystems like wifi, sensors, cell to handle Unknown case and + * hopefully provide a definitive state transition to the third party + * application. GPS Geofence will just be a signal indicating what the GPS + * subsystem knows about the Geofence. + * + */ +#define LOC_GPS_GEOFENCE_ENTERED (1<<0L) +#define LOC_GPS_GEOFENCE_EXITED (1<<1L) +#define LOC_GPS_GEOFENCE_UNCERTAIN (1<<2L) + +#define LOC_GPS_GEOFENCE_UNAVAILABLE (1<<0L) +#define LOC_GPS_GEOFENCE_AVAILABLE (1<<1L) + +#define LOC_GPS_GEOFENCE_OPERATION_SUCCESS 0 +#define LOC_GPS_GEOFENCE_ERROR_TOO_MANY_GEOFENCES -100 +#define LOC_GPS_GEOFENCE_ERROR_ID_EXISTS -101 +#define LOC_GPS_GEOFENCE_ERROR_ID_UNKNOWN -102 +#define LOC_GPS_GEOFENCE_ERROR_INVALID_TRANSITION -103 +#define LOC_GPS_GEOFENCE_ERROR_GENERIC -149 + +/** + * The callback associated with the geofence. + * Parameters: + * geofence_id - The id associated with the add_geofence_area. + * location - The current GPS location. + * transition - Can be one of LOC_GPS_GEOFENCE_ENTERED, LOC_GPS_GEOFENCE_EXITED, + * LOC_GPS_GEOFENCE_UNCERTAIN. + * timestamp - Timestamp when the transition was detected. + * + * The callback should only be called when the caller is interested in that + * particular transition. For instance, if the caller is interested only in + * ENTERED transition, then the callback should NOT be called with the EXITED + * transition. + * + * IMPORTANT: If a transition is triggered resulting in this callback, the GPS + * subsystem will wake up the application processor, if its in suspend state. + */ +typedef void (*loc_gps_geofence_transition_callback) (int32_t geofence_id, LocGpsLocation* location, + int32_t transition, LocGpsUtcTime timestamp); + +/** + * The callback associated with the availability of the GPS system for geofencing + * monitoring. If the GPS system determines that it cannot monitor geofences + * because of lack of reliability or unavailability of the GPS signals, it will + * call this callback with LOC_GPS_GEOFENCE_UNAVAILABLE parameter. + * + * Parameters: + * status - LOC_GPS_GEOFENCE_UNAVAILABLE or LOC_GPS_GEOFENCE_AVAILABLE. + * last_location - Last known location. + */ +typedef void (*loc_gps_geofence_status_callback) (int32_t status, LocGpsLocation* last_location); + +/** + * The callback associated with the add_geofence call. + * + * Parameter: + * geofence_id - Id of the geofence. + * status - LOC_GPS_GEOFENCE_OPERATION_SUCCESS + * LOC_GPS_GEOFENCE_ERROR_TOO_MANY_GEOFENCES - geofence limit has been reached. + * LOC_GPS_GEOFENCE_ERROR_ID_EXISTS - geofence with id already exists + * LOC_GPS_GEOFENCE_ERROR_INVALID_TRANSITION - the monitorTransition contains an + * invalid transition + * LOC_GPS_GEOFENCE_ERROR_GENERIC - for other errors. + */ +typedef void (*loc_gps_geofence_add_callback) (int32_t geofence_id, int32_t status); + +/** + * The callback associated with the remove_geofence call. + * + * Parameter: + * geofence_id - Id of the geofence. + * status - LOC_GPS_GEOFENCE_OPERATION_SUCCESS + * LOC_GPS_GEOFENCE_ERROR_ID_UNKNOWN - for invalid id + * LOC_GPS_GEOFENCE_ERROR_GENERIC for others. + */ +typedef void (*loc_gps_geofence_remove_callback) (int32_t geofence_id, int32_t status); + + +/** + * The callback associated with the pause_geofence call. + * + * Parameter: + * geofence_id - Id of the geofence. + * status - LOC_GPS_GEOFENCE_OPERATION_SUCCESS + * LOC_GPS_GEOFENCE_ERROR_ID_UNKNOWN - for invalid id + * LOC_GPS_GEOFENCE_ERROR_INVALID_TRANSITION - + * when monitor_transitions is invalid + * LOC_GPS_GEOFENCE_ERROR_GENERIC for others. + */ +typedef void (*loc_gps_geofence_pause_callback) (int32_t geofence_id, int32_t status); + +/** + * The callback associated with the resume_geofence call. + * + * Parameter: + * geofence_id - Id of the geofence. + * status - LOC_GPS_GEOFENCE_OPERATION_SUCCESS + * LOC_GPS_GEOFENCE_ERROR_ID_UNKNOWN - for invalid id + * LOC_GPS_GEOFENCE_ERROR_GENERIC for others. + */ +typedef void (*loc_gps_geofence_resume_callback) (int32_t geofence_id, int32_t status); + +typedef struct { + loc_gps_geofence_transition_callback geofence_transition_callback; + loc_gps_geofence_status_callback geofence_status_callback; + loc_gps_geofence_add_callback geofence_add_callback; + loc_gps_geofence_remove_callback geofence_remove_callback; + loc_gps_geofence_pause_callback geofence_pause_callback; + loc_gps_geofence_resume_callback geofence_resume_callback; + loc_gps_create_thread create_thread_cb; +} LocGpsGeofenceCallbacks; + +/** Extended interface for GPS_Geofencing support */ +typedef struct { + /** set to sizeof(LocGpsGeofencingInterface) */ + size_t size; + + /** + * Opens the geofence interface and provides the callback routines + * to the implementation of this interface. + */ + void (*init)( LocGpsGeofenceCallbacks* callbacks ); + + /** + * Add a geofence area. This api currently supports circular geofences. + * Parameters: + * geofence_id - The id for the geofence. If a geofence with this id + * already exists, an error value (LOC_GPS_GEOFENCE_ERROR_ID_EXISTS) + * should be returned. + * latitude, longtitude, radius_meters - The lat, long and radius + * (in meters) for the geofence + * last_transition - The current state of the geofence. For example, if + * the system already knows that the user is inside the geofence, + * this will be set to LOC_GPS_GEOFENCE_ENTERED. In most cases, it + * will be LOC_GPS_GEOFENCE_UNCERTAIN. + * monitor_transition - Which transitions to monitor. Bitwise OR of + * LOC_GPS_GEOFENCE_ENTERED, LOC_GPS_GEOFENCE_EXITED and + * LOC_GPS_GEOFENCE_UNCERTAIN. + * notification_responsiveness_ms - Defines the best-effort description + * of how soon should the callback be called when the transition + * associated with the Geofence is triggered. For instance, if set + * to 1000 millseconds with LOC_GPS_GEOFENCE_ENTERED, the callback + * should be called 1000 milliseconds within entering the geofence. + * This parameter is defined in milliseconds. + * NOTE: This is not to be confused with the rate that the GPS is + * polled at. It is acceptable to dynamically vary the rate of + * sampling the GPS for power-saving reasons; thus the rate of + * sampling may be faster or slower than this. + * unknown_timer_ms - The time limit after which the UNCERTAIN transition + * should be triggered. This parameter is defined in milliseconds. + * See above for a detailed explanation. + */ + void (*add_geofence_area) (int32_t geofence_id, double latitude, double longitude, + double radius_meters, int last_transition, int monitor_transitions, + int notification_responsiveness_ms, int unknown_timer_ms); + + /** + * Pause monitoring a particular geofence. + * Parameters: + * geofence_id - The id for the geofence. + */ + void (*pause_geofence) (int32_t geofence_id); + + /** + * Resume monitoring a particular geofence. + * Parameters: + * geofence_id - The id for the geofence. + * monitor_transitions - Which transitions to monitor. Bitwise OR of + * LOC_GPS_GEOFENCE_ENTERED, LOC_GPS_GEOFENCE_EXITED and + * LOC_GPS_GEOFENCE_UNCERTAIN. + * This supersedes the value associated provided in the + * add_geofence_area call. + */ + void (*resume_geofence) (int32_t geofence_id, int monitor_transitions); + + /** + * Remove a geofence area. After the function returns, no notifications + * should be sent. + * Parameter: + * geofence_id - The id for the geofence. + */ + void (*remove_geofence_area) (int32_t geofence_id); +} LocGpsGeofencingInterface; + +/** + * Legacy struct to represent an estimate of the GPS clock time. + * Deprecated, to be removed in the next Android release. + * Use LocGnssClock instead. + */ +typedef struct { + /** set to sizeof(LocGpsClock) */ + size_t size; + LocGpsClockFlags flags; + int16_t leap_second; + LocGpsClockType type; + int64_t time_ns; + double time_uncertainty_ns; + int64_t full_bias_ns; + double bias_ns; + double bias_uncertainty_ns; + double drift_nsps; + double drift_uncertainty_nsps; +} LocGpsClock; + +/** + * Represents an estimate of the GPS clock time. + */ +typedef struct { + /** set to sizeof(LocGnssClock) */ + size_t size; + + /** + * A set of flags indicating the validity of the fields in this data + * structure. + */ + LocGnssClockFlags flags; + + /** + * Leap second data. + * The sign of the value is defined by the following equation: + * utc_time_ns = time_ns - (full_bias_ns + bias_ns) - leap_second * + * 1,000,000,000 + * + * If the data is available 'flags' must contain LOC_GNSS_CLOCK_HAS_LEAP_SECOND. + */ + int16_t leap_second; + + /** + * The GNSS receiver internal clock value. This is the local hardware clock + * value. + * + * For local hardware clock, this value is expected to be monotonically + * increasing while the hardware clock remains power on. (For the case of a + * HW clock that is not continuously on, see the + * hw_clock_discontinuity_count field). The receiver's estimate of GPS time + * can be derived by substracting the sum of full_bias_ns and bias_ns (when + * available) from this value. + * + * This GPS time is expected to be the best estimate of current GPS time + * that GNSS receiver can achieve. + * + * Sub-nanosecond accuracy can be provided by means of the 'bias_ns' field. + * The value contains the 'time uncertainty' in it. + * + * This field is mandatory. + */ + int64_t time_ns; + + /** + * 1-Sigma uncertainty associated with the clock's time in nanoseconds. + * The uncertainty is represented as an absolute (single sided) value. + * + * If the data is available, 'flags' must contain + * LOC_GNSS_CLOCK_HAS_TIME_UNCERTAINTY. This value is effectively zero (it is + * the reference local clock, by which all other times and time + * uncertainties are measured.) (And thus this field can be not provided, + * per LOC_GNSS_CLOCK_HAS_TIME_UNCERTAINTY flag, or provided & set to 0.) + */ + double time_uncertainty_ns; + + /** + * The difference between hardware clock ('time' field) inside GPS receiver + * and the true GPS time since 0000Z, January 6, 1980, in nanoseconds. + * + * The sign of the value is defined by the following equation: + * local estimate of GPS time = time_ns - (full_bias_ns + bias_ns) + * + * This value is mandatory if the receiver has estimated GPS time. If the + * computed time is for a non-GPS constellation, the time offset of that + * constellation to GPS has to be applied to fill this value. The error + * estimate for the sum of this and the bias_ns is the bias_uncertainty_ns, + * and the caller is responsible for using this uncertainty (it can be very + * large before the GPS time has been solved for.) If the data is available + * 'flags' must contain LOC_GNSS_CLOCK_HAS_FULL_BIAS. + */ + int64_t full_bias_ns; + + /** + * Sub-nanosecond bias. + * The error estimate for the sum of this and the full_bias_ns is the + * bias_uncertainty_ns + * + * If the data is available 'flags' must contain LOC_GNSS_CLOCK_HAS_BIAS. If GPS + * has computed a position fix. This value is mandatory if the receiver has + * estimated GPS time. + */ + double bias_ns; + + /** + * 1-Sigma uncertainty associated with the local estimate of GPS time (clock + * bias) in nanoseconds. The uncertainty is represented as an absolute + * (single sided) value. + * + * If the data is available 'flags' must contain + * LOC_GNSS_CLOCK_HAS_BIAS_UNCERTAINTY. This value is mandatory if the receiver + * has estimated GPS time. + */ + double bias_uncertainty_ns; + + /** + * The clock's drift in nanoseconds (per second). + * + * A positive value means that the frequency is higher than the nominal + * frequency, and that the (full_bias_ns + bias_ns) is growing more positive + * over time. + * + * The value contains the 'drift uncertainty' in it. + * If the data is available 'flags' must contain LOC_GNSS_CLOCK_HAS_DRIFT. + * + * This value is mandatory if the receiver has estimated GNSS time + */ + double drift_nsps; + + /** + * 1-Sigma uncertainty associated with the clock's drift in nanoseconds (per second). + * The uncertainty is represented as an absolute (single sided) value. + * + * If the data is available 'flags' must contain + * LOC_GNSS_CLOCK_HAS_DRIFT_UNCERTAINTY. If GPS has computed a position fix this + * field is mandatory and must be populated. + */ + double drift_uncertainty_nsps; + + /** + * When there are any discontinuities in the HW clock, this field is + * mandatory. + * + * A "discontinuity" is meant to cover the case of a switch from one source + * of clock to another. A single free-running crystal oscillator (XO) + * should generally not have any discontinuities, and this can be set and + * left at 0. + * + * If, however, the time_ns value (HW clock) is derived from a composite of + * sources, that is not as smooth as a typical XO, or is otherwise stopped & + * restarted, then this value shall be incremented each time a discontinuity + * occurs. (E.g. this value may start at zero at device boot-up and + * increment each time there is a change in clock continuity. In the + * unlikely event that this value reaches full scale, rollover (not + * clamping) is required, such that this value continues to change, during + * subsequent discontinuity events.) + * + * While this number stays the same, between LocGnssClock reports, it can be + * safely assumed that the time_ns value has been running continuously, e.g. + * derived from a single, high quality clock (XO like, or better, that's + * typically used during continuous GNSS signal sampling.) + * + * It is expected, esp. during periods where there are few GNSS signals + * available, that the HW clock be discontinuity-free as long as possible, + * as this avoids the need to use (waste) a GNSS measurement to fully + * re-solve for the GPS clock bias and drift, when using the accompanying + * measurements, from consecutive LocGnssData reports. + */ + uint32_t hw_clock_discontinuity_count; + +} LocGnssClock; + +/** + * Legacy struct to represent a GPS Measurement, it contains raw and computed + * information. + * Deprecated, to be removed in the next Android release. + * Use LocGnssMeasurement instead. + */ +typedef struct { + /** set to sizeof(LocGpsMeasurement) */ + size_t size; + LocGpsMeasurementFlags flags; + int8_t prn; + double time_offset_ns; + LocGpsMeasurementState state; + int64_t received_gps_tow_ns; + int64_t received_gps_tow_uncertainty_ns; + double c_n0_dbhz; + double pseudorange_rate_mps; + double pseudorange_rate_uncertainty_mps; + LocGpsAccumulatedDeltaRangeState accumulated_delta_range_state; + double accumulated_delta_range_m; + double accumulated_delta_range_uncertainty_m; + double pseudorange_m; + double pseudorange_uncertainty_m; + double code_phase_chips; + double code_phase_uncertainty_chips; + float carrier_frequency_hz; + int64_t carrier_cycles; + double carrier_phase; + double carrier_phase_uncertainty; + LocGpsLossOfLock loss_of_lock; + int32_t bit_number; + int16_t time_from_last_bit_ms; + double doppler_shift_hz; + double doppler_shift_uncertainty_hz; + LocGpsMultipathIndicator multipath_indicator; + double snr_db; + double elevation_deg; + double elevation_uncertainty_deg; + double azimuth_deg; + double azimuth_uncertainty_deg; + bool used_in_fix; +} LocGpsMeasurement; + +/** + * Represents a GNSS Measurement, it contains raw and computed information. + * + * Independence - All signal measurement information (e.g. sv_time, + * pseudorange_rate, multipath_indicator) reported in this struct should be + * based on GNSS signal measurements only. You may not synthesize measurements + * by calculating or reporting expected measurements based on known or estimated + * position, velocity, or time. + */ +typedef struct { + /** set to sizeof(LocGnssMeasurement) */ + size_t size; + + /** A set of flags indicating the validity of the fields in this data structure. */ + LocGnssMeasurementFlags flags; + + /** + * Satellite vehicle ID number, as defined in LocGnssSvInfo::svid + * This is a mandatory value. + */ + int16_t svid; + + /** + * Defines the constellation of the given SV. Value should be one of those + * LOC_GNSS_CONSTELLATION_* constants + */ + LocGnssConstellationType constellation; + + /** + * Time offset at which the measurement was taken in nanoseconds. + * The reference receiver's time is specified by LocGpsData::clock::time_ns and should be + * interpreted in the same way as indicated by LocGpsClock::type. + * + * The sign of time_offset_ns is given by the following equation: + * measurement time = LocGpsClock::time_ns + time_offset_ns + * + * It provides an individual time-stamp for the measurement, and allows sub-nanosecond accuracy. + * This is a mandatory value. + */ + double time_offset_ns; + + /** + * Per satellite sync state. It represents the current sync state for the associated satellite. + * Based on the sync state, the 'received GPS tow' field should be interpreted accordingly. + * + * This is a mandatory value. + */ + LocGnssMeasurementState state; + + /** + * The received GNSS Time-of-Week at the measurement time, in nanoseconds. + * Ensure that this field is independent (see comment at top of + * LocGnssMeasurement struct.) + * + * For GPS & QZSS, this is: + * Received GPS Time-of-Week at the measurement time, in nanoseconds. + * The value is relative to the beginning of the current GPS week. + * + * Given the highest sync state that can be achieved, per each satellite, valid range + * for this field can be: + * Searching : [ 0 ] : LOC_GNSS_MEASUREMENT_STATE_UNKNOWN + * C/A code lock : [ 0 1ms ] : LOC_GNSS_MEASUREMENT_STATE_CODE_LOCK is set + * Bit sync : [ 0 20ms ] : LOC_GNSS_MEASUREMENT_STATE_BIT_SYNC is set + * Subframe sync : [ 0 6s ] : LOC_GNSS_MEASUREMENT_STATE_SUBFRAME_SYNC is set + * TOW decoded : [ 0 1week ] : LOC_GNSS_MEASUREMENT_STATE_TOW_DECODED is set + * + * Note well: if there is any ambiguity in integer millisecond, + * LOC_GNSS_MEASUREMENT_STATE_MSEC_AMBIGUOUS should be set accordingly, in the 'state' field. + * + * This value must be populated if 'state' != LOC_GNSS_MEASUREMENT_STATE_UNKNOWN. + * + * For Glonass, this is: + * Received Glonass time of day, at the measurement time in nanoseconds. + * + * Given the highest sync state that can be achieved, per each satellite, valid range for + * this field can be: + * Searching : [ 0 ] : LOC_GNSS_MEASUREMENT_STATE_UNKNOWN + * C/A code lock : [ 0 1ms ] : LOC_GNSS_MEASUREMENT_STATE_CODE_LOCK is set + * Symbol sync : [ 0 10ms ] : LOC_GNSS_MEASUREMENT_STATE_SYMBOL_SYNC is set + * Bit sync : [ 0 20ms ] : LOC_GNSS_MEASUREMENT_STATE_BIT_SYNC is set + * String sync : [ 0 2s ] : LOC_GNSS_MEASUREMENT_STATE_GLO_STRING_SYNC is set + * Time of day : [ 0 1day ] : LOC_GNSS_MEASUREMENT_STATE_GLO_TOD_DECODED is set + * + * For Beidou, this is: + * Received Beidou time of week, at the measurement time in nanoseconds. + * + * Given the highest sync state that can be achieved, per each satellite, valid range for + * this field can be: + * Searching : [ 0 ] : LOC_GNSS_MEASUREMENT_STATE_UNKNOWN + * C/A code lock: [ 0 1ms ] : LOC_GNSS_MEASUREMENT_STATE_CODE_LOCK is set + * Bit sync (D2): [ 0 2ms ] : LOC_GNSS_MEASUREMENT_STATE_BDS_D2_BIT_SYNC is set + * Bit sync (D1): [ 0 20ms ] : LOC_GNSS_MEASUREMENT_STATE_BIT_SYNC is set + * Subframe (D2): [ 0 0.6s ] : LOC_GNSS_MEASUREMENT_STATE_BDS_D2_SUBFRAME_SYNC is set + * Subframe (D1): [ 0 6s ] : LOC_GNSS_MEASUREMENT_STATE_SUBFRAME_SYNC is set + * Time of week : [ 0 1week ] : LOC_GNSS_MEASUREMENT_STATE_TOW_DECODED is set + * + * For Galileo, this is: + * Received Galileo time of week, at the measurement time in nanoseconds. + * + * E1BC code lock : [ 0 4ms ] : LOC_GNSS_MEASUREMENT_STATE_GAL_E1BC_CODE_LOCK is set + * E1C 2nd code lock: [ 0 100ms ] : + * LOC_GNSS_MEASUREMENT_STATE_GAL_E1C_2ND_CODE_LOCK is set + * + * E1B page : [ 0 2s ] : LOC_GNSS_MEASUREMENT_STATE_GAL_E1B_PAGE_SYNC is set + * Time of week: [ 0 1week ] : LOC_GNSS_MEASUREMENT_STATE_TOW_DECODED is set + * + * For SBAS, this is: + * Received SBAS time, at the measurement time in nanoseconds. + * + * Given the highest sync state that can be achieved, per each satellite, + * valid range for this field can be: + * Searching : [ 0 ] : LOC_GNSS_MEASUREMENT_STATE_UNKNOWN + * C/A code lock: [ 0 1ms ] : LOC_GNSS_MEASUREMENT_STATE_CODE_LOCK is set + * Symbol sync : [ 0 2ms ] : LOC_GNSS_MEASUREMENT_STATE_SYMBOL_SYNC is set + * Message : [ 0 1s ] : LOC_GNSS_MEASUREMENT_STATE_SBAS_SYNC is set + */ + int64_t received_sv_time_in_ns; + + /** + * 1-Sigma uncertainty of the Received GPS Time-of-Week in nanoseconds. + * + * This value must be populated if 'state' != LOC_GPS_MEASUREMENT_STATE_UNKNOWN. + */ + int64_t received_sv_time_uncertainty_in_ns; + + /** + * Carrier-to-noise density in dB-Hz, typically in the range [0, 63]. + * It contains the measured C/N0 value for the signal at the antenna port. + * + * This is a mandatory value. + */ + double c_n0_dbhz; + + /** + * Pseudorange rate at the timestamp in m/s. The correction of a given + * Pseudorange Rate value includes corrections for receiver and satellite + * clock frequency errors. Ensure that this field is independent (see + * comment at top of LocGnssMeasurement struct.) + * + * It is mandatory to provide the 'uncorrected' 'pseudorange rate', and provide LocGpsClock's + * 'drift' field as well (When providing the uncorrected pseudorange rate, do not apply the + * corrections described above.) + * + * The value includes the 'pseudorange rate uncertainty' in it. + * A positive 'uncorrected' value indicates that the SV is moving away from the receiver. + * + * The sign of the 'uncorrected' 'pseudorange rate' and its relation to the sign of 'doppler + * shift' is given by the equation: + * pseudorange rate = -k * doppler shift (where k is a constant) + * + * This should be the most accurate pseudorange rate available, based on + * fresh signal measurements from this channel. + * + * It is mandatory that this value be provided at typical carrier phase PRR + * quality (few cm/sec per second of uncertainty, or better) - when signals + * are sufficiently strong & stable, e.g. signals from a GPS simulator at >= + * 35 dB-Hz. + */ + double pseudorange_rate_mps; + + /** + * 1-Sigma uncertainty of the pseudorange_rate_mps. + * The uncertainty is represented as an absolute (single sided) value. + * + * This is a mandatory value. + */ + double pseudorange_rate_uncertainty_mps; + + /** + * Accumulated delta range's state. It indicates whether ADR is reset or there is a cycle slip + * (indicating loss of lock). + * + * This is a mandatory value. + */ + LocGnssAccumulatedDeltaRangeState accumulated_delta_range_state; + + /** + * Accumulated delta range since the last channel reset in meters. + * A positive value indicates that the SV is moving away from the receiver. + * + * The sign of the 'accumulated delta range' and its relation to the sign of 'carrier phase' + * is given by the equation: + * accumulated delta range = -k * carrier phase (where k is a constant) + * + * This value must be populated if 'accumulated delta range state' != LOC_GPS_ADR_STATE_UNKNOWN. + * However, it is expected that the data is only accurate when: + * 'accumulated delta range state' == LOC_GPS_ADR_STATE_VALID. + */ + double accumulated_delta_range_m; + + /** + * 1-Sigma uncertainty of the accumulated delta range in meters. + * This value must be populated if 'accumulated delta range state' != LOC_GPS_ADR_STATE_UNKNOWN. + */ + double accumulated_delta_range_uncertainty_m; + + /** + * Carrier frequency at which codes and messages are modulated, it can be L1 or L2. + * If the field is not set, the carrier frequency is assumed to be L1. + * + * If the data is available, 'flags' must contain + * LOC_GNSS_MEASUREMENT_HAS_CARRIER_FREQUENCY. + */ + float carrier_frequency_hz; + + /** + * The number of full carrier cycles between the satellite and the receiver. + * The reference frequency is given by the field 'carrier_frequency_hz'. + * Indications of possible cycle slips and resets in the accumulation of + * this value can be inferred from the accumulated_delta_range_state flags. + * + * If the data is available, 'flags' must contain + * LOC_GNSS_MEASUREMENT_HAS_CARRIER_CYCLES. + */ + int64_t carrier_cycles; + + /** + * The RF phase detected by the receiver, in the range [0.0, 1.0]. + * This is usually the fractional part of the complete carrier phase measurement. + * + * The reference frequency is given by the field 'carrier_frequency_hz'. + * The value contains the 'carrier-phase uncertainty' in it. + * + * If the data is available, 'flags' must contain + * LOC_GNSS_MEASUREMENT_HAS_CARRIER_PHASE. + */ + double carrier_phase; + + /** + * 1-Sigma uncertainty of the carrier-phase. + * If the data is available, 'flags' must contain + * LOC_GNSS_MEASUREMENT_HAS_CARRIER_PHASE_UNCERTAINTY. + */ + double carrier_phase_uncertainty; + + /** + * An enumeration that indicates the 'multipath' state of the event. + * + * The multipath Indicator is intended to report the presence of overlapping + * signals that manifest as distorted correlation peaks. + * + * - if there is a distorted correlation peak shape, report that multipath + * is LOC_GNSS_MULTIPATH_INDICATOR_PRESENT. + * - if there is not a distorted correlation peak shape, report + * LOC_GNSS_MULTIPATH_INDICATOR_NOT_PRESENT + * - if signals are too weak to discern this information, report + * LOC_GNSS_MULTIPATH_INDICATOR_UNKNOWN + * + * Example: when doing the standardized overlapping Multipath Performance + * test (3GPP TS 34.171) the Multipath indicator should report + * LOC_GNSS_MULTIPATH_INDICATOR_PRESENT for those signals that are tracked, and + * contain multipath, and LOC_GNSS_MULTIPATH_INDICATOR_NOT_PRESENT for those + * signals that are tracked and do not contain multipath. + */ + LocGnssMultipathIndicator multipath_indicator; + + /** + * Signal-to-noise ratio at correlator output in dB. + * If the data is available, 'flags' must contain LOC_GNSS_MEASUREMENT_HAS_SNR. + * This is the power ratio of the "correlation peak height above the + * observed noise floor" to "the noise RMS". + */ + double snr_db; +} LocGnssMeasurement; + +/** + * Legacy struct to represents a reading of GPS measurements. + * Deprecated, to be removed in the next Android release. + * Use LocGnssData instead. + */ +typedef struct { + /** set to sizeof(LocGpsData) */ + size_t size; + size_t measurement_count; + LocGpsMeasurement measurements[LOC_GPS_MAX_MEASUREMENT]; + + /** The GPS clock time reading. */ + LocGpsClock clock; +} LocGpsData; + +/** + * Represents a reading of GNSS measurements. For devices where LocGnssSystemInfo's + * year_of_hw is set to 2016+, it is mandatory that these be provided, on + * request, when the GNSS receiver is searching/tracking signals. + * + * - Reporting of GPS constellation measurements is mandatory. + * - Reporting of all tracked constellations are encouraged. + */ +typedef struct { + /** set to sizeof(LocGnssData) */ + size_t size; + + /** Number of measurements. */ + size_t measurement_count; + + /** The array of measurements. */ + LocGnssMeasurement measurements[LOC_GNSS_MAX_MEASUREMENT]; + + /** The GPS clock time reading. */ + LocGnssClock clock; +} LocGnssData; + +/** + * The legacy callback for to report measurements from the HAL. + * + * This callback is deprecated, and will be removed in the next release. Use + * loc_gnss_measurement_callback() instead. + * + * Parameters: + * data - A data structure containing the measurements. + */ +typedef void (*loc_gps_measurement_callback) (LocGpsData* data); + +/** + * The callback for to report measurements from the HAL. + * + * Parameters: + * data - A data structure containing the measurements. + */ +typedef void (*loc_gnss_measurement_callback) (LocGnssData* data); + +typedef struct { + /** set to sizeof(LocGpsMeasurementCallbacks) */ + size_t size; + loc_gps_measurement_callback measurement_callback; + loc_gnss_measurement_callback loc_gnss_measurement_callback; +} LocGpsMeasurementCallbacks; + +#define LOC_GPS_MEASUREMENT_OPERATION_SUCCESS 0 +#define LOC_GPS_MEASUREMENT_ERROR_ALREADY_INIT -100 +#define LOC_GPS_MEASUREMENT_ERROR_GENERIC -101 + +/** + * Extended interface for GPS Measurements support. + */ +typedef struct { + /** Set to sizeof(LocGpsMeasurementInterface) */ + size_t size; + + /** + * Initializes the interface and registers the callback routines with the HAL. + * After a successful call to 'init' the HAL must begin to provide updates at its own phase. + * + * Status: + * LOC_GPS_MEASUREMENT_OPERATION_SUCCESS + * LOC_GPS_MEASUREMENT_ERROR_ALREADY_INIT - if a callback has already been registered without a + * corresponding call to 'close' + * LOC_GPS_MEASUREMENT_ERROR_GENERIC - if any other error occurred, it is expected that the HAL + * will not generate any updates upon returning this error code. + */ + int (*init) (LocGpsMeasurementCallbacks* callbacks); + + /** + * Stops updates from the HAL, and unregisters the callback routines. + * After a call to stop, the previously registered callbacks must be considered invalid by the + * HAL. + * If stop is invoked without a previous 'init', this function should perform no work. + */ + void (*close) (); + +} LocGpsMeasurementInterface; + +#if 0 +/** + * Legacy struct to represents a GPS navigation message (or a fragment of it). + * Deprecated, to be removed in the next Android release. + * Use GnssNavigationMessage instead. + */ +typedef struct { + /** set to sizeof(GpsNavigationMessage) */ + size_t size; + int8_t prn; + GpsNavigationMessageType type; + NavigationMessageStatus status; + int16_t message_id; + int16_t submessage_id; + size_t data_length; + uint8_t* data; +} GpsNavigationMessage; + +/** Represents a GPS navigation message (or a fragment of it). */ +typedef struct { + /** set to sizeof(GnssNavigationMessage) */ + size_t size; + + /** + * Satellite vehicle ID number, as defined in LocGnssSvInfo::svid + * This is a mandatory value. + */ + int16_t svid; + + /** + * The type of message contained in the structure. + * This is a mandatory value. + */ + GnssNavigationMessageType type; + + /** + * The status of the received navigation message. + * No need to send any navigation message that contains words with parity error and cannot be + * corrected. + */ + NavigationMessageStatus status; + + /** + * Message identifier. It provides an index so the complete Navigation + * Message can be assembled. + * + * - For GPS L1 C/A subframe 4 and 5, this value corresponds to the 'frame + * id' of the navigation message, in the range of 1-25 (Subframe 1, 2, 3 + * does not contain a 'frame id' and this value can be set to -1.) + * + * - For Glonass L1 C/A, this refers to the frame ID, in the range of 1-5. + * + * - For BeiDou D1, this refers to the frame number in the range of 1-24 + * + * - For Beidou D2, this refers to the frame number, in the range of 1-120 + * + * - For Galileo F/NAV nominal frame structure, this refers to the subframe + * number, in the range of 1-12 + * + * - For Galileo I/NAV nominal frame structure, this refers to the subframe + * number in the range of 1-24 + */ + int16_t message_id; + + /** + * Sub-message identifier. If required by the message 'type', this value + * contains a sub-index within the current message (or frame) that is being + * transmitted. + * + * - For GPS L1 C/A, BeiDou D1 & BeiDou D2, the submessage id corresponds to + * the subframe number of the navigation message, in the range of 1-5. + * + * - For Glonass L1 C/A, this refers to the String number, in the range from + * 1-15 + * + * - For Galileo F/NAV, this refers to the page type in the range 1-6 + * + * - For Galileo I/NAV, this refers to the word type in the range 1-10+ + */ + int16_t submessage_id; + + /** + * The length of the data (in bytes) contained in the current message. + * If this value is different from zero, 'data' must point to an array of the same size. + * e.g. for L1 C/A the size of the sub-frame will be 40 bytes (10 words, 30 bits/word). + * + * This is a mandatory value. + */ + size_t data_length; + + /** + * The data of the reported GPS message. The bytes (or words) specified + * using big endian format (MSB first). + * + * - For GPS L1 C/A, Beidou D1 & Beidou D2, each subframe contains 10 30-bit + * words. Each word (30 bits) should be fit into the last 30 bits in a + * 4-byte word (skip B31 and B32), with MSB first, for a total of 40 + * bytes, covering a time period of 6, 6, and 0.6 seconds, respectively. + * + * - For Glonass L1 C/A, each string contains 85 data bits, including the + * checksum. These bits should be fit into 11 bytes, with MSB first (skip + * B86-B88), covering a time period of 2 seconds. + * + * - For Galileo F/NAV, each word consists of 238-bit (sync & tail symbols + * excluded). Each word should be fit into 30-bytes, with MSB first (skip + * B239, B240), covering a time period of 10 seconds. + * + * - For Galileo I/NAV, each page contains 2 page parts, even and odd, with + * a total of 2x114 = 228 bits, (sync & tail excluded) that should be fit + * into 29 bytes, with MSB first (skip B229-B232). + */ + uint8_t* data; + +} GnssNavigationMessage; + +/** + * The legacy callback to report an available fragment of a GPS navigation + * messages from the HAL. + * + * This callback is deprecated, and will be removed in the next release. Use + * gnss_navigation_message_callback() instead. + * + * Parameters: + * message - The GPS navigation submessage/subframe representation. + */ +typedef void (*gps_navigation_message_callback) (GpsNavigationMessage* message); + +/** + * The callback to report an available fragment of a GPS navigation messages from the HAL. + * + * Parameters: + * message - The GPS navigation submessage/subframe representation. + */ +typedef void (*gnss_navigation_message_callback) (GnssNavigationMessage* message); + +typedef struct { + /** set to sizeof(GpsNavigationMessageCallbacks) */ + size_t size; + gps_navigation_message_callback navigation_message_callback; + gnss_navigation_message_callback gnss_navigation_message_callback; +} GpsNavigationMessageCallbacks; + +#define GPS_NAVIGATION_MESSAGE_OPERATION_SUCCESS 0 +#define GPS_NAVIGATION_MESSAGE_ERROR_ALREADY_INIT -100 +#define GPS_NAVIGATION_MESSAGE_ERROR_GENERIC -101 + +/** + * Extended interface for GPS navigation message reporting support. + */ +typedef struct { + /** Set to sizeof(GpsNavigationMessageInterface) */ + size_t size; + + /** + * Initializes the interface and registers the callback routines with the HAL. + * After a successful call to 'init' the HAL must begin to provide updates as they become + * available. + * + * Status: + * GPS_NAVIGATION_MESSAGE_OPERATION_SUCCESS + * GPS_NAVIGATION_MESSAGE_ERROR_ALREADY_INIT - if a callback has already been registered + * without a corresponding call to 'close'. + * GPS_NAVIGATION_MESSAGE_ERROR_GENERIC - if any other error occurred, it is expected that + * the HAL will not generate any updates upon returning this error code. + */ + int (*init) (GpsNavigationMessageCallbacks* callbacks); + + /** + * Stops updates from the HAL, and unregisters the callback routines. + * After a call to stop, the previously registered callbacks must be considered invalid by the + * HAL. + * If stop is invoked without a previous 'init', this function should perform no work. + */ + void (*close) (); + +} GpsNavigationMessageInterface; +#endif + +/** + * Interface for passing GNSS configuration contents from platform to HAL. + */ +typedef struct { + /** Set to sizeof(LocGnssConfigurationInterface) */ + size_t size; + + /** + * Deliver GNSS configuration contents to HAL. + * Parameters: + * config_data - a pointer to a char array which holds what usually is expected from + file(/vendor/etc/gps.conf), i.e., a sequence of UTF8 strings separated by '\n'. + * length - total number of UTF8 characters in configuraiton data. + * + * IMPORTANT: + * GPS HAL should expect this function can be called multiple times. And it may be + * called even when GpsLocationProvider is already constructed and enabled. GPS HAL + * should maintain the existing requests for various callback regardless the change + * in configuration data. + */ + void (*configuration_update) (const char* config_data, int32_t length); +} LocGnssConfigurationInterface; + +__END_DECLS + +#endif /* LOC_GPS_H */ + diff --git a/gps/utils/loc_log.cpp b/gps/utils/loc_log.cpp index f6b54f9..9fad9e6 100644 --- a/gps/utils/loc_log.cpp +++ b/gps/utils/loc_log.cpp @@ -27,7 +27,7 @@ * */ -#define LOG_NDDEBUG 0 +#define LOG_NDEBUG 0 #include #include @@ -109,7 +109,6 @@ static const loc_name_val_s_type target_name[] = NAME_VAL(GNSS_MSM), NAME_VAL(GNSS_GSS), NAME_VAL(GNSS_MDM), - NAME_VAL(GNSS_QCA1530), NAME_VAL(GNSS_AUTO), NAME_VAL(GNSS_UNKNOWN) }; diff --git a/gps/utils/loc_misc_utils.cpp b/gps/utils/loc_misc_utils.cpp index dfe19a2..fd3ee6b 100644 --- a/gps/utils/loc_misc_utils.cpp +++ b/gps/utils/loc_misc_utils.cpp @@ -26,14 +26,14 @@ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */ +#define LOG_NDEBUG 0 +#define LOG_TAG "LocSvc_misc_utils" #include #include #include #include #include -#define LOG_NDDEBUG 0 -#define LOG_TAG "LocSvc_misc_utils" int loc_util_split_string(char *raw_string, char **split_strings_ptr, int max_num_substrings, char delimiter) diff --git a/gps/utils/loc_nmea.cpp b/gps/utils/loc_nmea.cpp new file mode 100644 index 0000000..eb193cc --- /dev/null +++ b/gps/utils/loc_nmea.cpp @@ -0,0 +1,1106 @@ +/* Copyright (c) 2012-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_NDEBUG 0 +#define LOG_TAG "LocSvc_nmea" +#include +#include +#include + +#define GLONASS_SV_ID_OFFSET 64 +#define MAX_SATELLITES_IN_USE 12 + +// GNSS system id according to NMEA spec +#define SYSTEM_ID_GPS 1 +#define SYSTEM_ID_GLONASS 2 +#define SYSTEM_ID_GALILEO 3 +// Extended systems +#define SYSTEM_ID_BEIDOU 4 +#define SYSTEM_ID_QZSS 5 + +typedef struct loc_nmea_sv_meta_s +{ + char talker[3]; + LocGnssConstellationType svType; + uint32_t mask; + uint32_t svCount; + uint32_t svIdOffset; + uint32_t systemId; +} loc_nmea_sv_meta; + +typedef struct loc_sv_cache_info_s +{ + uint32_t gps_used_mask; + uint32_t glo_used_mask; + uint32_t gal_used_mask; + uint32_t qzss_used_mask; + uint32_t bds_used_mask; + uint32_t gps_count; + uint32_t glo_count; + uint32_t gal_count; + uint32_t qzss_count; + uint32_t bds_count; + float hdop; + float pdop; + float vdop; +} loc_sv_cache_info; + +static loc_sv_cache_info sv_cache_info; + +/*=========================================================================== +FUNCTION loc_nmea_sv_meta_init + +DESCRIPTION + Init loc_nmea_sv_meta passed in + +DEPENDENCIES + NONE + +RETURN VALUE + Pointer to loc_nmea_sv_meta + +SIDE EFFECTS + N/A + +===========================================================================*/ +static loc_nmea_sv_meta* loc_nmea_sv_meta_init(loc_nmea_sv_meta& sv_meta, + GnssSvType svType, + bool needCombine) +{ + memset(&sv_meta, 0, sizeof(sv_meta)); + sv_meta.svType = svType; + + switch (svType) + { + case GNSS_SV_TYPE_GPS: + sv_meta.talker[0] = 'G'; + sv_meta.talker[1] = 'P'; + sv_meta.mask = sv_cache_info.gps_used_mask; + sv_meta.svCount = sv_cache_info.gps_count; + sv_meta.systemId = SYSTEM_ID_GPS; + break; + case GNSS_SV_TYPE_GLONASS: + sv_meta.talker[0] = 'G'; + sv_meta.talker[1] = 'L'; + sv_meta.mask = sv_cache_info.glo_used_mask; + sv_meta.svCount = sv_cache_info.glo_count; + // GLONASS SV ids are from 65-96 + sv_meta.svIdOffset = GLONASS_SV_ID_OFFSET; + sv_meta.systemId = SYSTEM_ID_GLONASS; + break; + case GNSS_SV_TYPE_GALILEO: + sv_meta.talker[0] = 'G'; + sv_meta.talker[1] = 'A'; + sv_meta.mask = sv_cache_info.gal_used_mask; + sv_meta.svCount = sv_cache_info.gal_count; + sv_meta.systemId = SYSTEM_ID_GALILEO; + break; + case GNSS_SV_TYPE_QZSS: + sv_meta.talker[0] = 'P'; + sv_meta.talker[1] = 'Q'; + sv_meta.mask = sv_cache_info.qzss_used_mask; + sv_meta.svCount = sv_cache_info.qzss_count; + // QZSS SV ids are from 193-197. So keep svIdOffset 0 + sv_meta.systemId = SYSTEM_ID_QZSS; + break; + case GNSS_SV_TYPE_BEIDOU: + sv_meta.talker[0] = 'P'; + sv_meta.talker[1] = 'Q'; + sv_meta.mask = sv_cache_info.bds_used_mask; + sv_meta.svCount = sv_cache_info.bds_count; + // BDS SV ids are from 201-235. So keep svIdOffset 0 + sv_meta.systemId = SYSTEM_ID_BEIDOU; + break; + default: + LOC_LOGE("NMEA Error unknow constellation type: %d", svType); + return NULL; + } + if (needCombine && + (sv_cache_info.gps_used_mask ? 1 : 0) + + (sv_cache_info.glo_used_mask ? 1 : 0) + + (sv_cache_info.gal_used_mask ? 1 : 0) + + (sv_cache_info.qzss_used_mask ? 1 : 0) + + (sv_cache_info.bds_used_mask ? 1 : 0) > 1) + { + // If GPS, GLONASS, Galileo, QZSS, BDS etc. are combined + // to obtain the reported position solution, + // talker shall be set to GN, to indicate that + // the satellites are used in a combined solution + sv_meta.talker[0] = 'G'; + sv_meta.talker[1] = 'N'; + } + return &sv_meta; +} + +/*=========================================================================== +FUNCTION loc_nmea_put_checksum + +DESCRIPTION + Generate NMEA sentences generated based on position report + +DEPENDENCIES + NONE + +RETURN VALUE + Total length of the nmea sentence + +SIDE EFFECTS + N/A + +===========================================================================*/ +static int loc_nmea_put_checksum(char *pNmea, int maxSize) +{ + uint8_t checksum = 0; + int length = 0; + if(NULL == pNmea) + return 0; + + pNmea++; //skip the $ + while (*pNmea != '\0') + { + checksum ^= *pNmea++; + length++; + } + + // length now contains nmea sentence string length not including $ sign. + int checksumLength = snprintf(pNmea,(maxSize-length-1),"*%02X\r\n", checksum); + + // total length of nmea sentence is length of nmea sentence inc $ sign plus + // length of checksum (+1 is to cover the $ character in the length). + return (length + checksumLength + 1); +} + +/*=========================================================================== +FUNCTION loc_nmea_generate_GSA + +DESCRIPTION + Generate NMEA GSA sentences generated based on position report + Currently below sentences are generated: + - $GPGSA : GPS DOP and active SVs + - $GLGSA : GLONASS DOP and active SVs + - $GAGSA : GALILEO DOP and active SVs + - $GNGSA : GNSS DOP and active SVs + +DEPENDENCIES + NONE + +RETURN VALUE + Number of SVs used + +SIDE EFFECTS + N/A + +===========================================================================*/ +static uint32_t loc_nmea_generate_GSA(const GpsLocationExtended &locationExtended, + char* sentence, + int bufSize, + loc_nmea_sv_meta* sv_meta_p, + std::vector &nmeaArraystr) +{ + if (!sentence || bufSize <= 0 || !sv_meta_p) + { + LOC_LOGE("NMEA Error invalid arguments."); + return 0; + } + + char* pMarker = sentence; + int lengthRemaining = bufSize; + int length = 0; + + uint32_t svUsedCount = 0; + uint32_t svUsedList[32] = {0}; + + char fixType = '\0'; + + const char* talker = sv_meta_p->talker; + uint32_t svIdOffset = sv_meta_p->svIdOffset; + uint32_t mask = sv_meta_p->mask; + + for (uint8_t i = 1; mask > 0 && svUsedCount < 32; i++) + { + if (mask & 1) + svUsedList[svUsedCount++] = i + svIdOffset; + mask = mask >> 1; + } + + if (svUsedCount == 0 && GNSS_SV_TYPE_GPS != sv_meta_p->svType) + return 0; + + if (svUsedCount == 0) + fixType = '1'; // no fix + else if (svUsedCount <= 3) + fixType = '2'; // 2D fix + else + fixType = '3'; // 3D fix + + // Start printing the sentence + // Format: $--GSA,a,x,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,xx,p.p,h.h,v.v*cc + // a : Mode : A : Automatic, allowed to automatically switch 2D/3D + // x : Fixtype : 1 (no fix), 2 (2D fix), 3 (3D fix) + // xx : 12 SV ID + // p.p : Position DOP (Dilution of Precision) + // h.h : Horizontal DOP + // v.v : Vertical DOP + // cc : Checksum value + length = snprintf(pMarker, lengthRemaining, "$%sGSA,A,%c,", talker, fixType); + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return 0; + } + pMarker += length; + lengthRemaining -= length; + + // Add first 12 satellite IDs + for (uint8_t i = 0; i < 12; i++) + { + if (i < svUsedCount) + length = snprintf(pMarker, lengthRemaining, "%02d,", svUsedList[i]); + else + length = snprintf(pMarker, lengthRemaining, ","); + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return 0; + } + pMarker += length; + lengthRemaining -= length; + } + + // Add the position/horizontal/vertical DOP values + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) + { + length = snprintf(pMarker, lengthRemaining, "%.1f,%.1f,%.1f,", + locationExtended.pdop, + locationExtended.hdop, + locationExtended.vdop); + } + else + { // no dop + length = snprintf(pMarker, lengthRemaining, ",,,"); + } + pMarker += length; + lengthRemaining -= length; + + // system id + length = snprintf(pMarker, lengthRemaining, "%d", sv_meta_p->systemId); + pMarker += length; + lengthRemaining -= length; + + /* Sentence is ready, add checksum and broadcast */ + length = loc_nmea_put_checksum(sentence, bufSize); + nmeaArraystr.push_back(sentence); + + return svUsedCount; +} + +/*=========================================================================== +FUNCTION loc_nmea_generate_GSV + +DESCRIPTION + Generate NMEA GSV sentences generated based on sv report + Currently below sentences are generated: + - $GPGSV: GPS Satellites in View + - $GNGSV: GLONASS Satellites in View + - $GAGSV: GALILEO Satellites in View + +DEPENDENCIES + NONE + +RETURN VALUE + NONE + +SIDE EFFECTS + N/A + +===========================================================================*/ +static void loc_nmea_generate_GSV(const GnssSvNotification &svNotify, + char* sentence, + int bufSize, + loc_nmea_sv_meta* sv_meta_p, + std::vector &nmeaArraystr) +{ + if (!sentence || bufSize <= 0) + { + LOC_LOGE("NMEA Error invalid argument."); + return; + } + + char* pMarker = sentence; + int lengthRemaining = bufSize; + int length = 0; + int sentenceCount = 0; + int sentenceNumber = 1; + size_t svNumber = 1; + + const char* talker = sv_meta_p->talker; + uint32_t svIdOffset = sv_meta_p->svIdOffset; + int svCount = sv_meta_p->svCount; + + if (svCount <= 0) + { + // no svs in view, so just send a blank $--GSV sentence + snprintf(sentence, lengthRemaining, "$%sGSV,1,1,0,", talker); + length = loc_nmea_put_checksum(sentence, bufSize); + nmeaArraystr.push_back(sentence); + return; + } + + svNumber = 1; + sentenceNumber = 1; + sentenceCount = svCount / 4 + (svCount % 4 != 0); + + while (sentenceNumber <= sentenceCount) + { + pMarker = sentence; + lengthRemaining = bufSize; + + length = snprintf(pMarker, lengthRemaining, "$%sGSV,%d,%d,%02d", + talker, sentenceCount, sentenceNumber, svCount); + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + for (int i=0; (svNumber <= svNotify.count) && (i < 4); svNumber++) + { + if (sv_meta_p->svType == svNotify.gnssSvs[svNumber - 1].type) + { + length = snprintf(pMarker, lengthRemaining,",%02d,%02d,%03d,", + svNotify.gnssSvs[svNumber - 1].svId + svIdOffset, + (int)(0.5 + svNotify.gnssSvs[svNumber - 1].elevation), //float to int + (int)(0.5 + svNotify.gnssSvs[svNumber - 1].azimuth)); //float to int + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (svNotify.gnssSvs[svNumber - 1].cN0Dbhz > 0) + { + length = snprintf(pMarker, lengthRemaining,"%02d", + (int)(0.5 + svNotify.gnssSvs[svNumber - 1].cN0Dbhz)); //float to int + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + } + + i++; + } + + } + + // The following entries are specific to QZSS and BDS + if ((sv_meta_p->svType == GNSS_SV_TYPE_QZSS) || + (sv_meta_p->svType == GNSS_SV_TYPE_BEIDOU)) + { + // last one is System id and second last is Signal Id which is always zero + length = snprintf(pMarker, lengthRemaining,",%d,%d",0,sv_meta_p->systemId); + pMarker += length; + lengthRemaining -= length; + } + + length = loc_nmea_put_checksum(sentence, bufSize); + nmeaArraystr.push_back(sentence); + sentenceNumber++; + + } //while +} + +/*=========================================================================== +FUNCTION loc_nmea_generate_pos + +DESCRIPTION + Generate NMEA sentences generated based on position report + Currently below sentences are generated within this function: + - $GPGSA : GPS DOP and active SVs + - $GLGSA : GLONASS DOP and active SVs + - $GAGSA : GALILEO DOP and active SVs + - $GNGSA : GNSS DOP and active SVs + - $--VTG : Track made good and ground speed + - $--RMC : Recommended minimum navigation information + - $--GGA : Time, position and fix related data + +DEPENDENCIES + NONE + +RETURN VALUE + 0 + +SIDE EFFECTS + N/A + +===========================================================================*/ +void loc_nmea_generate_pos(const UlpLocation &location, + const GpsLocationExtended &locationExtended, + unsigned char generate_nmea, + std::vector &nmeaArraystr) +{ + ENTRY_LOG(); + time_t utcTime(location.gpsLocation.timestamp/1000); + tm * pTm = gmtime(&utcTime); + if (NULL == pTm) { + LOC_LOGE("gmtime failed"); + return; + } + + char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0}; + char* pMarker = sentence; + int lengthRemaining = sizeof(sentence); + int length = 0; + int utcYear = pTm->tm_year % 100; // 2 digit year + int utcMonth = pTm->tm_mon + 1; // tm_mon starts at zero + int utcDay = pTm->tm_mday; + int utcHours = pTm->tm_hour; + int utcMinutes = pTm->tm_min; + int utcSeconds = pTm->tm_sec; + int utcMSeconds = (location.gpsLocation.timestamp)%1000; + + if (generate_nmea) { + char talker[3] = {'G', 'P', '\0'}; + uint32_t svUsedCount = 0; + uint32_t count = 0; + loc_nmea_sv_meta sv_meta; + // ------------------- + // ---$GPGSA/$GNGSA--- + // ------------------- + + count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GPS, true), nmeaArraystr); + if (count > 0) + { + svUsedCount += count; + talker[0] = sv_meta.talker[0]; + talker[1] = sv_meta.talker[1]; + } + + // ------------------- + // ---$GLGSA/$GNGSA--- + // ------------------- + + count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GLONASS, true), nmeaArraystr); + if (count > 0) + { + svUsedCount += count; + talker[0] = sv_meta.talker[0]; + talker[1] = sv_meta.talker[1]; + } + + // ------------------- + // ---$GAGSA/$GNGSA--- + // ------------------- + + count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GALILEO, true), nmeaArraystr); + if (count > 0) + { + svUsedCount += count; + talker[0] = sv_meta.talker[0]; + talker[1] = sv_meta.talker[1]; + } + + // -------------------------- + // ---$PQGSA/$GNGSA (QZSS)--- + // -------------------------- + + count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_QZSS, false), nmeaArraystr); + if (count > 0) + { + svUsedCount += count; + // talker should be default "GP". If GPS, GLO etc is used, it should be "GN" + } + + // ---------------------------- + // ---$PQGSA/$GNGSA (BEIDOU)--- + // ---------------------------- + count = loc_nmea_generate_GSA(locationExtended, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_BEIDOU, false), nmeaArraystr); + if (count > 0) + { + svUsedCount += count; + // talker should be default "GP". If GPS, GLO etc is used, it should be "GN" + } + + // ------------------- + // ------$--VTG------- + // ------------------- + + pMarker = sentence; + lengthRemaining = sizeof(sentence); + + if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_BEARING) + { + float magTrack = location.gpsLocation.bearing; + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV) + { + float magTrack = location.gpsLocation.bearing - locationExtended.magneticDeviation; + if (magTrack < 0.0) + magTrack += 360.0; + else if (magTrack > 360.0) + magTrack -= 360.0; + } + + length = snprintf(pMarker, lengthRemaining, "$%sVTG,%.1lf,T,%.1lf,M,", talker, location.gpsLocation.bearing, magTrack); + } + else + { + length = snprintf(pMarker, lengthRemaining, "$%sVTG,,T,,M,", talker); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_SPEED) + { + float speedKnots = location.gpsLocation.speed * (3600.0/1852.0); + float speedKmPerHour = location.gpsLocation.speed * 3.6; + + length = snprintf(pMarker, lengthRemaining, "%.1lf,N,%.1lf,K,", speedKnots, speedKmPerHour); + } + else + { + length = snprintf(pMarker, lengthRemaining, ",N,,K,"); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) + // N means no fix + length = snprintf(pMarker, lengthRemaining, "%c", 'N'); + else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask) + // D means differential + length = snprintf(pMarker, lengthRemaining, "%c", 'D'); + else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask) + // E means estimated (dead reckoning) + length = snprintf(pMarker, lengthRemaining, "%c", 'E'); + else // A means autonomous + length = snprintf(pMarker, lengthRemaining, "%c", 'A'); + + length = loc_nmea_put_checksum(sentence, sizeof(sentence)); + nmeaArraystr.push_back(sentence); + + // ------------------- + // ------$--RMC------- + // ------------------- + + pMarker = sentence; + lengthRemaining = sizeof(sentence); + + length = snprintf(pMarker, lengthRemaining, "$%sRMC,%02d%02d%02d.%02d,A," , + talker, utcHours, utcMinutes, utcSeconds,utcMSeconds/10); + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG) + { + double latitude = location.gpsLocation.latitude; + double longitude = location.gpsLocation.longitude; + char latHemisphere; + char lonHemisphere; + double latMinutes; + double lonMinutes; + + if (latitude > 0) + { + latHemisphere = 'N'; + } + else + { + latHemisphere = 'S'; + latitude *= -1.0; + } + + if (longitude < 0) + { + lonHemisphere = 'W'; + longitude *= -1.0; + } + else + { + lonHemisphere = 'E'; + } + + latMinutes = fmod(latitude * 60.0 , 60.0); + lonMinutes = fmod(longitude * 60.0 , 60.0); + + length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,", + (uint8_t)floor(latitude), latMinutes, latHemisphere, + (uint8_t)floor(longitude),lonMinutes, lonHemisphere); + } + else + { + length = snprintf(pMarker, lengthRemaining,",,,,"); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_SPEED) + { + float speedKnots = location.gpsLocation.speed * (3600.0/1852.0); + length = snprintf(pMarker, lengthRemaining, "%.1lf,", speedKnots); + } + else + { + length = snprintf(pMarker, lengthRemaining, ","); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_BEARING) + { + length = snprintf(pMarker, lengthRemaining, "%.1lf,", location.gpsLocation.bearing); + } + else + { + length = snprintf(pMarker, lengthRemaining, ","); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + length = snprintf(pMarker, lengthRemaining, "%2.2d%2.2d%2.2d,", + utcDay, utcMonth, utcYear); + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_MAG_DEV) + { + float magneticVariation = locationExtended.magneticDeviation; + char direction; + if (magneticVariation < 0.0) + { + direction = 'W'; + magneticVariation *= -1.0; + } + else + { + direction = 'E'; + } + + length = snprintf(pMarker, lengthRemaining, "%.1lf,%c,", + magneticVariation, direction); + } + else + { + length = snprintf(pMarker, lengthRemaining, ",,"); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) + // N means no fix + length = snprintf(pMarker, lengthRemaining, "%c", 'N'); + else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask) + // D means differential + length = snprintf(pMarker, lengthRemaining, "%c", 'D'); + else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask) + // E means estimated (dead reckoning) + length = snprintf(pMarker, lengthRemaining, "%c", 'E'); + else // A means autonomous + length = snprintf(pMarker, lengthRemaining, "%c", 'A'); + + length = loc_nmea_put_checksum(sentence, sizeof(sentence)); + nmeaArraystr.push_back(sentence); + + // ------------------- + // ------$--GGA------- + // ------------------- + + pMarker = sentence; + lengthRemaining = sizeof(sentence); + + length = snprintf(pMarker, lengthRemaining, "$%sGGA,%02d%02d%02d.%02d," , + talker, utcHours, utcMinutes, utcSeconds, utcMSeconds/10); + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG) + { + double latitude = location.gpsLocation.latitude; + double longitude = location.gpsLocation.longitude; + char latHemisphere; + char lonHemisphere; + double latMinutes; + double lonMinutes; + + if (latitude > 0) + { + latHemisphere = 'N'; + } + else + { + latHemisphere = 'S'; + latitude *= -1.0; + } + + if (longitude < 0) + { + lonHemisphere = 'W'; + longitude *= -1.0; + } + else + { + lonHemisphere = 'E'; + } + + latMinutes = fmod(latitude * 60.0 , 60.0); + lonMinutes = fmod(longitude * 60.0 , 60.0); + + length = snprintf(pMarker, lengthRemaining, "%02d%09.6lf,%c,%03d%09.6lf,%c,", + (uint8_t)floor(latitude), latMinutes, latHemisphere, + (uint8_t)floor(longitude),lonMinutes, lonHemisphere); + } + else + { + length = snprintf(pMarker, lengthRemaining,",,,,"); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + char gpsQuality; + if (!(location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_LAT_LONG)) + gpsQuality = '0'; // 0 means no fix + else if (LOC_NAV_MASK_SBAS_CORRECTION_IONO & locationExtended.navSolutionMask) + gpsQuality = '2'; // 2 means DGPS fix + else if (LOC_POS_TECH_MASK_SENSORS == locationExtended.tech_mask) + gpsQuality = '6'; // 6 means estimated (dead reckoning) + else + gpsQuality = '1'; // 1 means GPS fix + + // Number of satellites in use, 00-12 + if (svUsedCount > MAX_SATELLITES_IN_USE) + svUsedCount = MAX_SATELLITES_IN_USE; + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_DOP) + { + length = snprintf(pMarker, lengthRemaining, "%c,%02d,%.1f,", + gpsQuality, svUsedCount, locationExtended.hdop); + } + else + { // no hdop + length = snprintf(pMarker, lengthRemaining, "%c,%02d,,", + gpsQuality, svUsedCount); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL) + { + length = snprintf(pMarker, lengthRemaining, "%.1lf,M,", + locationExtended.altitudeMeanSeaLevel); + } + else + { + length = snprintf(pMarker, lengthRemaining,",,"); + } + + if (length < 0 || length >= lengthRemaining) + { + LOC_LOGE("NMEA Error in string formatting"); + return; + } + pMarker += length; + lengthRemaining -= length; + + if ((location.gpsLocation.flags & LOC_GPS_LOCATION_HAS_ALTITUDE) && + (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL)) + { + length = snprintf(pMarker, lengthRemaining, "%.1lf,M,,", + location.gpsLocation.altitude - locationExtended.altitudeMeanSeaLevel); + } + else + { + length = snprintf(pMarker, lengthRemaining,",,,"); + } + + length = loc_nmea_put_checksum(sentence, sizeof(sentence)); + nmeaArraystr.push_back(sentence); + + // clear the cache so they can't be used again + sv_cache_info.gps_used_mask = 0; + sv_cache_info.glo_used_mask = 0; + sv_cache_info.gal_used_mask = 0; + sv_cache_info.qzss_used_mask = 0; + sv_cache_info.bds_used_mask = 0; + } + //Send blank NMEA reports for non-final fixes + else { + strlcpy(sentence, "$GPGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence)); + length = loc_nmea_put_checksum(sentence, sizeof(sentence)); + nmeaArraystr.push_back(sentence); + + strlcpy(sentence, "$GNGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence)); + length = loc_nmea_put_checksum(sentence, sizeof(sentence)); + nmeaArraystr.push_back(sentence); + + strlcpy(sentence, "$PQGSA,A,1,,,,,,,,,,,,,,,", sizeof(sentence)); + length = loc_nmea_put_checksum(sentence, sizeof(sentence)); + nmeaArraystr.push_back(sentence); + + strlcpy(sentence, "$GPVTG,,T,,M,,N,,K,N", sizeof(sentence)); + length = loc_nmea_put_checksum(sentence, sizeof(sentence)); + nmeaArraystr.push_back(sentence); + + strlcpy(sentence, "$GPRMC,,V,,,,,,,,,,N", sizeof(sentence)); + length = loc_nmea_put_checksum(sentence, sizeof(sentence)); + nmeaArraystr.push_back(sentence); + + strlcpy(sentence, "$GPGGA,,,,,,0,,,,,,,,", sizeof(sentence)); + length = loc_nmea_put_checksum(sentence, sizeof(sentence)); + nmeaArraystr.push_back(sentence); + } + + EXIT_LOG(%d, 0); +} + + + +/*=========================================================================== +FUNCTION loc_nmea_generate_sv + +DESCRIPTION + Generate NMEA sentences generated based on sv report + +DEPENDENCIES + NONE + +RETURN VALUE + 0 + +SIDE EFFECTS + N/A + +===========================================================================*/ +void loc_nmea_generate_sv(const GnssSvNotification &svNotify, + std::vector &nmeaArraystr) +{ + ENTRY_LOG(); + + char sentence[NMEA_SENTENCE_MAX_LENGTH] = {0}; + char* pMarker = sentence; + int lengthRemaining = sizeof(sentence); + int length = 0; + int svCount = svNotify.count; + int sentenceCount = 0; + int sentenceNumber = 1; + int svNumber = 1; + + //Count GPS SVs for saparating GPS from GLONASS and throw others + + sv_cache_info.gps_used_mask = 0; + sv_cache_info.glo_used_mask = 0; + sv_cache_info.gal_used_mask = 0; + sv_cache_info.qzss_used_mask = 0; + sv_cache_info.bds_used_mask = 0; + + sv_cache_info.gps_count = 0; + sv_cache_info.glo_count = 0; + sv_cache_info.gal_count = 0; + sv_cache_info.qzss_count = 0; + sv_cache_info.bds_count = 0; + for(svNumber=1; svNumber <= svCount; svNumber++) { + if (GNSS_SV_TYPE_GPS == svNotify.gnssSvs[svNumber - 1].type) + { + // cache the used in fix mask, as it will be needed to send $GPGSA + // during the position report + if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == + (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) + { + sv_cache_info.gps_used_mask |= (1 << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + } + sv_cache_info.gps_count++; + } + else if (GNSS_SV_TYPE_GLONASS == svNotify.gnssSvs[svNumber - 1].type) + { + // cache the used in fix mask, as it will be needed to send $GNGSA + // during the position report + if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == + (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) + { + sv_cache_info.glo_used_mask |= (1 << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + } + sv_cache_info.glo_count++; + } + else if (GNSS_SV_TYPE_GALILEO == svNotify.gnssSvs[svNumber - 1].type) + { + // cache the used in fix mask, as it will be needed to send $GAGSA + // during the position report + if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == + (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) + { + sv_cache_info.gal_used_mask |= (1 << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + } + sv_cache_info.gal_count++; + } + else if (GNSS_SV_TYPE_QZSS == svNotify.gnssSvs[svNumber - 1].type) + { + // cache the used in fix mask, as it will be needed to send $PQGSA + // during the position report + if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == + (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) + { + sv_cache_info.qzss_used_mask |= (1 << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + } + sv_cache_info.qzss_count++; + } + else if (GNSS_SV_TYPE_BEIDOU == svNotify.gnssSvs[svNumber - 1].type) + { + // cache the used in fix mask, as it will be needed to send $PQGSA + // during the position report + if (GNSS_SV_OPTIONS_USED_IN_FIX_BIT == + (svNotify.gnssSvs[svNumber - 1].gnssSvOptionsMask & + GNSS_SV_OPTIONS_USED_IN_FIX_BIT)) + { + sv_cache_info.bds_used_mask |= (1 << (svNotify.gnssSvs[svNumber - 1].svId - 1)); + } + sv_cache_info.bds_count++; + } + } + + loc_nmea_sv_meta sv_meta; + // ------------------ + // ------$GPGSV------ + // ------------------ + + loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GPS, false), nmeaArraystr); + + // ------------------ + // ------$GLGSV------ + // ------------------ + + loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GLONASS, false), nmeaArraystr); + + // ------------------ + // ------$GAGSV------ + // ------------------ + + loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_GALILEO, false), nmeaArraystr); + + // ------------------------- + // ------$PQGSV (QZSS)------ + // ------------------------- + + loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_QZSS, false), nmeaArraystr); + + // --------------------------- + // ------$PQGSV (BEIDOU)------ + // --------------------------- + + loc_nmea_generate_GSV(svNotify, sentence, sizeof(sentence), + loc_nmea_sv_meta_init(sv_meta, GNSS_SV_TYPE_BEIDOU, false), nmeaArraystr); + + EXIT_LOG(%d, 0); +} diff --git a/gps/loc_api/libloc_api_50001/loc_eng_nmea.h b/gps/utils/loc_nmea.h similarity index 66% rename from gps/loc_api/libloc_api_50001/loc_eng_nmea.h rename to gps/utils/loc_nmea.h index 066943a..585a9c1 100644 --- a/gps/loc_api/libloc_api_50001/loc_eng_nmea.h +++ b/gps/utils/loc_nmea.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2012, The Linux Foundation. All rights reserved. +/* Copyright (c) 2012-2013, 2015-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 @@ -30,14 +30,25 @@ #ifndef LOC_ENG_NMEA_H #define LOC_ENG_NMEA_H -#include #include - +#include +#include #define NMEA_SENTENCE_MAX_LENGTH 200 -void loc_eng_nmea_send(char *pNmea, int length, loc_eng_data_s_type *loc_eng_data_p); -int loc_eng_nmea_put_checksum(char *pNmea, int maxSize); -void loc_eng_nmea_generate_sv(loc_eng_data_s_type *loc_eng_data_p, const GnssSvStatus &svStatus, const GpsLocationExtended &locationExtended); -void loc_eng_nmea_generate_pos(loc_eng_data_s_type *loc_eng_data_p, const UlpLocation &location, const GpsLocationExtended &locationExtended, unsigned char generate_nmea); +void loc_nmea_generate_sv(const GnssSvNotification &svNotify, + std::vector &nmeaArraystr); + +void loc_nmea_generate_pos(const UlpLocation &location, + const GpsLocationExtended &locationExtended, + unsigned char generate_nmea, + std::vector &nmeaArraystr); + +#define DEBUG_NMEA_MINSIZE 6 +#define DEBUG_NMEA_MAXSIZE 4096 +inline bool loc_nmea_is_debug(const char* nmea, int length) { + return ((nullptr != nmea) && + (length >= DEBUG_NMEA_MINSIZE) && (length <= DEBUG_NMEA_MAXSIZE) && + (nmea[0] == '$') && (nmea[1] == 'P') && (nmea[2] == 'Q') && (nmea[3] == 'W')); +} #endif // LOC_ENG_NMEA_H diff --git a/gps/utils/loc_target.cpp b/gps/utils/loc_target.cpp index 2da2fea..cf42932 100644 --- a/gps/utils/loc_target.cpp +++ b/gps/utils/loc_target.cpp @@ -34,7 +34,6 @@ #include #include #include -#include #include #include "loc_target.h" #include "loc_log.h" @@ -53,18 +52,15 @@ #define STR_SURF "Surf" #define STR_MTP "MTP" #define STR_APQ "apq" +#define STR_SDC "sdc" // alternative string for APQ targets +#define STR_MSM "msm" +#define STR_SDM "sdm" // alternative string for MSM targets #define STR_APQ_NO_WGR "baseband_apq_nowgr" #define STR_AUTO "auto" #define IS_STR_END(c) ((c) == '\0' || (c) == '\n' || (c) == '\r') #define LENGTH(s) (sizeof(s) - 1) #define GPS_CHECK_NO_ERROR 0 #define GPS_CHECK_NO_GPS_HW 1 -/* When system server is started, it uses 20 seconds as ActivityManager - * timeout. After that it sends SIGSTOP signal to process. - */ -#define QCA1530_DETECT_TIMEOUT 15 -#define QCA1530_DETECT_PRESENT "yes" -#define QCA1530_DETECT_PROGRESS "detect" static unsigned int gTarget = (unsigned int)-1; @@ -90,63 +86,6 @@ static int read_a_line(const char * file_path, char * line, int line_size) return result; } -/*! - * \brief Checks if QCA1530 is avalable. - * - * Function verifies if qca1530 SoC is configured on the device. The test is - * based on property value. For 1530 scenario, the value shall be one of the - * following: "yes", "no", "detect". All other values are treated equally to - * "no". When the value is "detect" the system waits for SoC detection to - * finish before returning result. - * - * \retval true - QCA1530 is available. - * \retval false - QCA1530 is not available. - */ -static bool is_qca1530(void) -{ - static const char qca1530_property_name[] = "sys.qca1530"; - bool res = false; - int ret, i; - char buf[PROPERTY_VALUE_MAX]; - - memset(buf, 0, sizeof(buf)); - - for (i = 0; i < QCA1530_DETECT_TIMEOUT; ++i) - { - ret = platform_lib_abstraction_property_get(qca1530_property_name, buf, NULL); - if (ret < 0) - { - LOC_LOGV( "qca1530: property %s is not accessible, ret=%d", - qca1530_property_name, - ret); - - break; - } - - LOC_LOGV( "qca1530: property %s is set to %s", - qca1530_property_name, - buf); - - if (!memcmp(buf, QCA1530_DETECT_PRESENT, - sizeof(QCA1530_DETECT_PRESENT))) - { - res = true; - break; - } - if (!memcmp(buf, QCA1530_DETECT_PROGRESS, - sizeof(QCA1530_DETECT_PROGRESS))) - { - LOC_LOGV("qca1530: SoC detection is in progress."); - sleep(1); - continue; - } - break; - } - - LOC_LOGD("qca1530: detected=%s", res ? "true" : "false"); - return res; -} - /*The character array passed to this function should have length of atleast PROPERTY_VALUE_MAX*/ void loc_get_target_baseband(char *baseband, int array_length) @@ -199,7 +138,7 @@ unsigned int loc_get_target(void) static const char hw_platform_dep[] = "/sys/devices/system/soc/soc0/hw_platform"; static const char id_dep[] = "/sys/devices/system/soc/soc0/id"; - static const char mdm[] = "/dev/mdm"; // No such file or directory + static const char mdm[] = "/target"; // mdm target we are using char rd_hw_platform[LINE_LEN]; char rd_id[LINE_LEN]; @@ -207,11 +146,6 @@ unsigned int loc_get_target(void) char baseband[LINE_LEN]; char rd_auto_platform[LINE_LEN]; - if (is_qca1530()) { - gTarget = TARGET_QCA1530; - goto detected; - } - loc_get_target_baseband(baseband, sizeof(baseband)); if (!access(hw_platform, F_OK)) { @@ -239,36 +173,36 @@ unsigned int loc_get_target(void) goto detected; } - if( !memcmp(baseband, STR_APQ, LENGTH(STR_APQ)) ){ + if( !memcmp(baseband, STR_APQ, LENGTH(STR_APQ)) || + !memcmp(baseband, STR_SDC, LENGTH(STR_SDC)) ) { if( !memcmp(rd_id, MPQ8064_ID_1, LENGTH(MPQ8064_ID_1)) && IS_STR_END(rd_id[LENGTH(MPQ8064_ID_1)]) ) gTarget = TARGET_NO_GNSS; else gTarget = TARGET_APQ_SA; - } - else { - if( (!memcmp(rd_hw_platform, STR_LIQUID, LENGTH(STR_LIQUID)) - && IS_STR_END(rd_hw_platform[LENGTH(STR_LIQUID)])) || - (!memcmp(rd_hw_platform, STR_SURF, LENGTH(STR_SURF)) - && IS_STR_END(rd_hw_platform[LENGTH(STR_SURF)])) || - (!memcmp(rd_hw_platform, STR_MTP, LENGTH(STR_MTP)) - && IS_STR_END(rd_hw_platform[LENGTH(STR_MTP)]))) { - - if (!read_a_line( mdm, rd_mdm, LINE_LEN)) - gTarget = TARGET_MDM; - } - else if( (!memcmp(rd_id, MSM8930_ID_1, LENGTH(MSM8930_ID_1)) - && IS_STR_END(rd_id[LENGTH(MSM8930_ID_1)])) || - (!memcmp(rd_id, MSM8930_ID_2, LENGTH(MSM8930_ID_2)) - && IS_STR_END(rd_id[LENGTH(MSM8930_ID_2)])) ) - gTarget = TARGET_MSM_NO_SSC; - else - gTarget = TARGET_UNKNOWN; + } else if (((!memcmp(rd_hw_platform, STR_LIQUID, LENGTH(STR_LIQUID)) + && IS_STR_END(rd_hw_platform[LENGTH(STR_LIQUID)])) || + (!memcmp(rd_hw_platform, STR_SURF, LENGTH(STR_SURF)) + && IS_STR_END(rd_hw_platform[LENGTH(STR_SURF)])) || + (!memcmp(rd_hw_platform, STR_MTP, LENGTH(STR_MTP)) + && IS_STR_END(rd_hw_platform[LENGTH(STR_MTP)]))) && + !read_a_line( mdm, rd_mdm, LINE_LEN)) { + gTarget = TARGET_MDM; + } else if( (!memcmp(rd_id, MSM8930_ID_1, LENGTH(MSM8930_ID_1)) + && IS_STR_END(rd_id[LENGTH(MSM8930_ID_1)])) || + (!memcmp(rd_id, MSM8930_ID_2, LENGTH(MSM8930_ID_2)) + && IS_STR_END(rd_id[LENGTH(MSM8930_ID_2)])) ) { + gTarget = TARGET_MSM_NO_SSC; + } else if ( !memcmp(baseband, STR_MSM, LENGTH(STR_MSM)) || + !memcmp(baseband, STR_SDM, LENGTH(STR_SDM)) ) { + gTarget = TARGET_DEFAULT; + } else { + gTarget = TARGET_UNKNOWN; } detected: - LOC_LOGD("HAL: %s returned %d", __FUNCTION__, gTarget); + LOC_LOGW("HAL: %s returned %d", __FUNCTION__, gTarget); return gTarget; } diff --git a/gps/utils/loc_target.h b/gps/utils/loc_target.h index 69395db..47a67d9 100644 --- a/gps/utils/loc_target.h +++ b/gps/utils/loc_target.h @@ -34,7 +34,6 @@ #define TARGET_APQ_SA TARGET_SET(GNSS_GSS, NO_SSC) #define TARGET_NO_GNSS TARGET_SET(GNSS_NONE, NO_SSC) #define TARGET_MSM_NO_SSC TARGET_SET(GNSS_MSM, NO_SSC) -#define TARGET_QCA1530 TARGET_SET(GNSS_QCA1530, NO_SSC) #define TARGET_AUTO TARGET_SET(GNSS_AUTO, NO_SSC) #define TARGET_UNKNOWN TARGET_SET(GNSS_UNKNOWN, NO_SSC) #define getTargetGnssType(target) (target>>1) @@ -69,7 +68,6 @@ typedef enum { GNSS_MSM, GNSS_GSS, GNSS_MDM, - GNSS_QCA1530, GNSS_AUTO, GNSS_UNKNOWN }GNSS_TARGET; diff --git a/gps/utils/log_util.h b/gps/utils/log_util.h index d27c800..7eb338a 100644 --- a/gps/utils/log_util.h +++ b/gps/utils/log_util.h @@ -99,46 +99,24 @@ extern char* get_timestamp(char* str, unsigned long buf_size); provide a value and we default to the initial value to use Android's logging levels*/ #define IF_LOC_LOGE if((loc_logger.DEBUG_LEVEL >= 1) && (loc_logger.DEBUG_LEVEL <= 5)) - #define IF_LOC_LOGW if((loc_logger.DEBUG_LEVEL >= 2) && (loc_logger.DEBUG_LEVEL <= 5)) - #define IF_LOC_LOGI if((loc_logger.DEBUG_LEVEL >= 3) && (loc_logger.DEBUG_LEVEL <= 5)) - #define IF_LOC_LOGD if((loc_logger.DEBUG_LEVEL >= 4) && (loc_logger.DEBUG_LEVEL <= 5)) - #define IF_LOC_LOGV if((loc_logger.DEBUG_LEVEL >= 5) && (loc_logger.DEBUG_LEVEL <= 5)) -#define LOC_LOGE(...) \ -IF_LOC_LOGE { ALOGE("E/" __VA_ARGS__); } \ -else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGE("E/" __VA_ARGS__); } - -#define LOC_LOGW(...) \ -IF_LOC_LOGW { ALOGE("W/" __VA_ARGS__); } \ -else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGW("W/" __VA_ARGS__); } - -#define LOC_LOGI(...) \ -IF_LOC_LOGI { ALOGE("I/" __VA_ARGS__); } \ -else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGI("I/" __VA_ARGS__); } - -#define LOC_LOGD(...) \ -IF_LOC_LOGD { ALOGE("D/" __VA_ARGS__); } \ -else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGD("D/" __VA_ARGS__); } - -#define LOC_LOGV(...) \ -IF_LOC_LOGV { ALOGE("V/" __VA_ARGS__); } \ -else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/" __VA_ARGS__); } +#define LOC_LOGE(...) IF_LOC_LOGE { ALOGE(__VA_ARGS__); } +#define LOC_LOGW(...) IF_LOC_LOGW { ALOGW(__VA_ARGS__); } +#define LOC_LOGI(...) IF_LOC_LOGI { ALOGI(__VA_ARGS__); } +#define LOC_LOGD(...) IF_LOC_LOGD { ALOGD(__VA_ARGS__); } +#define LOC_LOGV(...) IF_LOC_LOGV { ALOGV(__VA_ARGS__); } #else /* DEBUG_DMN_LOC_API */ -#define LOC_LOGE(...) ALOGE("E/" __VA_ARGS__) - -#define LOC_LOGW(...) ALOGW("W/" __VA_ARGS__) - -#define LOC_LOGI(...) ALOGI("I/" __VA_ARGS__) - -#define LOC_LOGD(...) ALOGD("D/" __VA_ARGS__) - -#define LOC_LOGV(...) ALOGV("V/" __VA_ARGS__) +#define LOC_LOGE(...) ALOGE(__VA_ARGS__) +#define LOC_LOGW(...) ALOGW(__VA_ARGS__) +#define LOC_LOGI(...) ALOGI(__VA_ARGS__) +#define LOC_LOGD(...) ALOGD(__VA_ARGS__) +#define LOC_LOGV(...) ALOGV(__VA_ARGS__) #endif /* DEBUG_DMN_LOC_API */ @@ -159,32 +137,32 @@ else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/" __VA_ARGS__); } } \ } while(0) -#define LOC_LOG_HEAD(tag,fmt) "%s:%d][" tag "] " fmt "\n" -#define LOC_LOGv(tag,fmt,...) LOC_LOGV(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) -#define LOC_LOGw(tag,fmt,...) LOC_LOGW(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) -#define LOC_LOGd(tag,fmt,...) LOC_LOGD(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) -#define LOC_LOGe(tag,fmt,...) LOC_LOGE(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) +#define LOC_LOG_HEAD(fmt) "%s:%d] " fmt +#define LOC_LOGv(fmt,...) LOC_LOGV(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define LOC_LOGw(fmt,...) LOC_LOGW(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define LOC_LOGd(fmt,...) LOC_LOGD(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define LOC_LOGe(fmt,...) LOC_LOGE(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__) #define LOG_I(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGI, ID, WHAT, SPEC, VAL) #define LOG_V(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGV, ID, WHAT, SPEC, VAL) #define LOG_E(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGE, ID, WHAT, SPEC, VAL) -#define ENTRY_LOG() LOG_V(ENTRY_TAG, __func__, %s, "") -#define EXIT_LOG(SPEC, VAL) LOG_V(EXIT_TAG, __func__, SPEC, VAL) +#define ENTRY_LOG() LOG_V(ENTRY_TAG, __FUNCTION__, %s, "") +#define EXIT_LOG(SPEC, VAL) LOG_V(EXIT_TAG, __FUNCTION__, SPEC, VAL) #define EXIT_LOG_WITH_ERROR(SPEC, VAL) \ if (VAL != 0) { \ - LOG_E(EXIT_ERROR_TAG, __func__, SPEC, VAL); \ + LOG_E(EXIT_ERROR_TAG, __FUNCTION__, SPEC, VAL); \ } else { \ - LOG_V(EXIT_TAG, __func__, SPEC, VAL); \ + LOG_V(EXIT_TAG, __FUNCTION__, SPEC, VAL); \ } // Used for logging callflow from Android Framework -#define ENTRY_LOG_CALLFLOW() LOG_I(FROM_AFW, __func__, %s, "") +#define ENTRY_LOG_CALLFLOW() LOG_I(FROM_AFW, __FUNCTION__, %s, "") // Used for logging callflow to Modem -#define EXIT_LOG_CALLFLOW(SPEC, VAL) LOG_I(TO_MODEM, __func__, SPEC, VAL) -// Used for logging callflow from Modem(TO_MODEM, __func__, %s, "") -#define MODEM_LOG_CALLFLOW(SPEC, VAL) LOG_I(FROM_MODEM, __func__, SPEC, VAL) +#define EXIT_LOG_CALLFLOW(SPEC, VAL) LOG_I(TO_MODEM, __FUNCTION__, SPEC, VAL) +// Used for logging callflow from Modem(TO_MODEM, __FUNCTION__, %s, "") +#define MODEM_LOG_CALLFLOW(SPEC, VAL) LOG_I(FROM_MODEM, __FUNCTION__, SPEC, VAL) // Used for logging callflow to Android Framework #define CALLBACK_LOG_CALLFLOW(CB, SPEC, VAL) LOG_I(TO_AFW, CB, SPEC, VAL) diff --git a/gps/utils/msg_q.c b/gps/utils/msg_q.c index e412e78..e8b4ffe 100644 --- a/gps/utils/msg_q.c +++ b/gps/utils/msg_q.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2011-2012,2014 The Linux Foundation. All rights reserved. +/* Copyright (c) 2011-2012, 2014, 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 @@ -198,7 +198,7 @@ msq_q_err_type msg_q_snd(void* msg_q_data, void* msg_obj, void (*dealloc)(void*) msg_q* p_msg_q = (msg_q*)msg_q_data; pthread_mutex_lock(&p_msg_q->list_mutex); - LOC_LOGV("%s: Sending message with handle = 0x%08X\n", __FUNCTION__, msg_obj); + LOC_LOGV("%s: Sending message with handle = %p\n", __FUNCTION__, msg_obj); if( p_msg_q->unblocked ) { @@ -214,7 +214,7 @@ msq_q_err_type msg_q_snd(void* msg_q_data, void* msg_obj, void (*dealloc)(void*) pthread_mutex_unlock(&p_msg_q->list_mutex); - LOC_LOGV("%s: Finished Sending message with handle = 0x%08X\n", __FUNCTION__, msg_obj); + LOC_LOGV("%s: Finished Sending message with handle = %p\n", __FUNCTION__, msg_obj); return rv; } @@ -241,8 +241,6 @@ msq_q_err_type msg_q_rcv(void* msg_q_data, void** msg_obj) msg_q* p_msg_q = (msg_q*)msg_q_data; - LOC_LOGV("%s: Waiting on message\n", __FUNCTION__); - pthread_mutex_lock(&p_msg_q->list_mutex); if( p_msg_q->unblocked ) @@ -262,7 +260,7 @@ msq_q_err_type msg_q_rcv(void* msg_q_data, void** msg_obj) pthread_mutex_unlock(&p_msg_q->list_mutex); - LOC_LOGV("%s: Received message 0x%08X rv = %d\n", __FUNCTION__, *msg_obj, rv); + LOC_LOGV("%s: Received message %p rv = %d\n", __FUNCTION__, *msg_obj, rv); return rv; } diff --git a/gps/utils/platform_lib_abstractions/elapsed_millis_since_boot.cpp b/gps/utils/platform_lib_abstractions/elapsed_millis_since_boot.cpp index e8cb93a..6c183a8 100644 --- a/gps/utils/platform_lib_abstractions/elapsed_millis_since_boot.cpp +++ b/gps/utils/platform_lib_abstractions/elapsed_millis_since_boot.cpp @@ -30,7 +30,7 @@ #include #include "platform_lib_time.h" -int64_t systemTime(int clock) +int64_t systemTime(int /*clock*/) { struct timeval t; t.tv_sec = t.tv_usec = 0; diff --git a/gps/utils/platform_lib_abstractions/loc_pla/Makefile.am b/gps/utils/platform_lib_abstractions/loc_pla/Makefile.am new file mode 100644 index 0000000..8996763 --- /dev/null +++ b/gps/utils/platform_lib_abstractions/loc_pla/Makefile.am @@ -0,0 +1,10 @@ +# Makefile.am for gps loc-pla +# + +ACLOCAL_AMFLAGS = -I m4 + +SUBDIRS = src + +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = loc-pla.pc +EXTRA_DIST = $(pkgconfig_DATA) diff --git a/gps/utils/platform_lib_abstractions/loc_pla/configure.ac b/gps/utils/platform_lib_abstractions/loc_pla/configure.ac new file mode 100644 index 0000000..a8b892b --- /dev/null +++ b/gps/utils/platform_lib_abstractions/loc_pla/configure.ac @@ -0,0 +1,61 @@ +# configure.ac -- Autoconf script for gps loc-pla +# +# Process this file with autoconf to produce a configure script + +# Requires autoconf tool later than 2.61 +AC_PREREQ(2.61) +# Initialize the gps loc-pla package version 1.0.0 +AC_INIT([loc-pla],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([include/platform_lib_includes.h]) +# 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([LOCSTUB], [loc-stub]) +AC_SUBST([LOCSTUB_CFLAGS]) +AC_SUBST([LOCSTUB_LIBS]) + +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 \ + src/Makefile \ + loc-pla.pc \ + ]) + +AC_OUTPUT diff --git a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_android_runtime.h b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_android_runtime.h deleted file mode 100644 index 9a954f0..0000000 --- a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_android_runtime.h +++ /dev/null @@ -1,45 +0,0 @@ -/* Copyright (c) 2014, 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 __PLATFORM_LIB_ANDROID_RUNTIME_H__ -#define __PLATFORM_LIB_ANDROID_RUNTIME_H__ - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -pthread_t platform_lib_abstraction_createJavaThread(const char* name, void (*start)(void *), void* arg); -#define LOC_EXT_CREATE_THREAD_CB_PLATFORM_LIB_ABSTRACTION platform_lib_abstraction_createJavaThread - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /*__PLATFORM_LIB_ANDROID_RUNTIME_H__ */ diff --git a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_gettid.h b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_gettid.h index 9956937..340c3c5 100644 --- a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_gettid.h +++ b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_gettid.h @@ -34,6 +34,10 @@ #ifdef __cplusplus extern "C" { #endif +#ifdef USE_GLIB +const char* getprogname(); +#endif /* USE_GLIB */ + pid_t platform_lib_abstraction_gettid(); #ifdef __cplusplus } diff --git a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_includes.h b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_includes.h index 47c37df..ebb7119 100644 --- a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_includes.h +++ b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_includes.h @@ -29,7 +29,6 @@ #ifndef __PLATFORM_LIB_INCLUDES_H__ #define __PLATFORM_LIB_INCLUDES_H__ -#include "platform_lib_android_runtime.h" #include "platform_lib_gettid.h" #include "platform_lib_log_util.h" #include "platform_lib_macros.h" diff --git a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_log_util.h b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_log_util.h index 5989c64..26d3c29 100644 --- a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_log_util.h +++ b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_log_util.h @@ -98,46 +98,24 @@ char* get_timestamp(char* str, unsigned long buf_size); provide a value and we default to the initial value to use Android's logging levels*/ #define IF_LOC_LOGE if((loc_logger.DEBUG_LEVEL >= 1) && (loc_logger.DEBUG_LEVEL <= 5)) - #define IF_LOC_LOGW if((loc_logger.DEBUG_LEVEL >= 2) && (loc_logger.DEBUG_LEVEL <= 5)) - #define IF_LOC_LOGI if((loc_logger.DEBUG_LEVEL >= 3) && (loc_logger.DEBUG_LEVEL <= 5)) - #define IF_LOC_LOGD if((loc_logger.DEBUG_LEVEL >= 4) && (loc_logger.DEBUG_LEVEL <= 5)) - #define IF_LOC_LOGV if((loc_logger.DEBUG_LEVEL >= 5) && (loc_logger.DEBUG_LEVEL <= 5)) -#define LOC_LOGE(...) \ -IF_LOC_LOGE { ALOGE("E/" __VA_ARGS__); } \ -else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGE("E/" __VA_ARGS__); } - -#define LOC_LOGW(...) \ -IF_LOC_LOGW { ALOGE("W/" __VA_ARGS__); } \ -else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGW("W/" __VA_ARGS__); } - -#define LOC_LOGI(...) \ -IF_LOC_LOGI { ALOGE("I/" __VA_ARGS__); } \ -else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGI("I/" __VA_ARGS__); } - -#define LOC_LOGD(...) \ -IF_LOC_LOGD { ALOGE("D/" __VA_ARGS__); } \ -else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGD("D/" __VA_ARGS__); } - -#define LOC_LOGV(...) \ -IF_LOC_LOGV { ALOGE("V/" __VA_ARGS__); } \ -else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/" __VA_ARGS__); } +#define LOC_LOGE(...) IF_LOC_LOGE { ALOGE(__VA_ARGS__); } +#define LOC_LOGW(...) IF_LOC_LOGW { ALOGW(__VA_ARGS__); } +#define LOC_LOGI(...) IF_LOC_LOGI { ALOGI(__VA_ARGS__); } +#define LOC_LOGD(...) IF_LOC_LOGD { ALOGD(__VA_ARGS__); } +#define LOC_LOGV(...) IF_LOC_LOGV { ALOGV(__VA_ARGS__); } #else /* DEBUG_DMN_LOC_API */ -#define LOC_LOGE(...) ALOGE("E/" __VA_ARGS__) - -#define LOC_LOGW(...) ALOGW("W/" __VA_ARGS__) - -#define LOC_LOGI(...) ALOGI("I/" __VA_ARGS__) - -#define LOC_LOGD(...) ALOGD("D/" __VA_ARGS__) - -#define LOC_LOGV(...) ALOGV("V/" __VA_ARGS__) +#define LOC_LOGE(...) ALOGE(__VA_ARGS__) +#define LOC_LOGW(...) ALOGW(__VA_ARGS__) +#define LOC_LOGI(...) ALOGI(__VA_ARGS__) +#define LOC_LOGD(...) ALOGD(__VA_ARGS__) +#define LOC_LOGV(...) ALOGV(__VA_ARGS__) #endif /* DEBUG_DMN_LOC_API */ @@ -158,32 +136,32 @@ else if (loc_logger.DEBUG_LEVEL == 0xff) { ALOGV("V/" __VA_ARGS__); } } \ } while(0) -#define LOC_LOG_HEAD(tag,fmt) "%s:%d][" tag "] " fmt "\n" -#define LOC_LOGv(tag,fmt,...) LOC_LOGV(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) -#define LOC_LOGw(tag,fmt,...) LOC_LOGW(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) -#define LOC_LOGd(tag,fmt,...) LOC_LOGD(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) -#define LOC_LOGe(tag,fmt,...) LOC_LOGE(LOC_LOG_HEAD(tag,fmt), __func__, __LINE__, ##__VA_ARGS__) +#define LOC_LOG_HEAD(fmt) "%s:%d] " fmt +#define LOC_LOGv(fmt,...) LOC_LOGV(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define LOC_LOGw(fmt,...) LOC_LOGW(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define LOC_LOGd(fmt,...) LOC_LOGD(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__) +#define LOC_LOGe(fmt,...) LOC_LOGE(LOC_LOG_HEAD(fmt), __FUNCTION__, __LINE__, ##__VA_ARGS__) #define LOG_I(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGI, ID, WHAT, SPEC, VAL) #define LOG_V(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGV, ID, WHAT, SPEC, VAL) #define LOG_E(ID, WHAT, SPEC, VAL) LOG_(LOC_LOGE, ID, WHAT, SPEC, VAL) -#define ENTRY_LOG() LOG_V(ENTRY_TAG, __func__, %s, "") -#define EXIT_LOG(SPEC, VAL) LOG_V(EXIT_TAG, __func__, SPEC, VAL) +#define ENTRY_LOG() LOG_V(ENTRY_TAG, __FUNCTION__, %s, "") +#define EXIT_LOG(SPEC, VAL) LOG_V(EXIT_TAG, __FUNCTION__, SPEC, VAL) #define EXIT_LOG_WITH_ERROR(SPEC, VAL) \ if (VAL != 0) { \ - LOG_E(EXIT_ERROR_TAG, __func__, SPEC, VAL); \ + LOG_E(EXIT_ERROR_TAG, __FUNCTION__, SPEC, VAL); \ } else { \ - LOG_V(EXIT_TAG, __func__, SPEC, VAL); \ + LOG_V(EXIT_TAG, __FUNCTION__, SPEC, VAL); \ } // Used for logging callflow from Android Framework -#define ENTRY_LOG_CALLFLOW() LOG_I(FROM_AFW, __func__, %s, "") +#define ENTRY_LOG_CALLFLOW() LOG_I(FROM_AFW, __FUNCTION__, %s, "") // Used for logging callflow to Modem -#define EXIT_LOG_CALLFLOW(SPEC, VAL) LOG_I(TO_MODEM, __func__, SPEC, VAL) -// Used for logging callflow from Modem(TO_MODEM, __func__, %s, "") -#define MODEM_LOG_CALLFLOW(SPEC, VAL) LOG_I(FROM_MODEM, __func__, SPEC, VAL) +#define EXIT_LOG_CALLFLOW(SPEC, VAL) LOG_I(TO_MODEM, __FUNCTION__, SPEC, VAL) +// Used for logging callflow from Modem(TO_MODEM, __FUNCTION__, %s, "") +#define MODEM_LOG_CALLFLOW(SPEC, VAL) LOG_I(FROM_MODEM, __FUNCTION__, SPEC, VAL) // Used for logging callflow to Android Framework #define CALLBACK_LOG_CALLFLOW(CB, SPEC, VAL) LOG_I(TO_AFW, CB, SPEC, VAL) diff --git a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_macros.h b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_macros.h index c712122..d0795eb 100644 --- a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_macros.h +++ b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_macros.h @@ -66,6 +66,18 @@ extern "C" { #endif /* USE_GLIB */ + +// Below are the location conf file paths +extern const char LOC_PATH_GPS_CONF[]; +extern const char LOC_PATH_IZAT_CONF[]; +extern const char LOC_PATH_FLP_CONF[]; +extern const char LOC_PATH_LOWI_CONF[]; +extern const char LOC_PATH_SAP_CONF[]; +extern const char LOC_PATH_APDR_CONF[]; +extern const char LOC_PATH_XTWIFI_CONF[]; +extern const char LOC_PATH_QUIPC_CONF[]; + + #ifdef __cplusplus } #endif /*__cplusplus */ diff --git a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_time.h b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_time.h index 2905a74..ae25ae6 100644 --- a/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_time.h +++ b/gps/utils/platform_lib_abstractions/loc_pla/include/platform_lib_time.h @@ -31,5 +31,6 @@ #include int64_t platform_lib_abstraction_elapsed_millis_since_boot(); +int64_t platform_lib_abstraction_elapsed_micros_since_boot(); #endif /* __PLATFORM_LIB_TIME_H__ */ diff --git a/gps/utils/platform_lib_abstractions/loc_pla/loc-pla.pc.in b/gps/utils/platform_lib_abstractions/loc_pla/loc-pla.pc.in new file mode 100644 index 0000000..1aad2f4 --- /dev/null +++ b/gps/utils/platform_lib_abstractions/loc_pla/loc-pla.pc.in @@ -0,0 +1,10 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: loc-pla +Description: QTI GPS Location Platform Library Abstractions +Version: @VERSION@ +Libs: -L${libdir} -lloc_pla +Cflags: -I${includedir}/loc-pla diff --git a/gps/utils/platform_lib_abstractions/loc_pla/src/Android.mk b/gps/utils/platform_lib_abstractions/loc_pla/src/Android.mk index 1c15d56..ab13717 100644 --- a/gps/utils/platform_lib_abstractions/loc_pla/src/Android.mk +++ b/gps/utils/platform_lib_abstractions/loc_pla/src/Android.mk @@ -1,3 +1,22 @@ +GNSS_CFLAGS := \ + -Werror \ + -Wno-error=unused-parameter \ + -Wno-error=format \ + -Wno-error=macro-redefined \ + -Wno-error=reorder \ + -Wno-error=missing-braces \ + -Wno-error=self-assign \ + -Wno-error=enum-conversion \ + -Wno-error=logical-op-parentheses \ + -Wno-error=null-arithmetic \ + -Wno-error=null-conversion \ + -Wno-error=parentheses-equality \ + -Wno-error=undefined-bool-conversion \ + -Wno-error=tautological-compare \ + -Wno-error=switch \ + -Wno-error=date-time + +ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) ifneq ($(BUILD_TINY_ANDROID),true) #Compile this library only for builds with the latest modem image @@ -10,11 +29,9 @@ LOCAL_SHARED_LIBRARIES := \ libutils \ libcutils \ liblog \ - libloc_stub \ - libandroid_runtime + libloc_stub LOCAL_SRC_FILES += \ - platform_lib_android_runtime.cpp \ platform_lib_gettid.cpp \ platform_lib_log_util.cpp \ platform_lib_property_service.cpp \ @@ -26,29 +43,26 @@ LOCAL_CFLAGS += \ -D_ANDROID_ \ -std=c++11 - ## Includes LOCAL_C_INCLUDES:= \ - $(LOCAL_PATH)/../include \ - $(TARGET_OUT_HEADERS)/gps.utils \ - $(TARGET_OUT_HEADERS)/libloc_stub - -LOCAL_COPY_HEADERS_TO:= libloc_pla/ -LOCAL_COPY_HEADERS:= \ - ../include/platform_lib_android_runtime.h \ - ../include/platform_lib_gettid.h \ - ../include/platform_lib_includes.h \ - ../include/platform_lib_log_util.h \ - ../include/platform_lib_macros.h \ - ../include/platform_lib_property_service.h \ - ../include/platform_lib_sched_policy.h \ - ../include/platform_lib_time.h + $(LOCAL_PATH)/../include +LOCAL_HEADER_LIBRARIES := \ + libgps.utils_headers \ + libloc_stub_headers LOCAL_MODULE := libloc_pla - +LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib +LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64 LOCAL_MODULE_TAGS := optional LOCAL_PRELINK_MODULE := false - +LOCAL_CFLAGS += $(GNSS_CFLAGS) include $(BUILD_SHARED_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_MODULE := libloc_pla_headers +LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../include +include $(BUILD_HEADER_LIBRARY) + endif # not BUILD_TINY_ANDROID +endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE diff --git a/gps/utils/platform_lib_abstractions/loc_pla/src/Makefile.am b/gps/utils/platform_lib_abstractions/loc_pla/src/Makefile.am new file mode 100644 index 0000000..30c4b4c --- /dev/null +++ b/gps/utils/platform_lib_abstractions/loc_pla/src/Makefile.am @@ -0,0 +1,39 @@ +AM_CFLAGS = \ + $(LOCSTUB_CFLAGS) \ + -I../include \ + -D__func__=__PRETTY_FUNCTION__ \ + -fno-short-enums + +h_sources = \ + ../include/platform_lib_gettid.h \ + ../include/platform_lib_includes.h \ + ../include/platform_lib_log_util.h \ + ../include/platform_lib_macros.h \ + ../include/platform_lib_property_service.h \ + ../include/platform_lib_sched_policy.h \ + ../include/platform_lib_time.h + +library_includedir = $(pkgincludedir) +library_include_HEADERS = $(h_sources) + +libloc_pla_la_SOURCES = \ + platform_lib_gettid.cpp \ + platform_lib_log_util.cpp \ + platform_lib_property_service.cpp \ + platform_lib_sched_policy.cpp \ + platform_lib_time.cpp + +if USE_GLIB +libloc_pla_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ +libloc_pla_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 +libloc_pla_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ +else +libloc_pla_la_CFLAGS = $(AM_CFLAGS) +libloc_pla_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0 +libloc_pla_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) +endif + +libloc_pla_la_LIBADD = -lstdc++ -ldl -llog $(LOCSTUB_LIBS) + +#Create and Install libraries +lib_LTLIBRARIES = libloc_pla.la diff --git a/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_android_runtime.cpp b/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_android_runtime.cpp deleted file mode 100644 index 090af13..0000000 --- a/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_android_runtime.cpp +++ /dev/null @@ -1,40 +0,0 @@ -/* Copyright (c) 2014, 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. - */ - -#include "platform_lib_android_runtime.h" - -#ifdef USE_GLIB -#include -#else -#include -#endif /* USE_GLIB */ - -pthread_t platform_lib_abstraction_createJavaThread(const char* name, void (*start)(void *), void* arg) -{ - return (pthread_t)android::AndroidRuntime::createJavaThread(name, start, arg); -} diff --git a/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_gettid.cpp b/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_gettid.cpp index 8686327..1b7aa32 100644 --- a/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_gettid.cpp +++ b/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_gettid.cpp @@ -30,6 +30,12 @@ #ifdef USE_GLIB #include + +#include +const char* getprogname() { + return program_invocation_short_name; +} + #else #include #endif /* USE_GLIB */ diff --git a/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_log_util.cpp b/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_log_util.cpp index ef23201..3cb51a3 100644 --- a/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_log_util.cpp +++ b/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_log_util.cpp @@ -26,6 +26,7 @@ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "platform_lib_log_util.h" +#include "platform_lib_macros.h" char * get_timestamp(char *str, unsigned long buf_size) { @@ -40,3 +41,38 @@ char * get_timestamp(char *str, unsigned long buf_size) return str; } +// Below are the location conf file paths +#ifdef __ANDROID__ + +#define LOC_PATH_GPS_CONF_STR "/vendor/etc/gps.conf" +#define LOC_PATH_IZAT_CONF_STR "/vendor/etc/izat.conf" +#define LOC_PATH_FLP_CONF_STR "/vendor/etc/flp.conf" +#define LOC_PATH_LOWI_CONF_STR "/vendor/etc/lowi.conf" +#define LOC_PATH_SAP_CONF_STR "/vendor/etc/sap.conf" +#define LOC_PATH_APDR_CONF_STR "/vendor/etc/apdr.conf" +#define LOC_PATH_XTWIFI_CONF_STR "/vendor/etc/xtwifi.conf" +#define LOC_PATH_QUIPC_CONF_STR "/vendor/etc/quipc.conf" + +#else + +#define LOC_PATH_GPS_CONF_STR "/etc/gps.conf" +#define LOC_PATH_IZAT_CONF_STR "/etc/izat.conf" +#define LOC_PATH_FLP_CONF_STR "/etc/flp.conf" +#define LOC_PATH_LOWI_CONF_STR "/etc/lowi.conf" +#define LOC_PATH_SAP_CONF_STR "/etc/sap.conf" +#define LOC_PATH_APDR_CONF_STR "/etc/apdr.conf" +#define LOC_PATH_XTWIFI_CONF_STR "/etc/xtwifi.conf" +#define LOC_PATH_QUIPC_CONF_STR "/etc/quipc.conf" + +#endif // __ANDROID__ + +// Reference below arrays wherever needed to avoid duplicating +// same conf path string over and again in location code. +const char LOC_PATH_GPS_CONF[] = LOC_PATH_GPS_CONF_STR; +const char LOC_PATH_IZAT_CONF[] = LOC_PATH_IZAT_CONF_STR; +const char LOC_PATH_FLP_CONF[] = LOC_PATH_FLP_CONF_STR; +const char LOC_PATH_LOWI_CONF[] = LOC_PATH_LOWI_CONF_STR; +const char LOC_PATH_SAP_CONF[] = LOC_PATH_SAP_CONF_STR; +const char LOC_PATH_APDR_CONF[] = LOC_PATH_APDR_CONF_STR; +const char LOC_PATH_XTWIFI_CONF[] = LOC_PATH_XTWIFI_CONF_STR; +const char LOC_PATH_QUIPC_CONF[] = LOC_PATH_QUIPC_CONF_STR; diff --git a/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_property_service.cpp b/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_property_service.cpp index 1cc63ab..dccdebc 100644 --- a/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_property_service.cpp +++ b/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_property_service.cpp @@ -25,14 +25,14 @@ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "platform_lib_property_service.h" - #ifdef USE_GLIB #include #else #include #endif /* USE_GLIB */ +#include "platform_lib_property_service.h" + int platform_lib_abstraction_property_get(const char *key, char *value, const char *default_value) { return property_get(key, value, default_value); diff --git a/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_time.cpp b/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_time.cpp index dc7dff1..3dcd4d3 100644 --- a/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_time.cpp +++ b/gps/utils/platform_lib_abstractions/loc_pla/src/platform_lib_time.cpp @@ -31,6 +31,8 @@ #include #else #include +#include + #endif /* USE_GLIB */ int64_t platform_lib_abstraction_elapsed_millis_since_boot() @@ -41,7 +43,17 @@ int64_t platform_lib_abstraction_elapsed_millis_since_boot() #else - return android::elapsedRealtime(); - + //return android::nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME))/1000; + return nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME))/1000; +#endif +} +int64_t platform_lib_abstraction_elapsed_micros_since_boot() +{ +#ifdef USE_GLIB + return elapsedMicrosSinceBoot(); + +#else + //return android::nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME)); + return nanoseconds_to_microseconds(systemTime(SYSTEM_TIME_BOOTTIME)); #endif } diff --git a/gps/utils/platform_lib_abstractions/loc_stub/Makefile.am b/gps/utils/platform_lib_abstractions/loc_stub/Makefile.am new file mode 100644 index 0000000..d81e363 --- /dev/null +++ b/gps/utils/platform_lib_abstractions/loc_stub/Makefile.am @@ -0,0 +1,9 @@ +# Makefile.am for gps loc-stub + +ACLOCAL_AMFLAGS = -I m4 + +SUBDIRS = src + +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = loc-stub.pc +EXTRA_DIST = $(pkgconfig_DATA) diff --git a/gps/utils/platform_lib_abstractions/loc_stub/configure.ac b/gps/utils/platform_lib_abstractions/loc_stub/configure.ac new file mode 100644 index 0000000..8900f04 --- /dev/null +++ b/gps/utils/platform_lib_abstractions/loc_stub/configure.ac @@ -0,0 +1,67 @@ +# configure.ac -- Autoconf script for gps loc-stub +# +# Process this file with autoconf to produce a configure script + +# Requires autoconf tool later than 2.61 +AC_PREREQ(2.61) +# Initialize the gps loc-stub package version 1.0.0 +AC_INIT([loc-stub],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([Makefile.am]) +# 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. +AC_ARG_WITH([hardware_include], + AC_HELP_STRING([--with-hardware-include=@<:@dir@:>@], + [Specify the location of the hardware headers]), + [hardware_incdir=$withval], + with_hardware_include=no) + +if test "x$with_hardware_include" != "xno"; then + CPPFLAGS="${CPPFLAGS} -I${hardware_incdir}" +fi + +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 \ + src/Makefile \ + loc-stub.pc + ]) + +AC_OUTPUT diff --git a/gps/utils/platform_lib_abstractions/loc_stub/include/loc_stub_time.h b/gps/utils/platform_lib_abstractions/loc_stub/include/loc_stub_time.h index 271e2ff..f00a49b 100644 --- a/gps/utils/platform_lib_abstractions/loc_stub/include/loc_stub_time.h +++ b/gps/utils/platform_lib_abstractions/loc_stub/include/loc_stub_time.h @@ -37,6 +37,7 @@ extern "C" { int64_t systemTime(int clock); int64_t elapsedMillisSinceBoot(); +int64_t elapsedMicrosSinceBoot(); #ifdef __cplusplus } diff --git a/gps/utils/platform_lib_abstractions/loc_stub/loc-stub.pc.in b/gps/utils/platform_lib_abstractions/loc_stub/loc-stub.pc.in new file mode 100644 index 0000000..c2ae764 --- /dev/null +++ b/gps/utils/platform_lib_abstractions/loc_stub/loc-stub.pc.in @@ -0,0 +1,10 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: loc-stub +Description: QTI GPS Location Stub +Version: @VERSION +Libs: -L${libdir} -lloc_stub +Cflags: -I${includedir}/loc-stub diff --git a/gps/utils/platform_lib_abstractions/loc_stub/src/Android.mk b/gps/utils/platform_lib_abstractions/loc_stub/src/Android.mk index 65fe021..08697cb 100644 --- a/gps/utils/platform_lib_abstractions/loc_stub/src/Android.mk +++ b/gps/utils/platform_lib_abstractions/loc_stub/src/Android.mk @@ -1,3 +1,4 @@ +ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),) ifneq ($(BUILD_TINY_ANDROID),true) #Compile this library only for builds with the latest modem image @@ -30,20 +31,19 @@ LOCAL_LDFLAGS += -Wl,--export-dynamic LOCAL_C_INCLUDES:= \ $(LOCAL_PATH)/../include \ - -LOCAL_COPY_HEADERS_TO:= libloc_stub/ -LOCAL_COPY_HEADERS:= \ - ../include/loc_stub_android_runtime.h \ - ../include/loc_stub_gettid.h \ - ../include/loc_stub_property_service.h \ - ../include/loc_stub_sched_policy.h \ - ../include/loc_stub_time.h - LOCAL_MODULE := libloc_stub - +LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib +LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64 LOCAL_MODULE_TAGS := optional LOCAL_PRELINK_MODULE := false - +LOCAL_CFLAGS += $(GNSS_CFLAGS) include $(BUILD_SHARED_LIBRARY) + +include $(CLEAR_VARS) +LOCAL_MODULE := libloc_stub_headers +LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../include +include $(BUILD_HEADER_LIBRARY) + endif # not BUILD_TINY_ANDROID +endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE diff --git a/gps/utils/platform_lib_abstractions/loc_stub/src/Makefile.am b/gps/utils/platform_lib_abstractions/loc_stub/src/Makefile.am new file mode 100644 index 0000000..ba823a2 --- /dev/null +++ b/gps/utils/platform_lib_abstractions/loc_stub/src/Makefile.am @@ -0,0 +1,40 @@ +AM_CFLAGS = \ + -I../include \ + -D__func__=__PRETTY_FUNCTION__ \ + -fno-short-enums + +libloc_stub_la_extra_h = \ + ../include/utils/Log.h + +libloc_stub_la_c_sources = \ + loc_stub_android_runtime.cpp \ + loc_stub_gettid.cpp \ + loc_stub_property_service.cpp \ + loc_stub_sched_policy.cpp \ + loc_stub_time.cpp + +libloc_stub_la_SOURCES = $(libloc_stub_la_c_sources) $(libloc_stub_la_extra_h) + +library_include_HEADERS = \ + ../include/loc_stub_android_runtime.h \ + ../include/loc_stub_gettid.h \ + ../include/loc_stub_property_service.h \ + ../include/loc_stub_sched_policy.h \ + ../include/loc_stub_time.h + +library_includedir = $(pkgincludedir) + +if USE_GLIB +libloc_stub_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@ +libloc_stub_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0 +libloc_stub_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@ +else +libloc_stub_la_CFLAGS = $(AM_CFLAGS) +libloc_stub_la_LDFLAGS = -Wl,-z,defs -lpthread -shared -version-info 1:0:0 +libloc_stub_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) +endif + +libloc_stub_la_LIBADD = -lstdc++ -ldl -llog + +#Create and Install libraries +lib_LTLIBRARIES = libloc_stub.la diff --git a/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_android_runtime.cpp b/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_android_runtime.cpp index 1db69b2..068df4e 100644 --- a/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_android_runtime.cpp +++ b/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_android_runtime.cpp @@ -30,7 +30,7 @@ namespace android { -pthread_t AndroidRuntime::createJavaThread(const char* name, +pthread_t AndroidRuntime::createJavaThread(const char* /*name*/, void (*start)(void *), void* arg) { pthread_t threadId = 0; diff --git a/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_property_service.cpp b/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_property_service.cpp index f9d9e3e..907ab02 100644 --- a/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_property_service.cpp +++ b/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_property_service.cpp @@ -30,7 +30,7 @@ #include #include -int property_get(const char *key, char * value, const char *default_value) +int property_get(const char *key, char * value, const char */*default_value*/) { /* This will disable gps interface value[0] = '1'; diff --git a/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_sched_policy.cpp b/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_sched_policy.cpp index 781be29..5e26245 100644 --- a/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_sched_policy.cpp +++ b/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_sched_policy.cpp @@ -44,7 +44,7 @@ SIDE EFFECTS N/A ===========================================================================*/ -int set_sched_policy(int tid, SchedPolicy policy) +int set_sched_policy(int /*tid*/, SchedPolicy /*policy*/) { return 0; } diff --git a/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_time.cpp b/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_time.cpp index 82dc593..48149a6 100644 --- a/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_time.cpp +++ b/gps/utils/platform_lib_abstractions/loc_stub/src/loc_stub_time.cpp @@ -29,8 +29,9 @@ #include "loc_stub_time.h" #include #include +#include -int64_t systemTime(int clock) +int64_t systemTime(int /*clock*/) { struct timeval t; t.tv_sec = t.tv_usec = 0; @@ -38,9 +39,17 @@ int64_t systemTime(int clock) return t.tv_sec*1000000LL + t.tv_usec; } +int64_t elapsedMicrosSinceBoot() +{ + struct timespec ts; + int64_t time_ms = 0; + clock_gettime(CLOCK_BOOTTIME, &ts); + time_ms += (ts.tv_sec * 1000000000LL); /* Seconds to nanoseconds */ + time_ms += ts.tv_nsec; /* Add Nanoseconds */ + return time_ms; +} int64_t elapsedMillisSinceBoot() { - int64_t t_us = systemTime(0); - return (int64_t) t_us / 1000LL; + return (int64_t) (elapsedMicrosSinceBoot() /1000000LL); }