sm8250-common: import gps from LA.UM.9.12.r1-13500.01-SMxx50.QSSI12.0

Change-Id: Ib5a80c095e5e203f90cc0d685758553fd18a7f0c

gps/core/Android.bp

@@ -0,0 +1,56 @@
+
+cc_library_shared {
+
+    name: "libloc_core",
+    vendor: true,
+
+
+
+    shared_libs: [
+        "liblog",
+        "libutils",
+        "libcutils",
+        "libgps.utils",
+        "libdl",
+        "liblog",
+    ],
+
+    srcs: [
+        "LocApiBase.cpp",
+        "LocAdapterBase.cpp",
+        "ContextBase.cpp",
+        "LocContext.cpp",
+        "loc_core_log.cpp",
+        "data-items/DataItemsFactoryProxy.cpp",
+        "SystemStatusOsObserver.cpp",
+        "SystemStatus.cpp",
+    ],
+
+    cflags: [
+        "-fno-short-enums",
+        "-D_ANDROID_",
+    ] + GNSS_CFLAGS,
+
+    local_include_dirs: [
+        "data-items",
+        "observer",
+    ],
+
+    header_libs: [
+        "libutils_headers",
+        "libgps.utils_headers",
+        "libloc_pla_headers",
+        "liblocation_api_headers",
+    ],
+
+}
+
+cc_library_headers {
+
+    name: "libloc_core_headers",
+    vendor: true,
+    export_include_dirs: ["."] + [
+        "data-items",
+        "observer",
+    ],
+}

gps/core/ContextBase.cpp

@@ -0,0 +1,384 @@
+/* Copyright (c) 2011-2014,2016-2017,2020 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_CtxBase"
+
+#include <dlfcn.h>
+#include <unistd.h>
+#include <ContextBase.h>
+#include <msg_q.h>
+#include <loc_target.h>
+#include <loc_pla.h>
+#include <loc_log.h>
+
+namespace loc_core {
+
+#define SLL_LOC_API_LIB_NAME "libsynergy_loc_api.so"
+#define LOC_APIV2_0_LIB_NAME "libloc_api_v02.so"
+#define IS_SS5_HW_ENABLED  1
+
+loc_gps_cfg_s_type ContextBase::mGps_conf {};
+loc_sap_cfg_s_type ContextBase::mSap_conf {};
+bool ContextBase::sIsEngineCapabilitiesKnown = false;
+uint64_t ContextBase::sSupportedMsgMask = 0;
+bool ContextBase::sGnssMeasurementSupported = false;
+uint8_t ContextBase::sFeaturesSupported[MAX_FEATURE_LENGTH];
+GnssNMEARptRate ContextBase::sNmeaReportRate = GNSS_NMEA_REPORT_RATE_NHZ;
+LocationCapabilitiesMask ContextBase::sQwesFeatureMask = 0;
+
+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'},
+  {"NMEA_REPORT_RATE",               &mGps_conf.NMEA_REPORT_RATE,               NULL, 's'},
+  {"CAPABILITIES",                   &mGps_conf.CAPABILITIES,                   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'},
+  {"SUPL_HOST",                      &mGps_conf.SUPL_HOST,                      NULL, 's'},
+  {"SUPL_PORT",                      &mGps_conf.SUPL_PORT,                      NULL, 'n'},
+  {"MODEM_TYPE",                     &mGps_conf.MODEM_TYPE,                     NULL, 'n' },
+  {"MO_SUPL_HOST",                   &mGps_conf.MO_SUPL_HOST,                   NULL, 's' },
+  {"MO_SUPL_PORT",                   &mGps_conf.MO_SUPL_PORT,                   NULL, 'n' },
+  {"CONSTRAINED_TIME_UNCERTAINTY_ENABLED",
+           &mGps_conf.CONSTRAINED_TIME_UNCERTAINTY_ENABLED,      NULL, 'n'},
+  {"CONSTRAINED_TIME_UNCERTAINTY_THRESHOLD",
+           &mGps_conf.CONSTRAINED_TIME_UNCERTAINTY_THRESHOLD,    NULL, 'f'},
+  {"CONSTRAINED_TIME_UNCERTAINTY_ENERGY_BUDGET",
+           &mGps_conf.CONSTRAINED_TIME_UNCERTAINTY_ENERGY_BUDGET, NULL, 'n'},
+  {"POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED",
+           &mGps_conf.POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED, NULL, 'n'},
+  {"PROXY_APP_PACKAGE_NAME",         &mGps_conf.PROXY_APP_PACKAGE_NAME,         NULL, 's' },
+  {"CP_MTLR_ES",                     &mGps_conf.CP_MTLR_ES,                     NULL, 'n' },
+  {"GNSS_DEPLOYMENT",  &mGps_conf.GNSS_DEPLOYMENT, NULL, 'n'},
+  {"CUSTOM_NMEA_GGA_FIX_QUALITY_ENABLED",
+           &mGps_conf.CUSTOM_NMEA_GGA_FIX_QUALITY_ENABLED, NULL, 'n'},
+  {"NMEA_TAG_BLOCK_GROUPING_ENABLED", &mGps_conf.NMEA_TAG_BLOCK_GROUPING_ENABLED, NULL, 'n'},
+  {"NI_SUPL_DENY_ON_NFW_LOCKED",  &mGps_conf.NI_SUPL_DENY_ON_NFW_LOCKED, NULL, 'n'},
+  {"ENABLE_NMEA_PRINT",  &mGps_conf.ENABLE_NMEA_PRINT, 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_ALGORITHM_CONFIG_MASK",   &mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK,   NULL, 'n'}
+};
+
+void ContextBase::readConfig()
+{
+    static bool confReadDone = false;
+    if (!confReadDone) {
+        confReadDone = true;
+        /*Defaults for gps.conf*/
+        mGps_conf.INTERMEDIATE_POS = 0;
+        mGps_conf.ACCURACY_THRES = 0;
+        mGps_conf.NMEA_PROVIDER = 0;
+        mGps_conf.GPS_LOCK = GNSS_CONFIG_GPS_LOCK_MO_AND_NI;
+        mGps_conf.SUPL_VER = 0x10000;
+        mGps_conf.SUPL_MODE = 0x1;
+        mGps_conf.SUPL_ES = 0;
+        mGps_conf.CP_MTLR_ES = 0;
+        mGps_conf.SUPL_HOST[0] = 0;
+        mGps_conf.SUPL_PORT = 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;
+        /*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;
+        /* By default we use unknown modem type*/
+        mGps_conf.MODEM_TYPE = 2;
+
+        /*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_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;
+
+        /* 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;
+
+        /* default configuration value of constrained time uncertainty mode:
+           feature disabled, time uncertainty threshold defined by modem,
+           and unlimited power budget */
+#ifdef FEATURE_AUTOMOTIVE
+        mGps_conf.CONSTRAINED_TIME_UNCERTAINTY_ENABLED = 1;
+#else
+        mGps_conf.CONSTRAINED_TIME_UNCERTAINTY_ENABLED = 0;
+#endif
+        mGps_conf.CONSTRAINED_TIME_UNCERTAINTY_THRESHOLD = 0.0;
+        mGps_conf.CONSTRAINED_TIME_UNCERTAINTY_ENERGY_BUDGET = 0;
+
+        /* default configuration value of position assisted clock estimator mode */
+        mGps_conf.POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED = 0;
+        /* default configuration QTI GNSS H/W */
+        mGps_conf.GNSS_DEPLOYMENT = 0;
+        mGps_conf.CUSTOM_NMEA_GGA_FIX_QUALITY_ENABLED = 0;
+        /* default NMEA Tag Block Grouping is disabled */
+        mGps_conf.NMEA_TAG_BLOCK_GROUPING_ENABLED = 0;
+        /* default configuration for NI_SUPL_DENY_ON_NFW_LOCKED */
+        mGps_conf.NI_SUPL_DENY_ON_NFW_LOCKED = 1;
+        /* By default NMEA Printing is disabled */
+        mGps_conf.ENABLE_NMEA_PRINT = 0;
+
+        UTIL_READ_CONF(LOC_PATH_GPS_CONF, mGps_conf_table);
+        UTIL_READ_CONF(LOC_PATH_SAP_CONF, mSap_conf_table);
+
+        if (strncmp(mGps_conf.NMEA_REPORT_RATE, "1HZ", sizeof(mGps_conf.NMEA_REPORT_RATE)) == 0) {
+            /* NMEA reporting is configured at 1Hz*/
+            sNmeaReportRate = GNSS_NMEA_REPORT_RATE_1HZ;
+        } else {
+            sNmeaReportRate = GNSS_NMEA_REPORT_RATE_NHZ;
+        }
+        LOC_LOGI("%s] GNSS Deployment: %s", __FUNCTION__,
+                ((mGps_conf.GNSS_DEPLOYMENT == 1) ? "SS5" :
+                ((mGps_conf.GNSS_DEPLOYMENT == 2) ? "QFUSION" : "QGNSS")));
+
+        switch (getTargetGnssType(loc_get_target())) {
+          case GNSS_GSS:
+          case GNSS_AUTO:
+             // For APQ targets, MSA/MSB capabilities should be reset
+             mGps_conf.CAPABILITIES &= ~(LOC_GPS_CAPABILITY_MSA | LOC_GPS_CAPABILITY_MSB);
+             break;
+          default:
+             break;
+        }
+    }
+}
+
+uint32_t ContextBase::getCarrierCapabilities() {
+    #define carrierMSA (uint32_t)0x2
+    #define carrierMSB (uint32_t)0x1
+    #define gpsConfMSA (uint32_t)0x4
+    #define gpsConfMSB (uint32_t)0x2
+    uint32_t capabilities = mGps_conf.CAPABILITIES;
+    if ((mGps_conf.SUPL_MODE & carrierMSA) != carrierMSA) {
+        capabilities &= ~gpsConfMSA;
+    }
+    if ((mGps_conf.SUPL_MODE & carrierMSB) != carrierMSB) {
+        capabilities &= ~gpsConfMSB;
+    }
+
+    LOC_LOGV("getCarrierCapabilities: CAPABILITIES %x, SUPL_MODE %x, carrier capabilities %x",
+             mGps_conf.CAPABILITIES, mGps_conf.SUPL_MODE, capabilities);
+    return capabilities;
+}
+
+LBSProxyBase* ContextBase::getLBSProxy(const char* libName)
+{
+    LBSProxyBase* proxy = NULL;
+    LOC_LOGD("%s:%d]: getLBSProxy libname: %s\n", __func__, __LINE__, libName);
+    void* lib = dlopen(libName, RTLD_NOW);
+
+    if ((void*)NULL != lib) {
+        getLBSProxy_t* getter = (getLBSProxy_t*)dlsym(lib, "getLBSProxy");
+        if (NULL != getter) {
+            proxy = (*getter)();
+        }
+    }
+    else
+    {
+        LOC_LOGW("%s:%d]: FAILED TO LOAD libname: %s\n", __func__, __LINE__, libName);
+    }
+    if (NULL == proxy) {
+        proxy = new LBSProxyBase();
+    }
+    LOC_LOGD("%s:%d]: Exiting\n", __func__, __LINE__);
+    return proxy;
+}
+
+LocApiBase* ContextBase::createLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask)
+{
+    LocApiBase* locApi = NULL;
+    const char* libname = LOC_APIV2_0_LIB_NAME;
+
+    // Check the target
+    if (TARGET_NO_GNSS != loc_get_target()){
+
+        if (NULL == (locApi = mLBSProxy->getLocApi(exMask, this))) {
+            void *handle = NULL;
+
+            if (IS_SS5_HW_ENABLED == mGps_conf.GNSS_DEPLOYMENT) {
+                libname = SLL_LOC_API_LIB_NAME;
+            }
+
+            if ((handle = dlopen(libname, RTLD_NOW)) != NULL) {
+                LOC_LOGD("%s:%d]: %s is present", __func__, __LINE__, libname);
+                getLocApi_t* getter = (getLocApi_t*) dlsym(handle, "getLocApi");
+                if (getter != NULL) {
+                    LOC_LOGD("%s:%d]: getter is not NULL of %s", __func__,
+                            __LINE__, libname);
+                    locApi = (*getter)(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)(exMask, this);
+                    }
+                }
+            }
+        }
+    }
+
+    // locApi could still be NULL at this time
+    // we would then create a dummy one
+    if (NULL == locApi) {
+        locApi = new LocApiBase(exMask, this);
+    }
+
+    return locApi;
+}
+
+ContextBase::ContextBase(const MsgTask* msgTask,
+                         LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                         const char* libName) :
+    mLBSProxy(getLBSProxy(libName)),
+    mMsgTask(msgTask),
+    mLocApi(createLocApi(exMask)),
+    mLocApiProxy(mLocApi->getLocApiProxy())
+{
+}
+
+void ContextBase::setEngineCapabilities(uint64_t supportedMsgMask,
+       uint8_t *featureList, bool gnssMeasurementSupported) {
+
+    if (ContextBase::sIsEngineCapabilitiesKnown == false) {
+        ContextBase::sSupportedMsgMask = supportedMsgMask;
+        ContextBase::sGnssMeasurementSupported = gnssMeasurementSupported;
+        if (featureList != NULL) {
+            memcpy((void *)ContextBase::sFeaturesSupported,
+                    (void *)featureList, sizeof(ContextBase::sFeaturesSupported));
+        }
+
+        /* */
+        if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_MEASUREMENTS_CORRECTION)) {
+            static uint8_t isSapModeKnown = 0;
+
+            if (!isSapModeKnown) {
+                /* Check if SAP is PREMIUM_ENV_AIDING in izat.conf */
+                char conf_feature_sap[LOC_MAX_PARAM_STRING];
+                loc_param_s_type izat_conf_feature_table[] =
+                {
+                    { "SAP",           &conf_feature_sap,           &isSapModeKnown, 's' }
+                };
+                UTIL_READ_CONF(LOC_PATH_IZAT_CONF, izat_conf_feature_table);
+
+                /* Disable this feature if SAP is not PREMIUM_ENV_AIDING in izat.conf */
+                if (strcmp(conf_feature_sap, "PREMIUM_ENV_AIDING") != 0) {
+                    uint8_t arrayIndex = LOC_SUPPORTED_FEATURE_MEASUREMENTS_CORRECTION >> 3;
+                    uint8_t bitPos = LOC_SUPPORTED_FEATURE_MEASUREMENTS_CORRECTION & 7;
+
+                    if (arrayIndex < MAX_FEATURE_LENGTH) {
+                        /* To disable the feature we need to reset the bit on the "bitPos"
+                           position, so shift a "1" to the left by "bitPos" */
+                        ContextBase::sFeaturesSupported[arrayIndex] &= ~(1 << bitPos);
+                    }
+                }
+            }
+        }
+        ContextBase::sIsEngineCapabilitiesKnown = true;
+    }
+}
+
+
+bool ContextBase::isFeatureSupported(uint8_t featureVal)
+{
+    uint8_t arrayIndex = featureVal >> 3;
+    uint8_t bitPos = featureVal & 7;
+
+    if (arrayIndex >= MAX_FEATURE_LENGTH) return false;
+    return ((ContextBase::sFeaturesSupported[arrayIndex] >> bitPos ) & 0x1);
+}
+
+bool ContextBase::gnssConstellationConfig() {
+    return sGnssMeasurementSupported;
+}
+
+}

gps/core/ContextBase.h

@@ -0,0 +1,385 @@
+/* Copyright (c) 2011-2017, 2020, 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_CONTEXT_BASE__
+#define __LOC_CONTEXT_BASE__
+
+#include <stdbool.h>
+#include <ctype.h>
+#include <MsgTask.h>
+#include <LocApiBase.h>
+#include <LBSProxyBase.h>
+#include <loc_cfg.h>
+#ifdef NO_UNORDERED_SET_OR_MAP
+    #include <map>
+#else
+    #include <unordered_map>
+#endif
+
+/* GPS.conf support */
+/* NOTE: the implementaiton of the parser casts number
+   fields to 32 bit. To ensure all 'n' fields working,
+   they must all be 32 bit fields. */
+typedef struct loc_gps_cfg_s
+{
+    uint32_t       INTERMEDIATE_POS;
+    uint32_t       ACCURACY_THRES;
+    uint32_t       SUPL_VER;
+    uint32_t       SUPL_MODE;
+    uint32_t       SUPL_ES;
+    uint32_t       CAPABILITIES;
+    uint32_t       LPP_PROFILE;
+    char           XTRA_SERVER_1[LOC_MAX_PARAM_STRING];
+    char           XTRA_SERVER_2[LOC_MAX_PARAM_STRING];
+    char           XTRA_SERVER_3[LOC_MAX_PARAM_STRING];
+    uint32_t       USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL;
+    uint32_t       NMEA_PROVIDER;
+    char           NMEA_REPORT_RATE[LOC_MAX_PARAM_NAME];
+    GnssConfigGpsLock   GPS_LOCK;
+    uint32_t       A_GLONASS_POS_PROTOCOL_SELECT;
+    uint32_t       AGPS_CERT_WRITABLE_MASK;
+    uint32_t       AGPS_CONFIG_INJECT;
+    uint32_t       LPPE_CP_TECHNOLOGY;
+    uint32_t       LPPE_UP_TECHNOLOGY;
+    uint32_t       EXTERNAL_DR_ENABLED;
+    char           SUPL_HOST[LOC_MAX_PARAM_STRING];
+    uint32_t       SUPL_PORT;
+    uint32_t       MODEM_TYPE;
+    char           MO_SUPL_HOST[LOC_MAX_PARAM_STRING];
+    uint32_t       MO_SUPL_PORT;
+    uint32_t       CONSTRAINED_TIME_UNCERTAINTY_ENABLED;
+    double         CONSTRAINED_TIME_UNCERTAINTY_THRESHOLD;
+    uint32_t       CONSTRAINED_TIME_UNCERTAINTY_ENERGY_BUDGET;
+    uint32_t       POSITION_ASSISTED_CLOCK_ESTIMATOR_ENABLED;
+    char           PROXY_APP_PACKAGE_NAME[LOC_MAX_PARAM_STRING];
+    uint32_t       CP_MTLR_ES;
+    uint32_t       GNSS_DEPLOYMENT;
+    uint32_t       CUSTOM_NMEA_GGA_FIX_QUALITY_ENABLED;
+    uint32_t       NI_SUPL_DENY_ON_NFW_LOCKED;
+    uint32_t       ENABLE_NMEA_PRINT;
+    uint32_t       NMEA_TAG_BLOCK_GROUPING_ENABLED;
+} loc_gps_cfg_s_type;
+
+/* NOTE: the implementation of the parser casts number
+   fields to 32 bit. To ensure all 'n' fields working,
+   they must all be 32 bit fields. */
+/* Meanwhile, *_valid fields are 8 bit fields, and 'f'
+   fields are double. Rigid as they are, it is the
+   the status quo, until the parsing mechanism is
+   changed, that is. */
+typedef struct
+{
+    uint8_t        GYRO_BIAS_RANDOM_WALK_VALID;
+    double         GYRO_BIAS_RANDOM_WALK;
+    uint32_t       SENSOR_ACCEL_BATCHES_PER_SEC;
+    uint32_t       SENSOR_ACCEL_SAMPLES_PER_BATCH;
+    uint32_t       SENSOR_GYRO_BATCHES_PER_SEC;
+    uint32_t       SENSOR_GYRO_SAMPLES_PER_BATCH;
+    uint32_t       SENSOR_ACCEL_BATCHES_PER_SEC_HIGH;
+    uint32_t       SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH;
+    uint32_t       SENSOR_GYRO_BATCHES_PER_SEC_HIGH;
+    uint32_t       SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH;
+    uint32_t       SENSOR_CONTROL_MODE;
+    uint32_t       SENSOR_ALGORITHM_CONFIG_MASK;
+    uint8_t        ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
+    double         ACCEL_RANDOM_WALK_SPECTRAL_DENSITY;
+    uint8_t        ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
+    double         ANGLE_RANDOM_WALK_SPECTRAL_DENSITY;
+    uint8_t        RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
+    double         RATE_RANDOM_WALK_SPECTRAL_DENSITY;
+    uint8_t        VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID;
+    double         VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY;
+} loc_sap_cfg_s_type;
+
+using namespace loc_util;
+
+namespace loc_core {
+
+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;
+    LocApiBase* mLocApi;
+    LocApiProxyBase *mLocApiProxy;
+
+public:
+    ContextBase(const MsgTask* msgTask,
+                LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                const char* libName);
+    inline virtual ~ContextBase() {
+        if (nullptr != mLocApi) {
+            mLocApi->destroy();
+            mLocApi = nullptr;
+        }
+        if (nullptr != mLBSProxy) {
+            delete mLBSProxy;
+            mLBSProxy = nullptr;
+        }
+    }
+
+    inline const MsgTask* getMsgTask() { return mMsgTask; }
+    inline LocApiBase* getLocApi() { return mLocApi; }
+    inline LocApiProxyBase* getLocApiProxy() { return mLocApiProxy; }
+    inline bool hasAgpsExtendedCapabilities() { return mLBSProxy->hasAgpsExtendedCapabilities(); }
+    inline bool hasNativeXtraClient() { return mLBSProxy->hasNativeXtraClient(); }
+    inline void modemPowerVote(bool power) const { return mLBSProxy->modemPowerVote(power); }
+    inline IzatDevId_t getIzatDevId() const {
+        return mLBSProxy->getIzatDevId();
+    }
+    inline void sendMsg(const LocMsg *msg) { getMsgTask()->sendMsg(msg); }
+
+    static loc_gps_cfg_s_type mGps_conf;
+    static loc_sap_cfg_s_type mSap_conf;
+    static bool sIsEngineCapabilitiesKnown;
+    static uint64_t sSupportedMsgMask;
+    static uint8_t sFeaturesSupported[MAX_FEATURE_LENGTH];
+    static bool sGnssMeasurementSupported;
+    static GnssNMEARptRate sNmeaReportRate;
+    static LocationCapabilitiesMask sQwesFeatureMask;
+
+    void readConfig();
+    static uint32_t getCarrierCapabilities();
+    void setEngineCapabilities(uint64_t supportedMsgMask,
+            uint8_t *featureList, bool gnssMeasurementSupported);
+
+    static inline bool isEngineCapabilitiesKnown() {
+        return sIsEngineCapabilitiesKnown;
+    }
+
+    static inline bool isMessageSupported(LocCheckingMessagesID msgID) {
+
+        // confirm if msgID is not larger than the number of bits in
+        // mSupportedMsg
+        if ((uint64_t)msgID > (sizeof(sSupportedMsgMask) << 3)) {
+            return false;
+        } else {
+            uint32_t messageChecker = 1 << msgID;
+            return (messageChecker & sSupportedMsgMask) == messageChecker;
+        }
+    }
+
+    /*
+        Check if a feature is supported
+    */
+    static bool isFeatureSupported(uint8_t featureVal);
+
+    /*
+        Check if gnss measurement is supported
+    */
+    static bool gnssConstellationConfig();
+
+    /*
+        set QWES feature status info
+    */
+    static inline void setQwesFeatureStatus(
+            const std::unordered_map<LocationQwesFeatureType, bool> &featureMap) {
+       std::unordered_map<LocationQwesFeatureType, bool>::const_iterator itr;
+       static LocationQwesFeatureType locQwesFeatType[LOCATION_QWES_FEATURE_TYPE_MAX];
+       for (itr = featureMap.begin(); itr != featureMap.end(); ++itr) {
+           LOC_LOGi("Feature : %d isValid: %d", itr->first, itr->second);
+           locQwesFeatType[itr->first] = itr->second;
+           switch (itr->first) {
+               case LOCATION_QWES_FEATURE_TYPE_CARRIER_PHASE:
+                   if (itr->second) {
+                       sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_CARRIER_PHASE_BIT;
+                   } else {
+                       sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_CARRIER_PHASE_BIT;
+                   }
+               break;
+               case LOCATION_QWES_FEATURE_TYPE_SV_POLYNOMIAL:
+                   if (itr->second) {
+                       sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_SV_POLYNOMIAL_BIT;
+                   } else {
+                       sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_SV_POLYNOMIAL_BIT;
+                   }
+               break;
+               case LOCATION_QWES_FEATURE_TYPE_GNSS_SINGLE_FREQUENCY:
+                   if (itr->second) {
+                       sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_GNSS_SINGLE_FREQUENCY;
+                   } else {
+                       sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_GNSS_SINGLE_FREQUENCY;
+                   }
+               break;
+               case LOCATION_QWES_FEATURE_TYPE_SV_EPH:
+                   if (itr->second) {
+                       sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_SV_EPHEMERIS_BIT;
+                   } else {
+                       sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_SV_EPHEMERIS_BIT;
+                   }
+               break;
+               case LOCATION_QWES_FEATURE_TYPE_GNSS_MULTI_FREQUENCY:
+                   if (itr->second) {
+                       sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_GNSS_MULTI_FREQUENCY;
+                   } else {
+                       sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_GNSS_MULTI_FREQUENCY;
+                   }
+               break;
+               case LOCATION_QWES_FEATURE_TYPE_PPE:
+                   if (itr->second) {
+                       sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_PPE;
+                   } else {
+                       sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_PPE;
+                   }
+               break;
+               case LOCATION_QWES_FEATURE_TYPE_QDR2:
+                   if (itr->second) {
+                       sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_QDR2;
+                   } else {
+                       sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_QDR2;
+                   }
+               break;
+               case LOCATION_QWES_FEATURE_TYPE_QDR3:
+                   if (itr->second) {
+                       sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_QDR3;
+                   } else {
+                       sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_QDR3;
+                   }
+               break;
+               case LOCATION_QWES_FEATURE_TYPE_VPE:
+                   if (itr->second) {
+                       sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_VPE;
+                   } else {
+                       sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_VPE;
+                   }
+               break;
+           }
+       }
+
+       // Set CV2X basic when time freq and tunc is set
+       // CV2X_BASIC  = LOCATION_QWES_FEATURE_TYPE_TIME_FREQUENCY &
+       //       LOCATION_QWES_FEATURE_TYPE_TIME_UNCERTAINTY
+
+       // Set CV2X premium when time freq and tunc is set
+       // CV2X_PREMIUM = CV2X_BASIC & LOCATION_QWES_FEATURE_TYPE_QDR3 &
+       //       LOCATION_QWES_FEATURE_TYPE_CLOCK_ESTIMATE
+
+       bool cv2xBasicEnabled = (1 == locQwesFeatType[LOCATION_QWES_FEATURE_TYPE_TIME_FREQUENCY]) &&
+            (1 == locQwesFeatType[LOCATION_QWES_FEATURE_TYPE_TIME_UNCERTAINTY]);
+       bool cv2xPremiumEnabled = cv2xBasicEnabled &&
+            (1 == locQwesFeatType[LOCATION_QWES_FEATURE_TYPE_QDR3]) &&
+            (1 == locQwesFeatType[LOCATION_QWES_FEATURE_TYPE_CLOCK_ESTIMATE]);
+
+       LOC_LOGd("CV2X_BASIC:%d, CV2X_PREMIUM:%d", cv2xBasicEnabled, cv2xPremiumEnabled);
+       if (cv2xBasicEnabled) {
+            sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_CV2X_LOCATION_BASIC;
+       } else {
+            sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_CV2X_LOCATION_BASIC;
+       }
+       if (cv2xPremiumEnabled) {
+            sQwesFeatureMask |= LOCATION_CAPABILITIES_QWES_CV2X_LOCATION_PREMIUM;
+       } else {
+            sQwesFeatureMask &= ~LOCATION_CAPABILITIES_QWES_CV2X_LOCATION_PREMIUM;
+       }
+    }
+
+    /*
+        get QWES feature status info
+    */
+    static inline LocationCapabilitiesMask getQwesFeatureStatus() {
+        return (ContextBase::sQwesFeatureMask);
+    }
+
+
+};
+
+struct LocApiResponse: LocMsg {
+    private:
+        ContextBase& mContext;
+        std::function<void (LocationError err)> mProcImpl;
+        inline virtual void proc() const {
+            mProcImpl(mLocationError);
+        }
+    protected:
+        LocationError mLocationError;
+    public:
+        inline LocApiResponse(ContextBase& context,
+                              std::function<void (LocationError err)> procImpl ) :
+                              mContext(context), mProcImpl(procImpl) {}
+
+        void returnToSender(const LocationError err) {
+            mLocationError = err;
+            mContext.sendMsg(this);
+        }
+};
+
+struct LocApiCollectiveResponse: LocMsg {
+    private:
+        ContextBase& mContext;
+        std::function<void (std::vector<LocationError> errs)> mProcImpl;
+        inline virtual void proc() const {
+            mProcImpl(mLocationErrors);
+        }
+    protected:
+        std::vector<LocationError> mLocationErrors;
+    public:
+        inline LocApiCollectiveResponse(ContextBase& context,
+                              std::function<void (std::vector<LocationError> errs)> procImpl ) :
+                              mContext(context), mProcImpl(procImpl) {}
+        inline virtual ~LocApiCollectiveResponse() {
+        }
+
+        void returnToSender(std::vector<LocationError>& errs) {
+            mLocationErrors = errs;
+            mContext.sendMsg(this);
+        }
+};
+
+
+template <typename DATA>
+struct LocApiResponseData: LocMsg {
+    private:
+        ContextBase& mContext;
+        std::function<void (LocationError err, DATA data)> mProcImpl;
+        inline virtual void proc() const {
+            mProcImpl(mLocationError, mData);
+        }
+    protected:
+        LocationError mLocationError;
+        DATA mData;
+    public:
+        inline LocApiResponseData(ContextBase& context,
+                              std::function<void (LocationError err, DATA data)> procImpl ) :
+                              mContext(context), mProcImpl(procImpl) {}
+
+        void returnToSender(const LocationError err, const DATA data) {
+            mLocationError = err;
+            mData = data;
+            mContext.sendMsg(this);
+        }
+};
+
+
+} // namespace loc_core
+
+#endif //__LOC_CONTEXT_BASE__

gps/core/EngineHubProxyBase.h

@@ -0,0 +1,160 @@
+/* Copyright (c) 2018-2020 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 ENGINE_HUB_PROXY_BASE_H
+#define ENGINE_HUB_PROXY_BASE_H
+#ifdef NO_UNORDERED_SET_OR_MAP
+    #include <map>
+#else
+    #include <unordered_map>
+#endif
+
+namespace loc_core {
+
+using namespace loc_util;
+
+class EngineHubProxyBase {
+public:
+    inline EngineHubProxyBase() {
+    }
+    inline virtual ~EngineHubProxyBase() {}
+
+    // gnss session related functions
+    inline virtual bool gnssStartFix() {
+        return false;
+    }
+
+    inline virtual bool gnssStopFix() {
+        return false;
+    }
+
+    inline virtual bool gnssSetFixMode(const LocPosMode &params) {
+        (void) params;
+        return false;
+    }
+
+    inline virtual bool gnssDeleteAidingData(const GnssAidingData &aidingData) {
+        (void) aidingData;
+        return false;
+    }
+
+    // GNSS reports
+    inline virtual bool gnssReportPosition(const UlpLocation &location,
+                                           const GpsLocationExtended &locationExtended,
+                                           enum loc_sess_status status) {
+        (void) location;
+        (void) locationExtended;
+        (void) status;
+        return false;
+    }
+
+    inline virtual bool gnssReportSv(const GnssSvNotification& svNotify) {
+        (void) svNotify;
+        return false;
+    }
+
+    inline virtual bool gnssReportSvMeasurement(const GnssSvMeasurementSet& svMeasurementSet) {
+        (void) svMeasurementSet;
+        return false;
+    }
+
+    inline virtual bool gnssReportSvPolynomial(const GnssSvPolynomial& svPolynomial) {
+        (void) svPolynomial;
+        return false;
+    }
+
+    inline virtual bool gnssReportSvEphemeris(const GnssSvEphemerisReport& svEphemeris) {
+        (void) svEphemeris;
+        return false;
+    }
+
+    inline virtual bool gnssReportSystemInfo(const LocationSystemInfo& systemInfo) {
+        (void) systemInfo;
+        return false;
+    }
+
+    inline virtual bool gnssReportKlobucharIonoModel(const GnssKlobucharIonoModel& ionoModel) {
+        (void) ionoModel;
+        return false;
+    }
+
+    inline virtual bool gnssReportAdditionalSystemInfo(
+            const GnssAdditionalSystemInfo& additionalSystemInfo) {
+        (void) additionalSystemInfo;
+        return false;
+    }
+
+    inline virtual bool configLeverArm(const LeverArmConfigInfo& configInfo) {
+        (void) configInfo;
+        return false;
+    }
+
+    inline virtual bool configDeadReckoningEngineParams(
+            const DeadReckoningEngineConfig& dreConfig) {
+        (void) dreConfig;
+        return false;
+    }
+
+    inline virtual bool configEngineRunState(
+            PositioningEngineMask engType, LocEngineRunState engState) {
+        (void) engType;
+        (void) engState;
+        return false;
+    }
+};
+
+typedef std::function<void(int count, EngineLocationInfo* locationArr)>
+        GnssAdapterReportEnginePositionsEventCb;
+
+typedef std::function<void(const GnssSvNotification& svNotify,
+                           bool fromEngineHub)>
+        GnssAdapterReportSvEventCb;
+
+typedef std::function<void(const GnssAidingDataSvMask& svDataMask)>
+        GnssAdapterReqAidingDataCb;
+
+typedef std::function<void(bool nHzNeeded, bool nHzMeasNeeded)>
+        GnssAdapterUpdateNHzRequirementCb;
+
+typedef std::function<void(const std::unordered_map<LocationQwesFeatureType, bool> &featureMap)>
+        GnssAdapterUpdateQwesFeatureStatusCb;
+
+// potential parameters: message queue: MsgTask * msgTask;
+// callback function to report back dr and ppe position and sv report
+typedef EngineHubProxyBase* (getEngHubProxyFn)(
+        const MsgTask * msgTask,
+        IOsObserver* osObserver,
+        GnssAdapterReportEnginePositionsEventCb positionEventCb,
+        GnssAdapterReportSvEventCb svEventCb,
+        GnssAdapterReqAidingDataCb reqAidingDataCb,
+        GnssAdapterUpdateNHzRequirementCb updateNHzRequirementCb,
+        GnssAdapterUpdateQwesFeatureStatusCb updateQwesFeatureStatusCb);
+
+} // namespace loc_core
+
+#endif // ENGINE_HUB_PROXY_BASE_H

gps/core/LBSProxyBase.h

@@ -0,0 +1,70 @@
+/* Copyright (c) 2013-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.
+ *
+ */
+#ifndef IZAT_PROXY_BASE_H
+#define IZAT_PROXY_BASE_H
+#include <gps_extended.h>
+
+namespace loc_core {
+
+class LocApiBase;
+class LocAdapterBase;
+class ContextBase;
+
+class LBSProxyBase {
+    friend class ContextBase;
+    inline virtual LocApiBase*
+        getLocApi(LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                  ContextBase* context) const {
+
+        (void)exMask;
+        (void)context;
+        return NULL;
+    }
+protected:
+    inline LBSProxyBase() {}
+public:
+    inline virtual ~LBSProxyBase() {}
+    inline virtual bool hasAgpsExtendedCapabilities() const { return false; }
+    inline virtual void modemPowerVote(bool power) const {
+
+        (void)power;
+    }
+    virtual void injectFeatureConfig(ContextBase* context) const {
+
+        (void)context;
+    }
+    inline virtual bool hasNativeXtraClient() const { return false; }
+    inline virtual IzatDevId_t getIzatDevId() const { return 0; }
+};
+
+typedef LBSProxyBase* (getLBSProxy_t)();
+
+} // namespace loc_core
+
+#endif // IZAT_PROXY_BASE_H

gps/core/LocAdapterBase.cpp

@@ -0,0 +1,439 @@
+/* Copyright (c) 2011-2014, 2016-2020 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_LocAdapterBase"
+
+#include <dlfcn.h>
+#include <LocAdapterBase.h>
+#include <loc_target.h>
+#include <log_util.h>
+#include <LocAdapterProxyBase.h>
+
+namespace loc_core {
+
+// This is the top level class, so the constructor will
+// always gets called. Here we prepare for the default.
+// But if getLocApi(targetEnumType target) is overriden,
+// the right locApi should get created.
+LocAdapterBase::LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
+                               ContextBase* context, bool isMaster,
+                               LocAdapterProxyBase *adapterProxyBase,
+                               bool waitForDoneInit) :
+    mIsMaster(isMaster), mEvtMask(mask), mContext(context),
+    mLocApi(context->getLocApi()), mLocAdapterProxyBase(adapterProxyBase),
+    mMsgTask(context->getMsgTask()),
+    mIsEngineCapabilitiesKnown(ContextBase::sIsEngineCapabilitiesKnown)
+{
+    LOC_LOGd("waitForDoneInit: %d", waitForDoneInit);
+    if (!waitForDoneInit) {
+        mLocApi->addAdapter(this);
+        mAdapterAdded = true;
+    } else {
+        mAdapterAdded = false;
+    }
+}
+
+uint32_t LocAdapterBase::mSessionIdCounter(1);
+
+uint32_t LocAdapterBase::generateSessionId()
+{
+    if (++mSessionIdCounter == 0xFFFFFFFF)
+        mSessionIdCounter = 1;
+
+     return mSessionIdCounter;
+}
+
+void LocAdapterBase::handleEngineUpEvent()
+{
+    if (mLocAdapterProxyBase) {
+        mLocAdapterProxyBase->handleEngineUpEvent();
+    }
+}
+
+void LocAdapterBase::handleEngineDownEvent()
+{
+    if (mLocAdapterProxyBase) {
+        mLocAdapterProxyBase->handleEngineDownEvent();
+    }
+}
+
+void LocAdapterBase::
+    reportPositionEvent(const UlpLocation& location,
+                        const GpsLocationExtended& locationExtended,
+                        enum loc_sess_status status,
+                        LocPosTechMask loc_technology_mask,
+                        GnssDataNotification* pDataNotify,
+                        int msInWeek)
+{
+    if (mLocAdapterProxyBase != NULL) {
+        mLocAdapterProxyBase->reportPositionEvent((UlpLocation&)location,
+                                                   (GpsLocationExtended&)locationExtended,
+                                                   status,
+                                                   loc_technology_mask);
+    } else {
+        DEFAULT_IMPL()
+    }
+}
+
+void LocAdapterBase::
+    reportSvEvent(const GnssSvNotification& /*svNotify*/,
+                  bool /*fromEngineHub*/)
+DEFAULT_IMPL()
+
+void LocAdapterBase::
+    reportSvPolynomialEvent(GnssSvPolynomial &/*svPolynomial*/)
+DEFAULT_IMPL()
+
+void LocAdapterBase::
+    reportSvEphemerisEvent(GnssSvEphemerisReport &/*svEphemeris*/)
+DEFAULT_IMPL()
+
+
+void LocAdapterBase::
+    reportStatus(LocGpsStatusValue /*status*/)
+DEFAULT_IMPL()
+
+
+void LocAdapterBase::
+    reportNmeaEvent(const char* /*nmea*/, size_t /*length*/)
+DEFAULT_IMPL()
+
+void LocAdapterBase::
+    reportDataEvent(const GnssDataNotification& /*dataNotify*/,
+                    int /*msInWeek*/)
+DEFAULT_IMPL()
+
+bool LocAdapterBase::
+    reportXtraServer(const char* /*url1*/, const char* /*url2*/,
+                     const char* /*url3*/, const int /*maxlength*/)
+DEFAULT_IMPL(false)
+
+void LocAdapterBase::
+    reportLocationSystemInfoEvent(const LocationSystemInfo& /*locationSystemInfo*/)
+DEFAULT_IMPL()
+
+bool LocAdapterBase::
+    requestXtraData()
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+    requestTime()
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+    requestLocation()
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+    requestATL(int /*connHandle*/, LocAGpsType /*agps_type*/,
+               LocApnTypeMask /*apn_type_mask*/)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+    releaseATL(int /*connHandle*/)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+    requestNiNotifyEvent(const GnssNiNotification &/*notify*/,
+                         const void* /*data*/,
+                         const LocInEmergency emergencyState)
+DEFAULT_IMPL(false)
+
+void LocAdapterBase::
+reportGnssMeasurementsEvent(const GnssMeasurements& /*gnssMeasurements*/,
+                                   int /*msInWeek*/)
+DEFAULT_IMPL()
+
+bool LocAdapterBase::
+    reportWwanZppFix(LocGpsLocation &/*zppLoc*/)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+    reportZppBestAvailableFix(LocGpsLocation& /*zppLoc*/,
+            GpsLocationExtended& /*location_extended*/, LocPosTechMask /*tech_mask*/)
+DEFAULT_IMPL(false)
+
+void LocAdapterBase::reportGnssSvIdConfigEvent(const GnssSvIdConfig& /*config*/)
+DEFAULT_IMPL()
+
+void LocAdapterBase::reportGnssSvTypeConfigEvent(const GnssSvTypeConfig& /*config*/)
+DEFAULT_IMPL()
+
+void LocAdapterBase::reportGnssConfigEvent(uint32_t,  /* session id*/
+            const GnssConfig& /*gnssConfig*/)
+DEFAULT_IMPL()
+
+bool LocAdapterBase::
+    requestOdcpiEvent(OdcpiRequestInfo& /*request*/)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+    reportGnssEngEnergyConsumedEvent(uint64_t /*energyConsumedSinceFirstBoot*/)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+    reportDeleteAidingDataEvent(GnssAidingData & /*aidingData*/)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+    reportKlobucharIonoModelEvent(GnssKlobucharIonoModel& /*ionoModel*/)
+DEFAULT_IMPL(false)
+
+bool LocAdapterBase::
+    reportGnssAdditionalSystemInfoEvent(GnssAdditionalSystemInfo& /*additionalSystemInfo*/)
+DEFAULT_IMPL(false)
+
+void LocAdapterBase::
+    reportNfwNotificationEvent(GnssNfwNotification& /*notification*/)
+DEFAULT_IMPL()
+
+void
+LocAdapterBase::geofenceBreachEvent(size_t /*count*/, uint32_t* /*hwIds*/, Location& /*location*/,
+                                    GeofenceBreachType /*breachType*/, uint64_t /*timestamp*/)
+DEFAULT_IMPL()
+
+void
+LocAdapterBase::geofenceStatusEvent(GeofenceStatusAvailable /*available*/)
+DEFAULT_IMPL()
+
+void
+LocAdapterBase::reportLocationsEvent(const Location* /*locations*/, size_t /*count*/,
+                                     BatchingMode /*batchingMode*/)
+DEFAULT_IMPL()
+
+void
+LocAdapterBase::reportCompletedTripsEvent(uint32_t /*accumulated_distance*/)
+DEFAULT_IMPL()
+
+void
+LocAdapterBase::reportBatchStatusChangeEvent(BatchingStatus /*batchStatus*/)
+DEFAULT_IMPL()
+
+void
+LocAdapterBase::reportPositionEvent(UlpLocation& /*location*/,
+                                    GpsLocationExtended& /*locationExtended*/,
+                                    enum loc_sess_status /*status*/,
+                                    LocPosTechMask /*loc_technology_mask*/)
+DEFAULT_IMPL()
+
+void
+LocAdapterBase::saveClient(LocationAPI* client, const LocationCallbacks& callbacks)
+{
+    mClientData[client] = callbacks;
+    updateClientsEventMask();
+}
+
+void
+LocAdapterBase::eraseClient(LocationAPI* client)
+{
+    auto it = mClientData.find(client);
+    if (it != mClientData.end()) {
+        mClientData.erase(it);
+    }
+    updateClientsEventMask();
+}
+
+LocationCallbacks
+LocAdapterBase::getClientCallbacks(LocationAPI* client)
+{
+    LocationCallbacks callbacks = {};
+    auto it = mClientData.find(client);
+    if (it != mClientData.end()) {
+        callbacks = it->second;
+    }
+    return callbacks;
+}
+
+LocationCapabilitiesMask
+LocAdapterBase::getCapabilities()
+{
+    LocationCapabilitiesMask mask = 0;
+
+    if (isEngineCapabilitiesKnown()) {
+        // time based tracking always supported
+        mask |= LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT;
+        if (ContextBase::isMessageSupported(
+                LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_LOCATION_BATCHING)){
+            mask |= LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT |
+                    LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT;
+        }
+        if (ContextBase::isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_TRACKING)) {
+            mask |= LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT;
+        }
+        if (ContextBase::isMessageSupported(LOC_API_ADAPTER_MESSAGE_OUTDOOR_TRIP_BATCHING)) {
+            mask |= LOCATION_CAPABILITIES_OUTDOOR_TRIP_BATCHING_BIT;
+        }
+        // geofence always supported
+        mask |= LOCATION_CAPABILITIES_GEOFENCE_BIT;
+        if (ContextBase::gnssConstellationConfig()) {
+            mask |= LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT;
+        }
+        uint32_t carrierCapabilities = ContextBase::getCarrierCapabilities();
+        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 (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02)) {
+            mask |= LOCATION_CAPABILITIES_DEBUG_NMEA_BIT;
+        }
+        if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_CONSTELLATION_ENABLEMENT_V02)) {
+            mask |= LOCATION_CAPABILITIES_CONSTELLATION_ENABLEMENT_BIT;
+        }
+        if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_AGPM_V02)) {
+            mask |= LOCATION_CAPABILITIES_AGPM_BIT;
+        }
+        if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_LOCATION_PRIVACY)) {
+            mask |= LOCATION_CAPABILITIES_PRIVACY_BIT;
+        }
+        if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_MEASUREMENTS_CORRECTION)) {
+            mask |= LOCATION_CAPABILITIES_MEASUREMENTS_CORRECTION_BIT;
+        }
+        if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_ROBUST_LOCATION)) {
+            mask |= LOCATION_CAPABILITIES_CONFORMITY_INDEX_BIT;
+        }
+        if (ContextBase::isFeatureSupported(LOC_SUPPORTED_FEATURE_EDGNSS)) {
+            mask |= LOCATION_CAPABILITIES_EDGNSS_BIT;
+        }
+    } else {
+        LOC_LOGE("%s]: attempt to get capabilities before they are known.", __func__);
+    }
+
+    return mask;
+}
+
+void
+LocAdapterBase::broadcastCapabilities(LocationCapabilitiesMask mask)
+{
+    for (auto clientData : mClientData) {
+        if (nullptr != clientData.second.capabilitiesCb) {
+            clientData.second.capabilitiesCb(mask);
+        }
+    }
+}
+
+void
+LocAdapterBase::updateClientsEventMask()
+DEFAULT_IMPL()
+
+void
+LocAdapterBase::stopClientSessions(LocationAPI* client)
+DEFAULT_IMPL()
+
+void
+LocAdapterBase::addClientCommand(LocationAPI* client, const LocationCallbacks& callbacks)
+{
+    LOC_LOGD("%s]: client %p", __func__, client);
+
+    struct MsgAddClient : public LocMsg {
+        LocAdapterBase& mAdapter;
+        LocationAPI* mClient;
+        const LocationCallbacks mCallbacks;
+        inline MsgAddClient(LocAdapterBase& 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
+LocAdapterBase::removeClientCommand(LocationAPI* client,
+                                removeClientCompleteCallback rmClientCb)
+{
+    LOC_LOGD("%s]: client %p", __func__, client);
+
+    struct MsgRemoveClient : public LocMsg {
+        LocAdapterBase& mAdapter;
+        LocationAPI* mClient;
+        removeClientCompleteCallback mRmClientCb;
+        inline MsgRemoveClient(LocAdapterBase& adapter,
+                               LocationAPI* client,
+                               removeClientCompleteCallback rmCb) :
+            LocMsg(),
+            mAdapter(adapter),
+            mClient(client),
+            mRmClientCb(rmCb){}
+        inline virtual void proc() const {
+            mAdapter.stopClientSessions(mClient);
+            mAdapter.eraseClient(mClient);
+            if (nullptr != mRmClientCb) {
+                (mRmClientCb)(mClient);
+            }
+        }
+    };
+
+    sendMsg(new MsgRemoveClient(*this, client, rmClientCb));
+}
+
+void
+LocAdapterBase::requestCapabilitiesCommand(LocationAPI* client)
+{
+    LOC_LOGD("%s]: ", __func__);
+
+    struct MsgRequestCapabilities : public LocMsg {
+        LocAdapterBase& mAdapter;
+        LocationAPI* mClient;
+        inline MsgRequestCapabilities(LocAdapterBase& adapter,
+                                      LocationAPI* client) :
+            LocMsg(),
+            mAdapter(adapter),
+            mClient(client) {}
+        inline virtual void proc() const {
+            if (!mAdapter.isEngineCapabilitiesKnown()) {
+                mAdapter.mPendingMsgs.push_back(new MsgRequestCapabilities(*this));
+                return;
+            }
+            LocationCallbacks callbacks = mAdapter.getClientCallbacks(mClient);
+            if (callbacks.capabilitiesCb != nullptr) {
+                callbacks.capabilitiesCb(mAdapter.getCapabilities());
+            }
+        }
+    };
+
+    sendMsg(new MsgRequestCapabilities(*this, client));
+}
+
+void
+LocAdapterBase::reportLatencyInfoEvent(const GnssLatencyInfo& /*gnssLatencyInfo*/)
+DEFAULT_IMPL()
+
+bool LocAdapterBase::
+    reportQwesCapabilities(const std::unordered_map<LocationQwesFeatureType, bool> &featureMap)
+DEFAULT_IMPL(false)
+
+} // namespace loc_core

gps/core/LocAdapterBase.h

@@ -0,0 +1,246 @@
+/* Copyright (c) 2011-2014, 2016-2020 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_ADAPTER_BASE_H
+#define LOC_API_ADAPTER_BASE_H
+
+#include <gps_extended.h>
+#include <ContextBase.h>
+#include <LocationAPI.h>
+#include <map>
+
+#define MIN_TRACKING_INTERVAL (100) // 100 msec
+
+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 void (*removeClientCompleteCallback)(LocationAPI* client);
+
+namespace loc_core {
+
+class LocAdapterProxyBase;
+
+class LocAdapterBase {
+private:
+    static uint32_t mSessionIdCounter;
+    const bool mIsMaster;
+    bool mIsEngineCapabilitiesKnown = false;
+
+protected:
+    LOC_API_ADAPTER_EVENT_MASK_T mEvtMask;
+    ContextBase* mContext;
+    LocApiBase* mLocApi;
+    LocAdapterProxyBase* mLocAdapterProxyBase;
+    const MsgTask* mMsgTask;
+    bool mAdapterAdded;
+
+    inline LocAdapterBase(const MsgTask* msgTask) :
+        mIsMaster(false), mEvtMask(0), mContext(NULL), mLocApi(NULL),
+        mLocAdapterProxyBase(NULL), mMsgTask(msgTask), mAdapterAdded(false) {}
+
+    /* ==== CLIENT ========================================================================= */
+    typedef std::map<LocationAPI*, LocationCallbacks> ClientDataMap;
+    ClientDataMap mClientData;
+    std::vector<LocMsg*> mPendingMsgs; // For temporal storage of msgs before Open is completed
+    /* ======== UTILITIES ================================================================== */
+    void saveClient(LocationAPI* client, const LocationCallbacks& callbacks);
+    void eraseClient(LocationAPI* client);
+    LocationCallbacks getClientCallbacks(LocationAPI* client);
+    LocationCapabilitiesMask getCapabilities();
+    void broadcastCapabilities(LocationCapabilitiesMask mask);
+    virtual void updateClientsEventMask();
+    virtual void stopClientSessions(LocationAPI* client);
+
+public:
+    inline virtual ~LocAdapterBase() { mLocApi->removeAdapter(this); }
+    // When waitForDoneInit is not specified or specified as false,
+    // handleEngineUpEvent may be called on the child adapter object from
+    // a different thread before the constructor of the child
+    // object finishes.
+    //
+    // If the handleEngineUpEvent relies on member variables of the constructor
+    // of the child adapter to be initialized first, we need to specify the
+    // waitForDoneInit to *TRUE* to delay handleEngineUpEvent to get called
+    // until when the child adapter finishes its initialization and notify
+    // LocAdapterBase via doneInit method.
+    LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
+                   ContextBase* context, bool isMaster = false,
+                   LocAdapterProxyBase *adapterProxyBase = NULL,
+                   bool waitForDoneInit = false);
+
+    inline void doneInit() {
+        if (!mAdapterAdded) {
+            mLocApi->addAdapter(this);
+            mAdapterAdded = true;
+        }
+    }
+
+    inline LOC_API_ADAPTER_EVENT_MASK_T
+        checkMask(LOC_API_ADAPTER_EVENT_MASK_T mask) const {
+        return mEvtMask & mask;
+    }
+
+    inline LOC_API_ADAPTER_EVENT_MASK_T getEvtMask() const {
+        return mEvtMask;
+    }
+
+    inline void sendMsg(const LocMsg* msg) const {
+        mMsgTask->sendMsg(msg);
+    }
+
+    inline void sendMsg(const LocMsg* msg) {
+        mMsgTask->sendMsg(msg);
+    }
+
+    inline void updateEvtMask(LOC_API_ADAPTER_EVENT_MASK_T event,
+                              loc_registration_mask_status status)
+    {
+        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();
+    }
+
+    inline void updateNmeaMask(uint32_t mask)
+    {
+        mLocApi->updateNmeaMask(mask);
+    }
+
+    inline bool isFeatureSupported(uint8_t featureVal) {
+        return ContextBase::isFeatureSupported(featureVal);
+    }
+
+    static uint32_t generateSessionId();
+
+    inline bool isAdapterMaster() {
+        return mIsMaster;
+    }
+
+    inline bool isEngineCapabilitiesKnown() { return mIsEngineCapabilitiesKnown;}
+    inline void setEngineCapabilitiesKnown(bool value) { mIsEngineCapabilitiesKnown = value;}
+
+    virtual void handleEngineUpEvent();
+    virtual void handleEngineDownEvent();
+    virtual void reportPositionEvent(const UlpLocation& location,
+                                     const GpsLocationExtended& locationExtended,
+                                     enum loc_sess_status status,
+                                     LocPosTechMask loc_technology_mask,
+                                     GnssDataNotification* pDataNotify = nullptr,
+                                     int msInWeek = -1);
+    virtual void reportEnginePositionsEvent(unsigned int count,
+                                            EngineLocationInfo* locationArr) {
+        (void)count;
+        (void)locationArr;
+    }
+    virtual void reportSvEvent(const GnssSvNotification& svNotify,
+                               bool fromEngineHub=false);
+    virtual void reportDataEvent(const GnssDataNotification& dataNotify, int msInWeek);
+    virtual void reportNmeaEvent(const char* nmea, size_t length);
+    virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial);
+    virtual void reportSvEphemerisEvent(GnssSvEphemerisReport &svEphemeris);
+    virtual void reportStatus(LocGpsStatusValue status);
+    virtual bool reportXtraServer(const char* url1, const char* url2,
+                                  const char* url3, const int maxlength);
+    virtual void reportLocationSystemInfoEvent(const LocationSystemInfo& locationSystemInfo);
+
+    virtual bool requestXtraData();
+    virtual bool requestTime();
+    virtual bool requestLocation();
+    virtual bool requestATL(int connHandle, LocAGpsType agps_type,
+                            LocApnTypeMask apn_type_mask);
+    virtual bool releaseATL(int connHandle);
+    virtual bool requestNiNotifyEvent(const GnssNiNotification &notify, const void* data,
+                                      const LocInEmergency emergencyState);
+    inline virtual bool isInSession() { return false; }
+    ContextBase* getContext() const { return mContext; }
+    virtual void reportGnssMeasurementsEvent(const GnssMeasurements& gnssMeasurements,
+                                                int msInWeek);
+    virtual bool reportWwanZppFix(LocGpsLocation &zppLoc);
+    virtual bool reportZppBestAvailableFix(LocGpsLocation &zppLoc,
+            GpsLocationExtended &location_extended, LocPosTechMask tech_mask);
+    virtual void reportGnssSvIdConfigEvent(const GnssSvIdConfig& config);
+    virtual void reportGnssSvTypeConfigEvent(const GnssSvTypeConfig& config);
+    virtual void reportGnssConfigEvent(uint32_t sessionId, const GnssConfig& gnssConfig);
+    virtual bool requestOdcpiEvent(OdcpiRequestInfo& request);
+    virtual bool reportGnssEngEnergyConsumedEvent(uint64_t energyConsumedSinceFirstBoot);
+    virtual bool reportDeleteAidingDataEvent(GnssAidingData &aidingData);
+    virtual bool reportKlobucharIonoModelEvent(GnssKlobucharIonoModel& ionoModel);
+    virtual bool reportGnssAdditionalSystemInfoEvent(
+            GnssAdditionalSystemInfo& additionalSystemInfo);
+    virtual void reportNfwNotificationEvent(GnssNfwNotification& notification);
+
+    virtual void geofenceBreachEvent(size_t count, uint32_t* hwIds, Location& location,
+                                     GeofenceBreachType breachType, uint64_t timestamp);
+    virtual void geofenceStatusEvent(GeofenceStatusAvailable available);
+
+    virtual void reportPositionEvent(UlpLocation &location,
+                                     GpsLocationExtended &locationExtended,
+                                     enum loc_sess_status status,
+                                     LocPosTechMask loc_technology_mask);
+
+    virtual void reportLocationsEvent(const Location* locations, size_t count,
+            BatchingMode batchingMode);
+    virtual void reportCompletedTripsEvent(uint32_t accumulated_distance);
+    virtual void reportBatchStatusChangeEvent(BatchingStatus batchStatus);
+
+    /* ==== CLIENT ========================================================================= */
+    /* ======== COMMANDS ====(Called from Client Thread)==================================== */
+    void addClientCommand(LocationAPI* client, const LocationCallbacks& callbacks);
+    void removeClientCommand(LocationAPI* client,
+                             removeClientCompleteCallback rmClientCb);
+    void requestCapabilitiesCommand(LocationAPI* client);
+
+    virtual void reportLatencyInfoEvent(const GnssLatencyInfo& gnssLatencyInfo);
+    virtual bool reportQwesCapabilities(
+            const std::unordered_map<LocationQwesFeatureType, bool> &featureMap);
+};
+
+} // namespace loc_core
+
+#endif //LOC_API_ADAPTER_BASE_H

gps/core/LocAdapterProxyBase.h

@@ -0,0 +1,77 @@
+/* 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
+ * 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_ADAPTER_PROXY_BASE_H
+#define LOC_ADAPTER_PROXY_BASE_H
+
+#include <ContextBase.h>
+#include <gps_extended.h>
+
+namespace loc_core {
+
+class LocAdapterProxyBase {
+private:
+    LocAdapterBase *mLocAdapterBase;
+protected:
+    inline LocAdapterProxyBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
+                               ContextBase* context, bool isMaster = false):
+            mLocAdapterBase(new LocAdapterBase(mask, context, isMaster, this)) {
+    }
+    inline virtual ~LocAdapterProxyBase() {
+        delete mLocAdapterBase;
+    }
+    inline void updateEvtMask(LOC_API_ADAPTER_EVENT_MASK_T event,
+                              loc_registration_mask_status isEnabled) {
+        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 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;
+    }
+};
+
+} // namespace loc_core
+
+#endif //LOC_ADAPTER_PROXY_BASE_H

gps/core/LocApiBase.h

@@ -0,0 +1,375 @@
+/* Copyright (c) 2011-2014, 2016-2020 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_BASE_H
+#define LOC_API_BASE_H
+
+#include <stddef.h>
+#include <ctype.h>
+#include <gps_extended.h>
+#include <LocationAPI.h>
+#include <MsgTask.h>
+#include <LocSharedLock.h>
+#include <log_util.h>
+#ifdef NO_UNORDERED_SET_OR_MAP
+    #include <map>
+#else
+    #include <unordered_map>
+#endif
+#include <inttypes.h>
+#include <functional>
+
+using namespace loc_util;
+
+namespace loc_core {
+
+class ContextBase;
+struct LocApiResponse;
+template <typename> struct LocApiResponseData;
+
+int hexcode(char *hexstring, int string_size,
+            const char *data, int data_size);
+int decodeAddress(char *addr_string, int string_size,
+                  const char *data, int data_size);
+
+#define MAX_ADAPTERS          10
+#define MAX_FEATURE_LENGTH    100
+
+#define TO_ALL_ADAPTERS(adapters, call)                                \
+    for (int i = 0; i < MAX_ADAPTERS && NULL != (adapters)[i]; i++) {  \
+        call;                                                          \
+    }
+
+#define TO_1ST_HANDLING_ADAPTER(adapters, call)                              \
+    for (int i = 0; i <MAX_ADAPTERS && NULL != (adapters)[i] && !(call); i++);
+
+class LocAdapterBase;
+struct LocSsrMsg;
+struct LocOpenMsg;
+
+typedef struct
+{
+    uint32_t accumulatedDistance;
+    uint32_t numOfBatchedPositions;
+} LocApiBatchData;
+
+typedef struct
+{
+    uint32_t hwId;
+} LocApiGeofenceData;
+
+struct LocApiMsg: LocMsg {
+    private:
+        std::function<void ()> mProcImpl;
+        inline virtual void proc() const {
+            mProcImpl();
+        }
+    public:
+        inline LocApiMsg(std::function<void ()> procImpl ) :
+                         mProcImpl(procImpl) {}
+};
+
+class LocApiProxyBase {
+public:
+    inline LocApiProxyBase() {}
+    inline virtual ~LocApiProxyBase() {}
+    inline virtual void* getSibling2() { return NULL; }
+    inline virtual double getGloRfLoss(uint32_t left,
+            uint32_t center, uint32_t right, uint8_t gloFrequency) { return 0.0; }
+};
+
+class LocApiBase {
+    friend struct LocSsrMsg;
+    //LocOpenMsg calls open() which makes it necessary to declare
+    //it as a friend
+    friend struct LocOpenMsg;
+    friend struct LocCloseMsg;
+    friend struct LocKillMsg;
+    friend class ContextBase;
+    static MsgTask* mMsgTask;
+    static volatile int32_t mMsgTaskRefCount;
+    LocAdapterBase* mLocAdapters[MAX_ADAPTERS];
+
+protected:
+    ContextBase *mContext;
+    virtual enum loc_api_adapter_err
+        open(LOC_API_ADAPTER_EVENT_MASK_T mask);
+    virtual enum loc_api_adapter_err
+        close();
+    LOC_API_ADAPTER_EVENT_MASK_T getEvtMask();
+    LOC_API_ADAPTER_EVENT_MASK_T mMask;
+    uint32_t mNmeaMask;
+    LocApiBase(LOC_API_ADAPTER_EVENT_MASK_T excludedMask,
+               ContextBase* context = NULL);
+    inline virtual ~LocApiBase() {
+        android_atomic_dec(&mMsgTaskRefCount);
+        if (nullptr != mMsgTask && 0 == mMsgTaskRefCount) {
+            delete mMsgTask;
+            mMsgTask = nullptr;
+        }
+    }
+    bool isInSession();
+    const LOC_API_ADAPTER_EVENT_MASK_T mExcludedMask;
+    bool isMaster();
+
+public:
+    inline void sendMsg(const LocMsg* msg) const {
+        if (nullptr != mMsgTask) {
+            mMsgTask->sendMsg(msg);
+        }
+    }
+    inline void destroy() {
+        close();
+        struct LocKillMsg : public LocMsg {
+            LocApiBase* mLocApi;
+            inline LocKillMsg(LocApiBase* locApi) : LocMsg(), mLocApi(locApi) {}
+            inline virtual void proc() const {
+                delete mLocApi;
+            }
+        };
+        sendMsg(new LocKillMsg(this));
+    }
+
+    static bool needReport(const UlpLocation& ulpLocation,
+                           enum loc_sess_status status,
+                           LocPosTechMask techMask);
+
+    void addAdapter(LocAdapterBase* adapter);
+    void removeAdapter(LocAdapterBase* adapter);
+
+    // upward calls
+    void handleEngineUpEvent();
+    void handleEngineDownEvent();
+    void reportPosition(UlpLocation& location,
+                        GpsLocationExtended& locationExtended,
+                        enum loc_sess_status status,
+                        LocPosTechMask loc_technology_mask =
+                                  LOC_POS_TECH_MASK_DEFAULT,
+                        GnssDataNotification* pDataNotify = nullptr,
+                        int msInWeek = -1);
+    void reportSv(GnssSvNotification& svNotify);
+    void reportSvPolynomial(GnssSvPolynomial &svPolynomial);
+    void reportSvEphemeris(GnssSvEphemerisReport &svEphemeris);
+    void reportStatus(LocGpsStatusValue status);
+    void reportNmea(const char* nmea, int length);
+    void reportData(GnssDataNotification& dataNotify, int msInWeek);
+    void reportXtraServer(const char* url1, const char* url2,
+                          const char* url3, const int maxlength);
+    void reportLocationSystemInfo(const LocationSystemInfo& locationSystemInfo);
+    void requestXtraData();
+    void requestTime();
+    void requestLocation();
+    void requestATL(int connHandle, LocAGpsType agps_type, LocApnTypeMask apn_type_mask);
+    void releaseATL(int connHandle);
+    void requestNiNotify(GnssNiNotification &notify, const void* data,
+                         const LocInEmergency emergencyState);
+    void reportGnssMeasurements(GnssMeasurements& gnssMeasurements, int msInWeek);
+    void reportWwanZppFix(LocGpsLocation &zppLoc);
+    void reportZppBestAvailableFix(LocGpsLocation &zppLoc, GpsLocationExtended &location_extended,
+            LocPosTechMask tech_mask);
+    void reportGnssSvIdConfig(const GnssSvIdConfig& config);
+    void reportGnssSvTypeConfig(const GnssSvTypeConfig& config);
+    void requestOdcpi(OdcpiRequestInfo& request);
+    void reportGnssEngEnergyConsumedEvent(uint64_t energyConsumedSinceFirstBoot);
+    void reportDeleteAidingDataEvent(GnssAidingData& aidingData);
+    void reportKlobucharIonoModel(GnssKlobucharIonoModel& ionoModel);
+    void reportGnssAdditionalSystemInfo(GnssAdditionalSystemInfo& additionalSystemInfo);
+    void sendNfwNotification(GnssNfwNotification& notification);
+    void reportGnssConfig(uint32_t sessionId, const GnssConfig& gnssConfig);
+    void reportLatencyInfo(GnssLatencyInfo& gnssLatencyInfo);
+    void reportQwesCapabilities
+    (
+        const std::unordered_map<LocationQwesFeatureType, bool> &featureMap
+    );
+
+    void geofenceBreach(size_t count, uint32_t* hwIds, Location& location,
+            GeofenceBreachType breachType, uint64_t timestamp);
+    void geofenceStatus(GeofenceStatusAvailable available);
+    void reportDBTPosition(UlpLocation &location,
+                           GpsLocationExtended &locationExtended,
+                           enum loc_sess_status status,
+                           LocPosTechMask loc_technology_mask);
+    void reportLocations(Location* locations, size_t count, BatchingMode batchingMode);
+    void reportCompletedTrips(uint32_t accumulated_distance);
+    void handleBatchStatusEvent(BatchingStatus batchStatus);
+
+    // downward calls
+    virtual void* getSibling();
+    virtual LocApiProxyBase* getLocApiProxy();
+    virtual void startFix(const LocPosMode& fixCriteria, LocApiResponse* adapterResponse);
+    virtual void stopFix(LocApiResponse* adapterResponse);
+    virtual void deleteAidingData(const GnssAidingData& data, LocApiResponse* adapterResponse);
+    virtual void injectPosition(double latitude, double longitude, float accuracy,
+            bool onDemandCpi);
+    virtual void injectPosition(const GnssLocationInfoNotification &locationInfo,
+            bool onDemandCpi=false);
+    virtual void injectPosition(const Location& location, bool onDemandCpi);
+    virtual void setTime(LocGpsUtcTime time, int64_t timeReference, int uncertainty);
+    virtual void atlOpenStatus(int handle, int is_succ, char* apn, uint32_t apnLen,
+            AGpsBearerType bear, LocAGpsType agpsType, LocApnTypeMask mask);
+    virtual void atlCloseStatus(int handle, int is_succ);
+    virtual LocationError setServerSync(const char* url, int len, LocServerType type);
+    virtual LocationError setServerSync(unsigned int ip, int port, LocServerType type);
+    virtual void informNiResponse(GnssNiResponse userResponse, const void* passThroughData);
+    virtual LocationError setSUPLVersionSync(GnssConfigSuplVersion version);
+    virtual enum loc_api_adapter_err setNMEATypesSync(uint32_t typesMask);
+    virtual LocationError setLPPConfigSync(GnssConfigLppProfileMask profileMask);
+    virtual enum loc_api_adapter_err setSensorPropertiesSync(
+            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);
+    virtual enum loc_api_adapter_err setSensorPerfControlConfigSync(int controlMode,
+            int accelSamplesPerBatch, int accelBatchesPerSec, int gyroSamplesPerBatch,
+            int gyroBatchesPerSec, int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh,
+            int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig);
+    virtual LocationError
+            setAGLONASSProtocolSync(GnssConfigAGlonassPositionProtocolMask aGlonassProtocol);
+    virtual LocationError setLPPeProtocolCpSync(GnssConfigLppeControlPlaneMask lppeCP);
+    virtual LocationError setLPPeProtocolUpSync(GnssConfigLppeUserPlaneMask lppeUP);
+    virtual GnssConfigSuplVersion convertSuplVersion(const uint32_t suplVersion);
+    virtual GnssConfigLppeControlPlaneMask convertLppeCp(const uint32_t lppeControlPlaneMask);
+    virtual GnssConfigLppeUserPlaneMask convertLppeUp(const uint32_t lppeUserPlaneMask);
+    virtual LocationError setEmergencyExtensionWindowSync(const uint32_t emergencyExtensionSeconds);
+    virtual void setMeasurementCorrections(
+            const GnssMeasurementCorrections& gnssMeasurementCorrections);
+
+    virtual void getWwanZppFix();
+    virtual void getBestAvailableZppFix();
+    virtual LocationError setGpsLockSync(GnssConfigGpsLock lock);
+    virtual void requestForAidingData(GnssAidingDataSvMask svDataMask);
+    virtual LocationError setXtraVersionCheckSync(uint32_t check);
+    /* Requests for SV/Constellation Control */
+    virtual LocationError setBlacklistSvSync(const GnssSvIdConfig& config);
+    virtual void setBlacklistSv(const GnssSvIdConfig& config,
+                                LocApiResponse *adapterResponse=nullptr);
+    virtual void getBlacklistSv();
+    virtual void setConstellationControl(const GnssSvTypeConfig& config,
+                                         LocApiResponse *adapterResponse=nullptr);
+    virtual void getConstellationControl();
+    virtual void resetConstellationControl(LocApiResponse *adapterResponse=nullptr);
+
+    virtual void setConstrainedTuncMode(bool enabled,
+                                        float tuncConstraint,
+                                        uint32_t energyBudget,
+                                        LocApiResponse* adapterResponse=nullptr);
+    virtual void setPositionAssistedClockEstimatorMode(bool enabled,
+                                                       LocApiResponse* adapterResponse=nullptr);
+    virtual void getGnssEnergyConsumed();
+
+    virtual void addGeofence(uint32_t clientId, const GeofenceOption& options,
+            const GeofenceInfo& info, LocApiResponseData<LocApiGeofenceData>* adapterResponseData);
+    virtual void removeGeofence(uint32_t hwId, uint32_t clientId, LocApiResponse* adapterResponse);
+    virtual void pauseGeofence(uint32_t hwId, uint32_t clientId, LocApiResponse* adapterResponse);
+    virtual void resumeGeofence(uint32_t hwId, uint32_t clientId, LocApiResponse* adapterResponse);
+    virtual void modifyGeofence(uint32_t hwId, uint32_t clientId, const GeofenceOption& options,
+             LocApiResponse* adapterResponse);
+
+    virtual void startTimeBasedTracking(const TrackingOptions& options,
+             LocApiResponse* adapterResponse);
+    virtual void stopTimeBasedTracking(LocApiResponse* adapterResponse);
+    virtual void startDistanceBasedTracking(uint32_t sessionId, const LocationOptions& options,
+             LocApiResponse* adapterResponse);
+    virtual void stopDistanceBasedTracking(uint32_t sessionId,
+             LocApiResponse* adapterResponse = nullptr);
+    virtual void startBatching(uint32_t sessionId, const LocationOptions& options,
+            uint32_t accuracy, uint32_t timeout, LocApiResponse* adapterResponse);
+    virtual void stopBatching(uint32_t sessionId, LocApiResponse* adapterResponse);
+    virtual LocationError startOutdoorTripBatchingSync(uint32_t tripDistance,
+            uint32_t tripTbf, uint32_t timeout);
+    virtual void startOutdoorTripBatching(uint32_t tripDistance,
+            uint32_t tripTbf, uint32_t timeout, LocApiResponse* adapterResponse);
+    virtual void reStartOutdoorTripBatching(uint32_t ongoingTripDistance,
+            uint32_t ongoingTripInterval, uint32_t batchingTimeout,
+            LocApiResponse* adapterResponse);
+    virtual LocationError stopOutdoorTripBatchingSync(bool deallocBatchBuffer = true);
+    virtual void stopOutdoorTripBatching(bool deallocBatchBuffer = true,
+            LocApiResponse* adapterResponse = nullptr);
+    virtual LocationError getBatchedLocationsSync(size_t count);
+    virtual void getBatchedLocations(size_t count, LocApiResponse* adapterResponse);
+    virtual LocationError getBatchedTripLocationsSync(size_t count, uint32_t accumulatedDistance);
+    virtual void getBatchedTripLocations(size_t count, uint32_t accumulatedDistance,
+            LocApiResponse* adapterResponse);
+    virtual LocationError queryAccumulatedTripDistanceSync(uint32_t &accumulated_trip_distance,
+            uint32_t &numOfBatchedPositions);
+    virtual void queryAccumulatedTripDistance(
+            LocApiResponseData<LocApiBatchData>* adapterResponseData);
+    virtual void setBatchSize(size_t size);
+    virtual void setTripBatchSize(size_t size);
+    virtual void addToCallQueue(LocApiResponse* adapterResponse);
+
+    void updateEvtMask();
+    void updateNmeaMask(uint32_t mask);
+
+    virtual void updateSystemPowerState(PowerStateType systemPowerState);
+
+    virtual void configRobustLocation(bool enable, bool enableForE911,
+                                      LocApiResponse* adapterResponse=nullptr);
+    virtual void getRobustLocationConfig(uint32_t sessionId, LocApiResponse* adapterResponse);
+    virtual void configMinGpsWeek(uint16_t minGpsWeek,
+                                  LocApiResponse* adapterResponse=nullptr);
+    virtual void getMinGpsWeek(uint32_t sessionId, LocApiResponse* adapterResponse);
+
+    virtual LocationError setParameterSync(const GnssConfig & gnssConfig);
+    virtual void getParameter(uint32_t sessionId, GnssConfigFlagsMask flags,
+                              LocApiResponse* adapterResponse=nullptr);
+
+    virtual void configConstellationMultiBand(const GnssSvTypeConfig& secondaryBandConfig,
+                                              LocApiResponse* adapterResponse=nullptr);
+    virtual void getConstellationMultiBandConfig(uint32_t sessionId,
+                                        LocApiResponse* adapterResponse=nullptr);
+};
+
+class ElapsedRealtimeEstimator {
+private:
+    int64_t mCurrentClockDiff;
+    int64_t mPrevUtcTimeNanos;
+    int64_t mPrevBootTimeNanos;
+    int64_t mFixTimeStablizationThreshold;
+    int64_t mInitialTravelTime;
+    int64_t mPrevDataTimeNanos;
+public:
+
+    ElapsedRealtimeEstimator(int64_t travelTimeNanosEstimate):
+            mInitialTravelTime(travelTimeNanosEstimate) {reset();}
+    int64_t getElapsedRealtimeEstimateNanos(int64_t curDataTimeNanos,
+            bool isCurDataTimeTrustable, int64_t tbf);
+    inline int64_t getElapsedRealtimeUncNanos() { return 5000000;}
+    void reset();
+
+    static int64_t getElapsedRealtimeQtimer(int64_t qtimerTicksAtOrigin);
+    static bool getCurrentTime(struct timespec& currentTime, int64_t& sinceBootTimeNanos);
+};
+
+typedef LocApiBase* (getLocApi_t)(LOC_API_ADAPTER_EVENT_MASK_T exMask,
+                                  ContextBase *context);
+
+} // namespace loc_core
+
+#endif //LOC_API_BASE_H

gps/core/LocContext.cpp

@@ -0,0 +1,87 @@
+/* Copyright (c) 2011-2014, 2016-2020 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_Ctx"
+
+#include <cutils/sched_policy.h>
+#include <unistd.h>
+#include <LocContext.h>
+#include <msg_q.h>
+#include <log_util.h>
+#include <loc_log.h>
+
+namespace loc_core {
+
+const MsgTask* LocContext::mMsgTask = NULL;
+ContextBase* LocContext::mContext = NULL;
+// the name must be shorter than 15 chars
+const char* LocContext::mLocationHalName = "Loc_hal_worker";
+#ifndef USE_GLIB
+const char* LocContext::mLBSLibName = "liblbs_core.so";
+#else
+const char* LocContext::mLBSLibName = "liblbs_core.so.1";
+#endif
+
+pthread_mutex_t LocContext::mGetLocContextMutex = PTHREAD_MUTEX_INITIALIZER;
+
+const MsgTask* LocContext::getMsgTask(const char* name)
+{
+    if (NULL == mMsgTask) {
+        mMsgTask = new MsgTask(name);
+    }
+    return mMsgTask;
+}
+
+ContextBase* LocContext::getLocContext(const char* name)
+{
+    pthread_mutex_lock(&LocContext::mGetLocContextMutex);
+    LOC_LOGD("%s:%d]: querying ContextBase with tCreator", __func__, __LINE__);
+    if (NULL == mContext) {
+        LOC_LOGD("%s:%d]: creating msgTask with tCreator", __func__, __LINE__);
+        const MsgTask* msgTask = getMsgTask(name);
+        mContext = new LocContext(msgTask);
+    }
+    pthread_mutex_unlock(&LocContext::mGetLocContextMutex);
+
+    return mContext;
+}
+
+void LocContext :: injectFeatureConfig(ContextBase *curContext)
+{
+    LOC_LOGD("%s:%d]: Calling LBSProxy (%p) to inject feature config",
+             __func__, __LINE__, ((LocContext *)curContext)->mLBSProxy);
+    ((LocContext *)curContext)->mLBSProxy->injectFeatureConfig(curContext);
+}
+
+LocContext::LocContext(const MsgTask* msgTask) :
+    ContextBase(msgTask, 0, mLBSLibName)
+{
+}
+
+}

gps/core/LocContext.h

@@ -0,0 +1,60 @@
+/* Copyright (c) 2011-2014, 2017-2020 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_CONTEXT__
+#define __LOC_CONTEXT__
+
+#include <stdbool.h>
+#include <ctype.h>
+#include <dlfcn.h>
+#include <ContextBase.h>
+
+namespace loc_core {
+
+class LocContext : public ContextBase {
+    static const MsgTask* mMsgTask;
+    static ContextBase* mContext;
+    static const MsgTask* getMsgTask(const char* name);
+    static pthread_mutex_t mGetLocContextMutex;
+
+protected:
+    LocContext(const MsgTask* msgTask);
+    inline virtual ~LocContext() {}
+
+public:
+    static const char* mLBSLibName;
+    static const char* mLocationHalName;
+
+    static ContextBase* getLocContext(const char* name);
+
+    static void injectFeatureConfig(ContextBase *context);
+};
+
+}
+
+#endif //__LOC_CONTEXT__

gps/core/Makefile.am

@@ -0,0 +1,74 @@
+ACLOCAL_AMFLAGS = -I m4
+
+AM_CFLAGS = -I./ \
+            $(LOCPLA_CFLAGS) \
+            $(GPSUTILS_CFLAGS) \
+            -I./data-items/ \
+            -I./data-items/common \
+            -I./observer \
+            -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 \
+           LocContext.h \
+           LBSProxyBase.h \
+           loc_core_log.h \
+           LocAdapterProxyBase.h \
+           EngineHubProxyBase.h \
+           data-items/DataItemId.h \
+           data-items/IDataItemCore.h \
+           data-items/DataItemConcreteTypesBase.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 \
+           LocContext.cpp \
+           loc_core_log.cpp \
+           data-items/DataItemsFactoryProxy.cpp \
+           SystemStatusOsObserver.cpp \
+           SystemStatus.cpp
+
+if USE_EXTERNAL_AP
+AM_CFLAGS += -DFEATURE_EXTERNAL_AP
+endif
+
+library_includedir = $(pkgincludedir)
+
+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
+
+if USE_FEATURE_AUTOMOTIVE
+AM_CFLAGS += -DFEATURE_AUTOMOTIVE
+endif
+
+libloc_core_la_LIBADD = -ldl $(GPSUTILS_LIBS)
+
+#Create and Install libraries
+lib_LTLIBRARIES = libloc_core.la
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = loc-core.pc
+EXTRA_DIST = $(pkgconfig_DATA)

gps/core/SystemStatus.h

@@ -0,0 +1,926 @@
+/* Copyright (c) 2017-2021, 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 <stdint.h>
+#include <sys/time.h>
+#include <vector>
+#include <algorithm>
+#include <iterator>
+#include <loc_pla.h>
+#include <log_util.h>
+#include <MsgTask.h>
+#include <IDataItemCore.h>
+#include <IOsObserver.h>
+#include <DataItemConcreteTypesBase.h>
+#include <SystemStatusOsObserver.h>
+
+#include <gps_extended_c.h>
+
+#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 NAVIC_MIN  (401) //401-414
+
+#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 NAVIC_NUM   (14)
+#define SV_ALL_NUM_MIN  (GPS_NUM + GLO_NUM + QZSS_NUM + BDS_NUM + GAL_NUM) //=134
+#define SV_ALL_NUM      (SV_ALL_NUM_MIN + NAVIC_NUM) //=148
+
+namespace loc_core
+{
+
+/******************************************************************************
+ SystemStatus report data structure
+******************************************************************************/
+class SystemStatusItemBase
+{
+public:
+    timespec  mUtcTime;
+    timespec  mUtcReported;
+    static const uint32_t maxItem = 5;
+
+    SystemStatusItemBase() {
+        timeval tv;
+        gettimeofday(&tv, NULL);
+        mUtcTime.tv_sec  = tv.tv_sec;
+        mUtcTime.tv_nsec = tv.tv_usec*1000ULL;
+        mUtcReported = mUtcTime;
+    };
+    virtual ~SystemStatusItemBase() {};
+    inline virtual SystemStatusItemBase& collate(SystemStatusItemBase&) {
+        return *this;
+    }
+    virtual void dump(void) {};
+    inline virtual bool ignore() { return false; };
+};
+
+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(const SystemStatusLocation& peer);
+    void dump(void) override;
+};
+
+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;
+    uint64_t mTimeUncNs;
+    inline SystemStatusTimeAndClock() :
+        mGpsWeek(0),
+        mGpsTowMs(0),
+        mTimeValid(0),
+        mTimeSource(0),
+        mTimeUnc(0),
+        mClockFreqBias(0),
+        mClockFreqBiasUnc(0),
+        mLeapSeconds(0),
+        mLeapSecUnc(0),
+        mTimeUncNs(0ULL) {}
+    inline SystemStatusTimeAndClock(const SystemStatusPQWM1& nmea);
+    bool equals(const SystemStatusTimeAndClock& peer);
+    void dump(void) override;
+};
+
+class SystemStatusXoState : public SystemStatusItemBase
+{
+public:
+    uint8_t  mXoState;
+    inline SystemStatusXoState() :
+        mXoState(0) {}
+    inline SystemStatusXoState(const SystemStatusPQWM1& nmea);
+    bool equals(const SystemStatusXoState& peer);
+    void dump(void) override;
+};
+
+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;
+    uint32_t mGloBpAmpI;
+    uint32_t mGloBpAmpQ;
+    uint32_t mBdsBpAmpI;
+    uint32_t mBdsBpAmpQ;
+    uint32_t mGalBpAmpI;
+    uint32_t mGalBpAmpQ;
+    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),
+        mGloBpAmpI(0),
+        mGloBpAmpQ(0),
+        mBdsBpAmpI(0),
+        mBdsBpAmpQ(0),
+        mGalBpAmpI(0),
+        mGalBpAmpQ(0) {}
+    inline SystemStatusRfAndParams(const SystemStatusPQWM1& nmea);
+    bool equals(const SystemStatusRfAndParams& peer);
+    void dump(void) override;
+};
+
+class SystemStatusErrRecovery : public SystemStatusItemBase
+{
+public:
+    uint32_t mRecErrorRecovery;
+    inline SystemStatusErrRecovery() :
+        mRecErrorRecovery(0) {};
+    inline SystemStatusErrRecovery(const SystemStatusPQWM1& nmea);
+    bool equals(const SystemStatusErrRecovery& peer);
+    inline bool ignore() override { return 0 == mRecErrorRecovery; };
+    void dump(void) override;
+};
+
+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(const SystemStatusInjectedPosition& peer);
+    void dump(void) override;
+};
+
+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(const SystemStatusBestPosition& peer);
+    void dump(void) override;
+};
+
+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  mNavicXtraAge;
+    uint32_t  mGpsXtraValid;
+    uint32_t  mGloXtraValid;
+    uint64_t  mBdsXtraValid;
+    uint64_t  mGalXtraValid;
+    uint8_t   mQzssXtraValid;
+    uint32_t  mNavicXtraValid;
+    inline SystemStatusXtra() :
+        mXtraValidMask(0),
+        mGpsXtraAge(0),
+        mGloXtraAge(0),
+        mBdsXtraAge(0),
+        mGalXtraAge(0),
+        mQzssXtraAge(0),
+        mNavicXtraAge(0),
+        mGpsXtraValid(0),
+        mGloXtraValid(0),
+        mBdsXtraValid(0ULL),
+        mGalXtraValid(0ULL),
+        mQzssXtraValid(0),
+        mNavicXtraValid(0) {}
+    inline SystemStatusXtra(const SystemStatusPQWP3& nmea);
+    bool equals(const SystemStatusXtra& peer);
+    void dump(void) override;
+};
+
+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(const SystemStatusEphemeris& peer);
+    void dump(void) override;
+};
+
+class SystemStatusPQWP5;
+class SystemStatusSvHealth : public SystemStatusItemBase
+{
+public:
+    uint32_t  mGpsUnknownMask;
+    uint32_t  mGloUnknownMask;
+    uint64_t  mBdsUnknownMask;
+    uint64_t  mGalUnknownMask;
+    uint8_t   mQzssUnknownMask;
+    uint32_t  mNavicUnknownMask;
+    uint32_t  mGpsGoodMask;
+    uint32_t  mGloGoodMask;
+    uint64_t  mBdsGoodMask;
+    uint64_t  mGalGoodMask;
+    uint8_t   mQzssGoodMask;
+    uint32_t  mNavicGoodMask;
+    uint32_t  mGpsBadMask;
+    uint32_t  mGloBadMask;
+    uint64_t  mBdsBadMask;
+    uint64_t  mGalBadMask;
+    uint8_t   mQzssBadMask;
+    uint32_t  mNavicBadMask;
+    inline SystemStatusSvHealth() :
+        mGpsUnknownMask(0),
+        mGloUnknownMask(0),
+        mBdsUnknownMask(0ULL),
+        mGalUnknownMask(0ULL),
+        mQzssUnknownMask(0),
+        mNavicUnknownMask(0),
+        mGpsGoodMask(0),
+        mGloGoodMask(0),
+        mBdsGoodMask(0ULL),
+        mGalGoodMask(0ULL),
+        mQzssGoodMask(0),
+        mNavicGoodMask(0),
+        mGpsBadMask(0),
+        mGloBadMask(0),
+        mBdsBadMask(0ULL),
+        mGalBadMask(0ULL),
+        mQzssBadMask(0),
+        mNavicBadMask(0) {}
+    inline SystemStatusSvHealth(const SystemStatusPQWP5& nmea);
+    bool equals(const SystemStatusSvHealth& peer);
+    void dump(void) override;
+};
+
+class SystemStatusPQWP6;
+class SystemStatusPdr : public SystemStatusItemBase
+{
+public:
+    uint32_t  mFixInfoMask;
+    inline SystemStatusPdr() :
+        mFixInfoMask(0) {}
+    inline SystemStatusPdr(const SystemStatusPQWP6& nmea);
+    bool equals(const SystemStatusPdr& peer);
+    void dump(void) override;
+};
+
+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<SV_ALL_NUM; i++) {
+            mNav[i].mType = GNSS_EPH_TYPE_UNKNOWN;
+            mNav[i].mSource = GNSS_EPH_SOURCE_UNKNOWN;
+            mNav[i].mAgeSec = 0;
+        }
+    }
+    inline SystemStatusNavData(const SystemStatusPQWP7& nmea);
+    bool equals(const SystemStatusNavData& peer);
+    void dump(void) override;
+};
+
+class SystemStatusPQWS1;
+class SystemStatusPositionFailure : public SystemStatusItemBase
+{
+public:
+    uint32_t  mFixInfoMask;
+    uint32_t  mHepeLimit;
+    inline SystemStatusPositionFailure() :
+        mFixInfoMask(0),
+        mHepeLimit(0) {}
+    inline SystemStatusPositionFailure(const SystemStatusPQWS1& nmea);
+    bool equals(const SystemStatusPositionFailure& peer);
+    void dump(void) override;
+};
+
+/******************************************************************************
+ SystemStatus report data structure - from DataItem observer
+******************************************************************************/
+class SystemStatusAirplaneMode : public SystemStatusItemBase,
+        public AirplaneModeDataItemBase
+{
+public:
+    inline SystemStatusAirplaneMode(bool mode=false) :
+            AirplaneModeDataItemBase(mode) {}
+    inline SystemStatusAirplaneMode(const AirplaneModeDataItemBase& itemBase) :
+            AirplaneModeDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusAirplaneMode& peer) {
+        return (mMode == peer.mMode);
+    }
+};
+
+class SystemStatusENH : public SystemStatusItemBase,
+        public ENHDataItemBase
+{
+public:
+    inline SystemStatusENH(bool enabled=false) :
+            ENHDataItemBase(enabled) {}
+    inline SystemStatusENH(const ENHDataItemBase& itemBase) :
+            ENHDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusENH& peer) {
+        return (mEnabled == peer.mEnabled);
+    }
+};
+
+class SystemStatusGpsState : public SystemStatusItemBase,
+        public GPSStateDataItemBase
+{
+public:
+    inline SystemStatusGpsState(bool enabled=false) :
+            GPSStateDataItemBase(enabled) {}
+    inline SystemStatusGpsState(const GPSStateDataItemBase& itemBase) :
+            GPSStateDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusGpsState& peer) {
+        return (mEnabled == peer.mEnabled);
+    }
+    inline void dump(void) override {
+        LOC_LOGD("GpsState: state=%u", mEnabled);
+    }
+};
+
+class SystemStatusNLPStatus : public SystemStatusItemBase,
+        public NLPStatusDataItemBase
+{
+public:
+    inline SystemStatusNLPStatus(bool enabled=false) :
+            NLPStatusDataItemBase(enabled) {}
+    inline SystemStatusNLPStatus(const NLPStatusDataItemBase& itemBase) :
+            NLPStatusDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusNLPStatus& peer) {
+        return (mEnabled == peer.mEnabled);
+    }
+};
+
+class SystemStatusWifiHardwareState : public SystemStatusItemBase,
+        public WifiHardwareStateDataItemBase
+{
+public:
+    inline SystemStatusWifiHardwareState(bool enabled=false) :
+            WifiHardwareStateDataItemBase(enabled) {}
+    inline SystemStatusWifiHardwareState(const WifiHardwareStateDataItemBase& itemBase) :
+            WifiHardwareStateDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusWifiHardwareState& peer) {
+        return (mEnabled == peer.mEnabled);
+    }
+};
+
+class SystemStatusNetworkInfo : public SystemStatusItemBase,
+        public NetworkInfoDataItemBase
+{
+    NetworkInfoDataItemBase* mSrcObjPtr;
+public:
+    inline SystemStatusNetworkInfo(
+            int32_t type = 0,
+            std::string typeName = "",
+            string subTypeName = "",
+            bool connected = false,
+            bool roaming = false,
+            uint64_t networkHandle = NETWORK_HANDLE_UNKNOWN,
+            string apn = "") :
+            NetworkInfoDataItemBase(
+                    (NetworkType)type,
+                    type,
+                    typeName,
+                    subTypeName,
+                    connected && (!roaming),
+                    connected,
+                    roaming,
+                    networkHandle, apn),
+            mSrcObjPtr(nullptr) {}
+    inline SystemStatusNetworkInfo(const NetworkInfoDataItemBase& itemBase) :
+            NetworkInfoDataItemBase(itemBase),
+            mSrcObjPtr((NetworkInfoDataItemBase*)&itemBase) {
+        mType = (int32_t)itemBase.getType();
+    }
+    inline bool equals(const SystemStatusNetworkInfo& peer) {
+        bool rtv = (peer.mConnected == mConnected);
+        for (uint8_t i = 0; rtv && i < MAX_NETWORK_HANDLES; ++i) {
+            rtv &= (mAllNetworkHandles[i] == peer.mAllNetworkHandles[i]);
+        }
+        return rtv & peer.mApn.compare(mApn);
+    }
+    inline virtual SystemStatusItemBase& collate(SystemStatusItemBase& curInfo) {
+        LOC_LOGv("NetworkInfo: mAllTypes=%" PRIx64 " connected=%u mType=%x mApn=%s",
+                 mAllTypes, mConnected, mType, mApn.c_str());
+        uint64_t allTypes = (static_cast<SystemStatusNetworkInfo&>(curInfo)).mAllTypes;
+        string& apn = (static_cast<SystemStatusNetworkInfo&>(curInfo)).mApn;
+        // Replace current with cached table for now and then update
+        memcpy(mAllNetworkHandles,
+               (static_cast<SystemStatusNetworkInfo&>(curInfo)).getNetworkHandle(),
+               sizeof(mAllNetworkHandles));
+        // Update the apn for non-mobile type connections.
+        if (TYPE_MOBILE != mType && apn.compare("") != 0) {
+            mApn = apn;
+        }
+        if (mConnected) {
+            mAllTypes |= allTypes;
+            for (uint8_t i = 0; i < MAX_NETWORK_HANDLES; ++i) {
+                if (mNetworkHandle == mAllNetworkHandles[i].networkHandle) {
+                    LOC_LOGD("collate duplicate detected, not updating");
+                    break;
+                }
+                if (NETWORK_HANDLE_UNKNOWN == mAllNetworkHandles[i].networkHandle) {
+                    mAllNetworkHandles[i].networkHandle = mNetworkHandle;
+                    mAllNetworkHandles[i].networkType = (loc_core::NetworkType) mType;
+                    break;
+                }
+            }
+        } else if (0 != mAllTypes) {
+            uint8_t deletedIndex = MAX_NETWORK_HANDLES;
+            uint8_t lastValidIndex = 0;
+            uint8_t typeCount = 0;
+            for (; lastValidIndex < MAX_NETWORK_HANDLES &&
+                     NETWORK_HANDLE_UNKNOWN != mAllNetworkHandles[lastValidIndex].networkHandle;
+                 ++lastValidIndex) {
+                // Maintain count for number of network handles still
+                // connected for given type
+                if (mType == (int32_t)mAllNetworkHandles[lastValidIndex].networkType) {
+                    if (mNetworkHandle == mAllNetworkHandles[lastValidIndex].networkHandle) {
+                        deletedIndex = lastValidIndex;
+                    } else {
+                        typeCount++;
+                    }
+                }
+
+            }
+            if (lastValidIndex > 0) {
+                --lastValidIndex;
+            }
+
+            if (MAX_NETWORK_HANDLES != deletedIndex) {
+                LOC_LOGd("deletedIndex:%u, lastValidIndex:%u, typeCount:%u",
+                        deletedIndex, lastValidIndex, typeCount);
+                mAllNetworkHandles[deletedIndex] = mAllNetworkHandles[lastValidIndex];
+                mAllNetworkHandles[lastValidIndex].networkHandle = NETWORK_HANDLE_UNKNOWN;
+                mAllNetworkHandles[lastValidIndex].networkType = TYPE_UNKNOWN;
+            }
+
+            // If no more handles of given type, set bitmask
+            if (0 == typeCount) {
+                mAllTypes = (allTypes & (~mAllTypes));
+                LOC_LOGD("mAllTypes:%" PRIx64, mAllTypes);
+            }
+        } // else (mConnected == false && mAllTypes == 0)
+          // we keep mAllTypes as 0, which means no more connections.
+
+        if (nullptr != mSrcObjPtr) {
+            // this is critical, changing mAllTypes of the original obj
+            mSrcObjPtr->mAllTypes = mAllTypes;
+            memcpy(mSrcObjPtr->mAllNetworkHandles,
+                   mAllNetworkHandles,
+                   sizeof(mSrcObjPtr->mAllNetworkHandles));
+        }
+        return *this;
+    }
+    inline void dump(void) override {
+        LOC_LOGD("NetworkInfo: mAllTypes=%" PRIx64 " connected=%u mType=%x mApn=%s",
+                 mAllTypes, mConnected, mType, mApn.c_str());
+    }
+};
+
+class SystemStatusServiceInfo : public SystemStatusItemBase,
+        public RilServiceInfoDataItemBase
+{
+public:
+    inline SystemStatusServiceInfo() :
+            RilServiceInfoDataItemBase() {}
+    inline SystemStatusServiceInfo(const RilServiceInfoDataItemBase& itemBase) :
+            RilServiceInfoDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusServiceInfo& peer) {
+        return static_cast<const RilServiceInfoDataItemBase&>(peer) ==
+                static_cast<const RilServiceInfoDataItemBase&>(*this);
+    }
+};
+
+class SystemStatusRilCellInfo : public SystemStatusItemBase,
+        public RilCellInfoDataItemBase
+{
+public:
+    inline SystemStatusRilCellInfo() :
+            RilCellInfoDataItemBase() {}
+    inline SystemStatusRilCellInfo(const RilCellInfoDataItemBase& itemBase) :
+            RilCellInfoDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusRilCellInfo& peer) {
+        return static_cast<const RilCellInfoDataItemBase&>(peer) ==
+                static_cast<const RilCellInfoDataItemBase&>(*this);
+    }
+};
+
+class SystemStatusServiceStatus : public SystemStatusItemBase,
+        public ServiceStatusDataItemBase
+{
+public:
+    inline SystemStatusServiceStatus(int32_t mServiceState=0) :
+            ServiceStatusDataItemBase(mServiceState) {}
+    inline SystemStatusServiceStatus(const ServiceStatusDataItemBase& itemBase) :
+            ServiceStatusDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusServiceStatus& peer) {
+        return (mServiceState == peer.mServiceState);
+    }
+};
+
+class SystemStatusModel : public SystemStatusItemBase,
+        public ModelDataItemBase
+{
+public:
+    inline SystemStatusModel(string name="") :
+            ModelDataItemBase(name) {}
+    inline SystemStatusModel(const ModelDataItemBase& itemBase) :
+            ModelDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusModel& peer) {
+        return (mModel == peer.mModel);
+        }
+};
+
+class SystemStatusManufacturer : public SystemStatusItemBase,
+        public ManufacturerDataItemBase
+{
+public:
+    inline SystemStatusManufacturer(string name="") :
+            ManufacturerDataItemBase(name) {}
+    inline SystemStatusManufacturer(const ManufacturerDataItemBase& itemBase) :
+            ManufacturerDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusManufacturer& peer) {
+        return (mManufacturer == peer.mManufacturer);
+    }
+};
+
+class SystemStatusAssistedGps : public SystemStatusItemBase,
+        public AssistedGpsDataItemBase
+{
+public:
+    inline SystemStatusAssistedGps(bool enabled=false) :
+            AssistedGpsDataItemBase(enabled) {}
+    inline SystemStatusAssistedGps(const AssistedGpsDataItemBase& itemBase) :
+            AssistedGpsDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusAssistedGps& peer) {
+        return (mEnabled == peer.mEnabled);
+    }
+};
+
+class SystemStatusScreenState : public SystemStatusItemBase,
+        public ScreenStateDataItemBase
+{
+public:
+    inline SystemStatusScreenState(bool state=false) :
+            ScreenStateDataItemBase(state) {}
+    inline SystemStatusScreenState(const ScreenStateDataItemBase& itemBase) :
+            ScreenStateDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusScreenState& peer) {
+        return (mState == peer.mState);
+    }
+};
+
+class SystemStatusPowerConnectState : public SystemStatusItemBase,
+        public PowerConnectStateDataItemBase
+{
+public:
+    inline SystemStatusPowerConnectState(bool state=false) :
+            PowerConnectStateDataItemBase(state) {}
+    inline SystemStatusPowerConnectState(const PowerConnectStateDataItemBase& itemBase) :
+            PowerConnectStateDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusPowerConnectState& peer) {
+        return (mState == peer.mState);
+    }
+};
+
+class SystemStatusTimeZoneChange : public SystemStatusItemBase,
+        public TimeZoneChangeDataItemBase
+{
+public:
+    inline SystemStatusTimeZoneChange(
+            int64_t currTimeMillis=0ULL, int32_t rawOffset=0, int32_t dstOffset=0) :
+            TimeZoneChangeDataItemBase(currTimeMillis, rawOffset, dstOffset) {}
+    inline SystemStatusTimeZoneChange(const TimeZoneChangeDataItemBase& itemBase) :
+            TimeZoneChangeDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusTimeZoneChange& peer) {
+        return ((mCurrTimeMillis == peer.mCurrTimeMillis) &&
+                (mRawOffsetTZ == peer.mRawOffsetTZ) &&
+                (mDstOffsetTZ == peer.mDstOffsetTZ));
+    }
+};
+
+class SystemStatusTimeChange : public SystemStatusItemBase,
+        public TimeChangeDataItemBase
+{
+public:
+    inline SystemStatusTimeChange(
+            int64_t currTimeMillis=0ULL, int32_t rawOffset=0, int32_t dstOffset=0) :
+            TimeChangeDataItemBase(currTimeMillis, rawOffset, dstOffset) {}
+    inline SystemStatusTimeChange(const TimeChangeDataItemBase& itemBase) :
+            TimeChangeDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusTimeChange& peer) {
+        return ((mCurrTimeMillis == peer.mCurrTimeMillis) &&
+                (mRawOffsetTZ == peer.mRawOffsetTZ) &&
+                (mDstOffsetTZ == peer.mDstOffsetTZ));
+    }
+};
+
+class SystemStatusWifiSupplicantStatus : public SystemStatusItemBase,
+        public WifiSupplicantStatusDataItemBase
+{
+public:
+    inline SystemStatusWifiSupplicantStatus() :
+            WifiSupplicantStatusDataItemBase() {}
+    inline SystemStatusWifiSupplicantStatus(const WifiSupplicantStatusDataItemBase& itemBase) :
+            WifiSupplicantStatusDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusWifiSupplicantStatus& peer) {
+        return ((mState == peer.mState) &&
+                (mApMacAddressValid == peer.mApMacAddressValid) &&
+                (mWifiApSsidValid == peer.mWifiApSsidValid) &&
+                (mWifiApSsid == peer.mWifiApSsid));
+        }
+};
+
+class SystemStatusShutdownState : public SystemStatusItemBase,
+        public ShutdownStateDataItemBase
+{
+public:
+    inline SystemStatusShutdownState(bool state=false) :
+            ShutdownStateDataItemBase(state) {}
+    inline SystemStatusShutdownState(const ShutdownStateDataItemBase& itemBase) :
+            ShutdownStateDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusShutdownState& peer) {
+        return (mState == peer.mState);
+    }
+};
+
+class SystemStatusTac : public SystemStatusItemBase,
+        public TacDataItemBase
+{
+public:
+    inline SystemStatusTac(std::string value="") :
+            TacDataItemBase(value) {}
+    inline SystemStatusTac(const TacDataItemBase& itemBase) :
+            TacDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusTac& peer) {
+        return (mValue == peer.mValue);
+    }
+    inline void dump(void) override {
+        LOC_LOGD("Tac: value=%s", mValue.c_str());
+    }
+};
+
+class SystemStatusMccMnc : public SystemStatusItemBase,
+        public MccmncDataItemBase
+{
+public:
+    inline SystemStatusMccMnc(std::string value="") :
+            MccmncDataItemBase(value) {}
+    inline SystemStatusMccMnc(const MccmncDataItemBase& itemBase) :
+            MccmncDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusMccMnc& peer) {
+        return (mValue == peer.mValue);
+    }
+    inline void dump(void) override {
+        LOC_LOGD("TacMccMnc value=%s", mValue.c_str());
+    }
+};
+
+class SystemStatusBtDeviceScanDetail : public SystemStatusItemBase,
+        public BtDeviceScanDetailsDataItemBase
+{
+public:
+    inline SystemStatusBtDeviceScanDetail() :
+            BtDeviceScanDetailsDataItemBase() {}
+    inline SystemStatusBtDeviceScanDetail(const BtDeviceScanDetailsDataItemBase& itemBase) :
+            BtDeviceScanDetailsDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusBtDeviceScanDetail& peer) {
+        return ((mApSrnRssi == peer.mApSrnRssi) &&
+                (0 == memcmp(mApSrnMacAddress, peer.mApSrnMacAddress, sizeof(mApSrnMacAddress))) &&
+                (mApSrnTimestamp == peer.mApSrnTimestamp) &&
+                (mRequestTimestamp == peer.mRequestTimestamp) &&
+                (mReceiveTimestamp == peer.mReceiveTimestamp));
+    }
+};
+
+class SystemStatusBtleDeviceScanDetail : public SystemStatusItemBase,
+        public BtLeDeviceScanDetailsDataItemBase
+{
+public:
+    inline SystemStatusBtleDeviceScanDetail() :
+            BtLeDeviceScanDetailsDataItemBase() {}
+    inline SystemStatusBtleDeviceScanDetail(const BtLeDeviceScanDetailsDataItemBase& itemBase) :
+            BtLeDeviceScanDetailsDataItemBase(itemBase) {}
+    inline bool equals(const SystemStatusBtleDeviceScanDetail& peer) {
+        return ((mApSrnRssi == peer.mApSrnRssi) &&
+                (0 == memcmp(mApSrnMacAddress, peer.mApSrnMacAddress, sizeof(mApSrnMacAddress))) &&
+                (mApSrnTimestamp == peer.mApSrnTimestamp) &&
+                (mRequestTimestamp == peer.mRequestTimestamp) &&
+                (mReceiveTimestamp == peer.mReceiveTimestamp));
+    }
+};
+
+/******************************************************************************
+ SystemStatusReports
+******************************************************************************/
+class SystemStatusReports
+{
+public:
+    // from QMI_LOC indication
+    std::vector<SystemStatusLocation>         mLocation;
+
+    // from ME debug NMEA
+    std::vector<SystemStatusTimeAndClock>     mTimeAndClock;
+    std::vector<SystemStatusXoState>          mXoState;
+    std::vector<SystemStatusRfAndParams>      mRfAndParams;
+    std::vector<SystemStatusErrRecovery>      mErrRecovery;
+
+    // from PE debug NMEA
+    std::vector<SystemStatusInjectedPosition> mInjectedPosition;
+    std::vector<SystemStatusBestPosition>     mBestPosition;
+    std::vector<SystemStatusXtra>             mXtra;
+    std::vector<SystemStatusEphemeris>        mEphemeris;
+    std::vector<SystemStatusSvHealth>         mSvHealth;
+    std::vector<SystemStatusPdr>              mPdr;
+    std::vector<SystemStatusNavData>          mNavData;
+
+    // from SM debug NMEA
+    std::vector<SystemStatusPositionFailure>  mPositionFailure;
+
+    // from dataitems observer
+    std::vector<SystemStatusAirplaneMode>     mAirplaneMode;
+    std::vector<SystemStatusENH>              mENH;
+    std::vector<SystemStatusGpsState>         mGPSState;
+    std::vector<SystemStatusNLPStatus>        mNLPStatus;
+    std::vector<SystemStatusWifiHardwareState> mWifiHardwareState;
+    std::vector<SystemStatusNetworkInfo>      mNetworkInfo;
+    std::vector<SystemStatusServiceInfo>      mRilServiceInfo;
+    std::vector<SystemStatusRilCellInfo>      mRilCellInfo;
+    std::vector<SystemStatusServiceStatus>    mServiceStatus;
+    std::vector<SystemStatusModel>            mModel;
+    std::vector<SystemStatusManufacturer>     mManufacturer;
+    std::vector<SystemStatusAssistedGps>      mAssistedGps;
+    std::vector<SystemStatusScreenState>      mScreenState;
+    std::vector<SystemStatusPowerConnectState> mPowerConnectState;
+    std::vector<SystemStatusTimeZoneChange>   mTimeZoneChange;
+    std::vector<SystemStatusTimeChange>       mTimeChange;
+    std::vector<SystemStatusWifiSupplicantStatus> mWifiSupplicantStatus;
+    std::vector<SystemStatusShutdownState>    mShutdownState;
+    std::vector<SystemStatusTac>              mTac;
+    std::vector<SystemStatusMccMnc>           mMccMnc;
+    std::vector<SystemStatusBtDeviceScanDetail> mBtDeviceScanDetail;
+    std::vector<SystemStatusBtleDeviceScanDetail> mBtLeDeviceScanDetail;
+};
+
+/******************************************************************************
+ SystemStatus
+******************************************************************************/
+class SystemStatus
+{
+private:
+    static SystemStatus                       *mInstance;
+    SystemStatusOsObserver                    mSysStatusObsvr;
+    // ctor
+    SystemStatus(const MsgTask* msgTask);
+    // dtor
+    inline ~SystemStatus() {}
+
+    // Data members
+    static pthread_mutex_t                    mMutexSystemStatus;
+    SystemStatusReports mCache;
+
+    template <typename TYPE_REPORT, typename TYPE_ITEM>
+    bool setIteminReport(TYPE_REPORT& report, TYPE_ITEM&& s);
+
+    // set default dataitem derived item in report cache
+    template <typename TYPE_REPORT, typename TYPE_ITEM>
+    void setDefaultIteminReport(TYPE_REPORT& report, const TYPE_ITEM& s);
+
+    template <typename TYPE_REPORT, typename TYPE_ITEM>
+    void getIteminReport(TYPE_REPORT& reportout, const TYPE_ITEM& c) const;
+
+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 setDefaultGnssEngineStates(void);
+    bool eventConnectionStatus(bool connected, int8_t type,
+                               bool roaming, NetworkHandle networkHandle, string& apn);
+    bool updatePowerConnectState(bool charging);
+    void resetNetworkInfo();
+};
+
+} // namespace loc_core
+
+#endif //__SYSTEM_STATUS__
+

gps/core/SystemStatusOsObserver.cpp

@@ -0,0 +1,592 @@
+/* Copyright (c) 2015-2020, 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 <algorithm>
+#include <SystemStatus.h>
+#include <SystemStatusOsObserver.h>
+#include <IDataItemCore.h>
+#include <DataItemsFactoryProxy.h>
+
+namespace loc_core
+{
+template <typename CINT, typename COUT>
+COUT SystemStatusOsObserver::containerTransfer(CINT& inContainer) {
+    COUT outContainer = {};
+    for (auto item : inContainer) {
+        outContainer.insert(outContainer.begin(), item);
+    }
+    return outContainer;
+}
+
+SystemStatusOsObserver::~SystemStatusOsObserver() {
+    // Close data-item library handle
+    DataItemsFactoryProxy::closeDataItemLibraryHandle();
+
+    // Destroy cache
+    for (auto each : mDataItemCache) {
+        if (nullptr != each.second) {
+            delete each.second;
+        }
+    }
+
+    mDataItemCache.clear();
+}
+
+void SystemStatusOsObserver::setSubscriptionObj(IDataItemSubscription* subscriptionObj)
+{
+    struct SetSubsObj : public LocMsg {
+        ObserverContext& mContext;
+        IDataItemSubscription* mSubsObj;
+        inline SetSubsObj(ObserverContext& context, IDataItemSubscription* subscriptionObj) :
+                mContext(context), mSubsObj(subscriptionObj) {}
+        void proc() const {
+            LOC_LOGi("SetSubsObj::enter");
+            mContext.mSubscriptionObj = mSubsObj;
+
+            if (!mContext.mSSObserver->mDataItemToClients.empty()) {
+                list<DataItemId> dis(
+                        containerTransfer<unordered_set<DataItemId>, list<DataItemId>>(
+                                mContext.mSSObserver->mDataItemToClients.getKeys()));
+                mContext.mSubscriptionObj->subscribe(dis, mContext.mSSObserver);
+                mContext.mSubscriptionObj->requestData(dis, mContext.mSSObserver);
+            }
+            LOC_LOGi("SetSubsObj::exit");
+        }
+    };
+
+    if (nullptr == subscriptionObj) {
+        LOC_LOGw("subscriptionObj is NULL");
+    } else {
+        mContext.mMsgTask->sendMsg(new SetSubsObj(mContext, subscriptionObj));
+    }
+}
+
+/******************************************************************************
+ IDataItemSubscription Overrides
+******************************************************************************/
+void SystemStatusOsObserver::subscribe(const list<DataItemId>& l, IDataItemObserver* client,
+                                       bool toRequestData)
+{
+    struct HandleSubscribeReq : public LocMsg {
+        inline HandleSubscribeReq(SystemStatusOsObserver* parent,
+                list<DataItemId>& l, IDataItemObserver* client, bool requestData) :
+                mParent(parent), mClient(client),
+                mDataItemSet(containerTransfer<list<DataItemId>, unordered_set<DataItemId>>(l)),
+                diItemlist(l),
+                mToRequestData(requestData) {}
+
+        void proc() const {
+            unordered_set<DataItemId> dataItemsToSubscribe = {};
+            mParent->mDataItemToClients.add(mDataItemSet, {mClient}, &dataItemsToSubscribe);
+            mParent->mClientToDataItems.add(mClient, mDataItemSet);
+
+            mParent->sendCachedDataItems(mDataItemSet, mClient);
+
+            // Send subscription set to framework
+            if (nullptr != mParent->mContext.mSubscriptionObj) {
+                if (mToRequestData) {
+                    LOC_LOGD("Request Data sent to framework for the following");
+                    mParent->mContext.mSubscriptionObj->requestData(diItemlist, mParent);
+                } else if (!dataItemsToSubscribe.empty()) {
+                    LOC_LOGD("Subscribe Request sent to framework for the following");
+                    mParent->logMe(dataItemsToSubscribe);
+                    mParent->mContext.mSubscriptionObj->subscribe(
+                            containerTransfer<unordered_set<DataItemId>, list<DataItemId>>(
+                                    std::move(dataItemsToSubscribe)),
+                            mParent);
+                }
+            }
+        }
+        mutable SystemStatusOsObserver* mParent;
+        IDataItemObserver* mClient;
+        const unordered_set<DataItemId> mDataItemSet;
+        const list<DataItemId> diItemlist;
+        bool mToRequestData;
+    };
+
+    if (l.empty() || nullptr == client) {
+        LOC_LOGw("Data item set is empty or client is nullptr");
+    } else {
+        mContext.mMsgTask->sendMsg(
+                new HandleSubscribeReq(this, (list<DataItemId>&)l, client, toRequestData));
+    }
+}
+
+void SystemStatusOsObserver::updateSubscription(
+        const list<DataItemId>& l, IDataItemObserver* client)
+{
+    struct HandleUpdateSubscriptionReq : public LocMsg {
+        HandleUpdateSubscriptionReq(SystemStatusOsObserver* parent,
+                                    list<DataItemId>& l, IDataItemObserver* client) :
+                mParent(parent), mClient(client),
+                mDataItemSet(containerTransfer<list<DataItemId>, unordered_set<DataItemId>>(l)) {}
+
+        void proc() const {
+            unordered_set<DataItemId> dataItemsToSubscribe = {};
+            unordered_set<DataItemId> dataItemsToUnsubscribe = {};
+            unordered_set<IDataItemObserver*> clients({mClient});
+            // below removes clients from all entries keyed with the return of the
+            // mClientToDataItems.update() call. If leaving an empty set of clients as the
+            // result, the entire entry will be removed. dataItemsToUnsubscribe will be
+            // populated to keep the keys of the removed entries.
+            mParent->mDataItemToClients.trimOrRemove(
+                    // this call updates <IDataItemObserver*, DataItemId> map; removes
+                    // the DataItemId's that are not new to the clietn from mDataItemSet;
+                    // and returns a set of mDataItemSet's that are no longer used by client.
+                    // This unused set of mDataItemSet's is passed to trimOrRemove method of
+                    // <DataItemId, IDataItemObserver*> map to remove the client from the
+                    // corresponding entries, and gets a set of the entries that are
+                    // removed from the <DataItemId, IDataItemObserver*> map as a result.
+                    mParent->mClientToDataItems.update(mClient,
+                                                       (unordered_set<DataItemId>&)mDataItemSet),
+                    clients, &dataItemsToUnsubscribe, nullptr);
+            // below adds mClient to <DataItemId, IDataItemObserver*> map, and populates
+            // new keys added to that map, which are DataItemIds to be subscribed.
+            mParent->mDataItemToClients.add(mDataItemSet, clients, &dataItemsToSubscribe);
+
+            // Send First Response
+            mParent->sendCachedDataItems(mDataItemSet, mClient);
+
+            if (nullptr != mParent->mContext.mSubscriptionObj) {
+                // Send subscription set to framework
+                if (!dataItemsToSubscribe.empty()) {
+                    LOC_LOGD("Subscribe Request sent to framework for the following");
+                    mParent->logMe(dataItemsToSubscribe);
+
+                    mParent->mContext.mSubscriptionObj->subscribe(
+                            containerTransfer<unordered_set<DataItemId>, list<DataItemId>>(
+                                    std::move(dataItemsToSubscribe)),
+                            mParent);
+                }
+
+                // Send unsubscribe to framework
+                if (!dataItemsToUnsubscribe.empty()) {
+                    LOC_LOGD("Unsubscribe Request sent to framework for the following");
+                    mParent->logMe(dataItemsToUnsubscribe);
+
+                    mParent->mContext.mSubscriptionObj->unsubscribe(
+                            containerTransfer<unordered_set<DataItemId>, list<DataItemId>>(
+                                    std::move(dataItemsToUnsubscribe)),
+                            mParent);
+                }
+            }
+        }
+        SystemStatusOsObserver* mParent;
+        IDataItemObserver* mClient;
+        unordered_set<DataItemId> mDataItemSet;
+    };
+
+    if (l.empty() || nullptr == client) {
+        LOC_LOGw("Data item set is empty or client is nullptr");
+    } else {
+        mContext.mMsgTask->sendMsg(
+                new HandleUpdateSubscriptionReq(this, (list<DataItemId>&)l, client));
+    }
+}
+
+void SystemStatusOsObserver::unsubscribe(
+        const list<DataItemId>& l, IDataItemObserver* client)
+{
+    struct HandleUnsubscribeReq : public LocMsg {
+        HandleUnsubscribeReq(SystemStatusOsObserver* parent,
+                list<DataItemId>& l, IDataItemObserver* client) :
+                mParent(parent), mClient(client),
+                mDataItemSet(containerTransfer<list<DataItemId>, unordered_set<DataItemId>>(l)) {}
+
+        void proc() const {
+            unordered_set<DataItemId> dataItemsUnusedByClient = {};
+            unordered_set<IDataItemObserver*> clientToRemove = {};
+            unordered_set<DataItemId> dataItemsToUnsubscribe = {};
+            mParent->mClientToDataItems.trimOrRemove({mClient}, mDataItemSet,  &clientToRemove,
+                                                     &dataItemsUnusedByClient);
+            mParent->mDataItemToClients.trimOrRemove(dataItemsUnusedByClient, {mClient},
+                                                     &dataItemsToUnsubscribe, nullptr);
+
+            if (nullptr != mParent->mContext.mSubscriptionObj && !dataItemsToUnsubscribe.empty()) {
+                LOC_LOGD("Unsubscribe Request sent to framework for the following data items");
+                mParent->logMe(dataItemsToUnsubscribe);
+
+                // Send unsubscribe to framework
+                mParent->mContext.mSubscriptionObj->unsubscribe(
+                        containerTransfer<unordered_set<DataItemId>, list<DataItemId>>(
+                                  std::move(dataItemsToUnsubscribe)),
+                        mParent);
+            }
+        }
+        SystemStatusOsObserver* mParent;
+        IDataItemObserver* mClient;
+        unordered_set<DataItemId> mDataItemSet;
+    };
+
+    if (l.empty() || nullptr == client) {
+        LOC_LOGw("Data item set is empty or client is nullptr");
+    } else {
+        mContext.mMsgTask->sendMsg(new HandleUnsubscribeReq(this, (list<DataItemId>&)l, client));
+    }
+}
+
+void SystemStatusOsObserver::unsubscribeAll(IDataItemObserver* client)
+{
+    struct HandleUnsubscribeAllReq : public LocMsg {
+        HandleUnsubscribeAllReq(SystemStatusOsObserver* parent,
+                IDataItemObserver* client) :
+                mParent(parent), mClient(client) {}
+
+        void proc() const {
+            unordered_set<DataItemId> diByClient = mParent->mClientToDataItems.getValSet(mClient);
+
+            if (!diByClient.empty()) {
+                unordered_set<DataItemId> dataItemsToUnsubscribe;
+                mParent->mClientToDataItems.remove(mClient);
+                mParent->mDataItemToClients.trimOrRemove(diByClient, {mClient},
+                                                         &dataItemsToUnsubscribe, nullptr);
+
+                if (!dataItemsToUnsubscribe.empty() &&
+                    nullptr != mParent->mContext.mSubscriptionObj) {
+
+                    LOC_LOGD("Unsubscribe Request sent to framework for the following data items");
+                    mParent->logMe(dataItemsToUnsubscribe);
+
+                    // Send unsubscribe to framework
+                    mParent->mContext.mSubscriptionObj->unsubscribe(
+                            containerTransfer<unordered_set<DataItemId>, list<DataItemId>>(
+                                    std::move(dataItemsToUnsubscribe)),
+                            mParent);
+                }
+            }
+        }
+        SystemStatusOsObserver* mParent;
+        IDataItemObserver* mClient;
+    };
+
+    if (nullptr == client) {
+        LOC_LOGw("Data item set is empty or client is nullptr");
+    } else {
+        mContext.mMsgTask->sendMsg(new HandleUnsubscribeAllReq(this, client));
+    }
+}
+
+/******************************************************************************
+ IDataItemObserver Overrides
+******************************************************************************/
+void SystemStatusOsObserver::notify(const list<IDataItemCore*>& dlist)
+{
+    struct HandleNotify : public LocMsg {
+        HandleNotify(SystemStatusOsObserver* parent, vector<IDataItemCore*>& v) :
+                mParent(parent), mDiVec(std::move(v)) {}
+
+        inline virtual ~HandleNotify() {
+            for (auto item : mDiVec) {
+                delete item;
+            }
+        }
+
+        void proc() const {
+            // Update Cache with received data items and prepare
+            // list of data items to be sent.
+            unordered_set<DataItemId> dataItemIdsToBeSent = {};
+            for (auto item : mDiVec) {
+                if (mParent->updateCache(item)) {
+                    dataItemIdsToBeSent.insert(item->getId());
+                }
+            }
+
+            // Send data item to all subscribed clients
+            unordered_set<IDataItemObserver*> clientSet = {};
+            for (auto each : dataItemIdsToBeSent) {
+                auto clients = mParent->mDataItemToClients.getValSetPtr(each);
+                if (nullptr != clients) {
+                    clientSet.insert(clients->begin(), clients->end());
+                }
+            }
+
+            for (auto client : clientSet) {
+                unordered_set<DataItemId> dataItemIdsForThisClient(
+                        mParent->mClientToDataItems.getValSet(client));
+                for (auto itr = dataItemIdsForThisClient.begin();
+                        itr != dataItemIdsForThisClient.end(); ) {
+                    if (dataItemIdsToBeSent.find(*itr) == dataItemIdsToBeSent.end()) {
+                        itr = dataItemIdsForThisClient.erase(itr);
+                    } else {
+                        itr++;
+                    }
+                }
+
+                mParent->sendCachedDataItems(dataItemIdsForThisClient, client);
+            }
+        }
+        SystemStatusOsObserver* mParent;
+        const vector<IDataItemCore*> mDiVec;
+    };
+
+    if (!dlist.empty()) {
+        vector<IDataItemCore*> dataItemVec(dlist.size());
+
+        for (auto each : dlist) {
+
+            IDataItemCore* di = DataItemsFactoryProxy::createNewDataItem(each->getId());
+            if (nullptr == di) {
+                LOC_LOGw("Unable to create dataitem:%d", each->getId());
+                continue;
+            }
+
+            // Copy contents into the newly created data item
+            di->copy(each);
+
+            // add this dataitem if updated from last one
+            dataItemVec.push_back(di);
+            IF_LOC_LOGD {
+                string dv;
+                di->stringify(dv);
+                LOC_LOGd("notify: DataItem In Value:%s", dv.c_str());
+            }
+        }
+
+        if (!dataItemVec.empty()) {
+            mContext.mMsgTask->sendMsg(new HandleNotify(this, dataItemVec));
+        }
+    }
+}
+
+/******************************************************************************
+ 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
+    DataItemIdToInt::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<DataItemId, int> 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(mContext.mFrameworkActionReqObj, 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
+    DataItemIdToInt::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));
+        }
+    }
+}
+
+#ifdef USE_GLIB
+bool SystemStatusOsObserver::connectBackhaul(const string& clientName)
+{
+    bool result = false;
+
+    if (mContext.mFrameworkActionReqObj != NULL) {
+        struct HandleConnectBackhaul : public LocMsg {
+            HandleConnectBackhaul(IFrameworkActionReq* fwkActReq, const string& clientName) :
+                    mClientName(clientName), mFwkActionReqObj(fwkActReq) {}
+            virtual ~HandleConnectBackhaul() {}
+            void proc() const {
+                LOC_LOGi("HandleConnectBackhaul::enter");
+                mFwkActionReqObj->connectBackhaul(mClientName);
+                LOC_LOGi("HandleConnectBackhaul::exit");
+            }
+            IFrameworkActionReq* mFwkActionReqObj;
+            string mClientName;
+        };
+        mContext.mMsgTask->sendMsg(
+                new (nothrow) HandleConnectBackhaul(mContext.mFrameworkActionReqObj, clientName));
+        result = true;
+    }
+    else {
+        LOC_LOGe("Framework action request object is NULL.Caching connect request: %s",
+                clientName.c_str());
+        ClientBackhaulReqCache::const_iterator iter = mBackHaulConnReqCache.find(clientName);
+        if (iter == mBackHaulConnReqCache.end()) {
+            // not found in set. first time receiving from request from client
+            LOC_LOGe("Adding client to BackHaulConnReqCache list");
+            mBackHaulConnReqCache.insert(clientName);
+        }
+        result = false;
+    }
+    return result;
+
+}
+
+bool SystemStatusOsObserver::disconnectBackhaul(const string& clientName)
+{
+    bool result = false;
+
+    if (mContext.mFrameworkActionReqObj != NULL) {
+        struct HandleDisconnectBackhaul : public LocMsg {
+            HandleDisconnectBackhaul(IFrameworkActionReq* fwkActReq, const string& clientName) :
+                    mClientName(clientName), mFwkActionReqObj(fwkActReq) {}
+            virtual ~HandleDisconnectBackhaul() {}
+            void proc() const {
+                LOC_LOGi("HandleDisconnectBackhaul::enter");
+                mFwkActionReqObj->disconnectBackhaul(mClientName);
+                LOC_LOGi("HandleDisconnectBackhaul::exit");
+            }
+            IFrameworkActionReq* mFwkActionReqObj;
+            string mClientName;
+        };
+        mContext.mMsgTask->sendMsg(
+                new (nothrow) HandleDisconnectBackhaul(mContext.mFrameworkActionReqObj,
+                        clientName));
+    }
+    else {
+        LOC_LOGe("Framework action request object is NULL.Caching disconnect request: %s",
+                clientName.c_str());
+        // Check if client has requested for backhaul connection.
+        ClientBackhaulReqCache::const_iterator iter = mBackHaulConnReqCache.find(clientName);
+        if (iter != mBackHaulConnReqCache.end()) {
+            // client found, remove from set.
+            LOC_LOGd("Removing client from BackHaulConnReqCache list");
+            mBackHaulConnReqCache.erase(iter);
+        }
+        result = false;
+    }
+    return result;
+}
+#endif
+/******************************************************************************
+ Helpers
+******************************************************************************/
+void SystemStatusOsObserver::sendCachedDataItems(
+        const unordered_set<DataItemId>& s, IDataItemObserver* to)
+{
+    if (nullptr == to) {
+        LOC_LOGv("client pointer is NULL.");
+    } else {
+        string clientName;
+        to->getName(clientName);
+        list<IDataItemCore*> dataItems = {};
+
+        for (auto each : s) {
+            auto 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_front(citer->second);
+            }
+        }
+
+        if (dataItems.empty()) {
+            LOC_LOGv("No items to notify.");
+        } else {
+            to->notify(dataItems);
+        }
+    }
+}
+
+bool SystemStatusOsObserver::updateCache(IDataItemCore* d)
+{
+    bool dataItemUpdated = false;
+
+    // Request systemstatus to record this dataitem in its cache
+    // if the return is false, it means that SystemStatus is not
+    // handling it, so SystemStatusOsObserver also doesn't.
+    // So it has to be true to proceed.
+    if (nullptr != d && mSystemStatus->eventDataItemNotify(d)) {
+        auto 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) {
+                // Copy the contents of the data item
+                dataitem->copy(d);
+                // Insert in mDataItemCache
+                mDataItemCache.insert(std::make_pair(d->getId(), dataitem));
+                dataItemUpdated = true;
+            }
+        } else {
+            // Found in cache; Update cache if necessary
+            citer->second->copy(d, &dataItemUpdated);
+        }
+
+        if (dataItemUpdated) {
+            LOC_LOGV("DataItem:%d updated:%d", d->getId(), dataItemUpdated);
+        }
+    }
+
+    return dataItemUpdated;
+}
+
+} // namespace loc_core
+

gps/core/SystemStatusOsObserver.h

@@ -0,0 +1,181 @@
+/* Copyright (c) 2015-2017, 2020 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 <cinttypes>
+#include <string>
+#include <list>
+#include <map>
+#include <new>
+#include <vector>
+
+#include <MsgTask.h>
+#include <DataItemId.h>
+#include <IOsObserver.h>
+#include <loc_pla.h>
+#include <log_util.h>
+#include <LocUnorderedSetMap.h>
+
+namespace loc_core
+{
+/******************************************************************************
+ SystemStatusOsObserver
+******************************************************************************/
+using namespace std;
+using namespace loc_util;
+
+// Forward Declarations
+class IDataItemCore;
+class SystemStatus;
+class SystemStatusOsObserver;
+typedef map<IDataItemObserver*, list<DataItemId>> ObserverReqCache;
+typedef LocUnorderedSetMap<IDataItemObserver*, DataItemId> ClientToDataItems;
+typedef LocUnorderedSetMap<DataItemId, IDataItemObserver*> DataItemToClients;
+typedef unordered_map<DataItemId, IDataItemCore*> DataItemIdToCore;
+typedef unordered_map<DataItemId, int> DataItemIdToInt;
+#ifdef USE_GLIB
+// Cache details of backhaul client requests
+typedef unordered_set<string> ClientBackhaulReqCache;
+#endif
+
+struct ObserverContext {
+    IDataItemSubscription* mSubscriptionObj;
+    IFrameworkActionReq* mFrameworkActionReqObj;
+    const MsgTask* mMsgTask;
+    SystemStatusOsObserver* mSSObserver;
+
+    inline ObserverContext(const MsgTask* msgTask, SystemStatusOsObserver* observer) :
+            mSubscriptionObj(NULL), mFrameworkActionReqObj(NULL),
+            mMsgTask(msgTask), mSSObserver(observer) {}
+};
+
+// 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
+    inline SystemStatusOsObserver(SystemStatus* systemstatus, const MsgTask* msgTask) :
+            mSystemStatus(systemstatus), mContext(msgTask, this),
+            mAddress("SystemStatusOsObserver"),
+            mClientToDataItems(MAX_DATA_ITEM_ID), mDataItemToClients(MAX_DATA_ITEM_ID) {}
+
+    // dtor
+    ~SystemStatusOsObserver();
+
+    template <typename CINT, typename COUT>
+    static COUT containerTransfer(CINT& s);
+    template <typename CINT, typename COUT>
+    inline static COUT containerTransfer(CINT&& s) {
+        return containerTransfer<CINT, COUT>(s);
+    }
+
+    // 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;
+#ifdef USE_GLIB
+        uint32_t numBackHaulClients = mBackHaulConnReqCache.size();
+        if (numBackHaulClients > 0) {
+            // For each client, invoke connectbackhaul.
+            for (auto clientName : mBackHaulConnReqCache) {
+                LOC_LOGd("Invoke connectBackhaul for client: %s", clientName.c_str());
+                connectBackhaul(clientName);
+            }
+            // Clear the set
+            mBackHaulConnReqCache.clear();
+        }
+#endif
+    }
+
+    // IDataItemSubscription Overrides
+    inline virtual void subscribe(const list<DataItemId>& l, IDataItemObserver* client) override {
+        subscribe(l, client, false);
+    }
+    virtual void updateSubscription(const list<DataItemId>& l, IDataItemObserver* client) override;
+    inline virtual void requestData(const list<DataItemId>& l, IDataItemObserver* client) override {
+        subscribe(l, client, true);
+    }
+    virtual void unsubscribe(const list<DataItemId>& l, IDataItemObserver* client) override;
+    virtual void unsubscribeAll(IDataItemObserver* client) override;
+
+    // IDataItemObserver Overrides
+    virtual void notify(const list<IDataItemCore*>& dlist) override;
+    inline virtual void getName(string& name) override {
+        name = mAddress;
+    }
+
+    // IFrameworkActionReq Overrides
+    virtual void turnOn(DataItemId dit, int timeOut = 0) override;
+    virtual void turnOff(DataItemId dit) override;
+#ifdef USE_GLIB
+    virtual bool connectBackhaul(const string& clientName) override;
+    virtual bool disconnectBackhaul(const string& clientName) override;
+#endif
+
+private:
+    SystemStatus*                                    mSystemStatus;
+    ObserverContext                                  mContext;
+    const string                                     mAddress;
+    ClientToDataItems                                mClientToDataItems;
+    DataItemToClients                                mDataItemToClients;
+    DataItemIdToCore                                 mDataItemCache;
+    DataItemIdToInt                                  mActiveRequestCount;
+
+    // Cache the subscribe and requestData till subscription obj is obtained
+    void cacheObserverRequest(ObserverReqCache& reqCache,
+            const list<DataItemId>& l, IDataItemObserver* client);
+#ifdef USE_GLIB
+    // Cache the framework action request for connect/disconnect
+    ClientBackhaulReqCache  mBackHaulConnReqCache;
+#endif
+
+    void subscribe(const list<DataItemId>& l, IDataItemObserver* client, bool toRequestData);
+
+    // Helpers
+    void sendCachedDataItems(const unordered_set<DataItemId>& s, IDataItemObserver* to);
+    bool updateCache(IDataItemCore* d);
+    inline void logMe(const unordered_set<DataItemId>& l) {
+        IF_LOC_LOGD {
+            for (auto id : l) {
+                LOC_LOGD("DataItem %d", id);
+            }
+        }
+    }
+};
+
+} // namespace loc_core
+
+#endif //__SYSTEM_STATUS__
+

gps/core/configure.ac

@@ -0,0 +1,107 @@
+# configure.ac -- Autoconf script for gps loc-core
+#
+# 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-core],1.0.0)
+# Does not strictly follow GNU Coding standards
+AM_INIT_AUTOMAKE([foreign subdir-objects])
+# Disables auto rebuilding of configure, Makefile.ins
+AM_MAINTAINER_MODE
+# Verifies the --srcdir is correct by checking for the path
+AC_CONFIG_SRCDIR([loc-core.pc.in])
+# defines some macros variable to be included by source
+AC_CONFIG_HEADERS([config.h])
+AC_CONFIG_MACRO_DIR([m4])
+
+# Checks for programs.
+AC_PROG_LIBTOOL
+AC_PROG_CXX
+AC_PROG_CC
+AM_PROG_CC_C_O
+AC_PROG_AWK
+AC_PROG_CPP
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
+PKG_PROG_PKG_CONFIG
+
+# Checks for libraries.
+PKG_CHECK_MODULES([GPSUTILS], [gps-utils])
+AC_SUBST([GPSUTILS_CFLAGS])
+AC_SUBST([GPSUTILS_LIBS])
+
+AC_ARG_WITH([core_includes],
+      AC_HELP_STRING([--with-core-includes=@<:@dir@:>@],
+         [Specify the location of the core headers]),
+      [core_incdir=$withval],
+      with_core_includes=no)
+
+if test "x$with_core_includes" != "xno"; then
+   CPPFLAGS="${CPPFLAGS} -I${core_incdir}"
+fi
+
+AC_ARG_WITH([locpla_includes],
+      AC_HELP_STRING([--with-locpla-includes=@<:@dir@:>@],
+         [specify the path to locpla-includes in loc-pla_git.bb]),
+      [locpla_incdir=$withval],
+      with_locpla_includes=no)
+
+if test "x$with_locpla_includes" != "xno"; then
+   AC_SUBST(LOCPLA_CFLAGS, "-I${locpla_incdir}")
+fi
+
+AC_SUBST([CPPFLAGS])
+
+AC_ARG_WITH([glib],
+      AC_HELP_STRING([--with-glib],
+         [enable glib, building HLOS systems which use glib]))
+
+if (test "x${with_glib}" = "xyes"); then
+        AC_DEFINE(ENABLE_USEGLIB, 1, [Define if HLOS systems uses glib])
+        PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= 2.16, dummy=yes,
+                                AC_MSG_ERROR(GThread >= 2.16 is required))
+        PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, dummy=yes,
+                                AC_MSG_ERROR(GLib >= 2.16 is required))
+        GLIB_CFLAGS="$GLIB_CFLAGS $GTHREAD_CFLAGS"
+        GLIB_LIBS="$GLIB_LIBS $GTHREAD_LIBS"
+
+        AC_SUBST(GLIB_CFLAGS)
+        AC_SUBST(GLIB_LIBS)
+fi
+
+AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
+
+AC_ARG_WITH([auto_feature],
+    AC_HELP_STRING([--with-auto_feature=@<:@dir@:>@],
+        [Using Automotive feature]),
+    [],
+    with_auto_feature=no)
+
+if test "x$with_auto_feature" != "xno"; then
+    CPPFLAGS="${CPPFLAGS} -DFEATURE_AUTOMOTIVE"
+fi
+
+AM_CONDITIONAL(USE_FEATURE_AUTOMOTIVE, test "x${with_auto_feature}" = "xyes")
+
+# External AP
+AC_ARG_WITH([external_ap],
+    AC_HELP_STRING([--with-external_ap=@<:@dir@:>@],
+        [Using External Application Processor]),
+    [],
+    with_external_ap=no)
+
+if test "x$with_external_ap" != "xno"; then
+    CPPFLAGS="${CPPFLAGS} -DFEATURE_EXTERNAL_AP"
+fi
+
+AM_CONDITIONAL(USE_EXTERNAL_AP, test "x${with_external_ap}" = "xyes")
+
+AC_CONFIG_FILES([ \
+        Makefile \
+        loc-core.pc \
+        ])
+
+AC_OUTPUT

gps/core/data-items/DataItemConcreteTypesBase.h

@@ -0,0 +1,555 @@
+/* Copyright (c) 2015-2017, 2020, 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 __DATAITEMCONCRETEBASETYPES__
+#define __DATAITEMCONCRETEBASETYPES__
+
+#include <string>
+#include <cstring>
+#include <sstream>
+#include <DataItemId.h>
+#include <IDataItemCore.h>
+#include <gps_extended_c.h>
+#include <inttypes.h>
+
+#define MAC_ADDRESS_LENGTH    6
+// MAC address length in bytes
+// QMI_LOC_SRN_MAC_ADDR_LENGTH_V02
+#define SRN_MAC_ADDRESS_LENGTH    6
+#define WIFI_SUPPLICANT_DEFAULT_STATE    0
+
+static constexpr char sDelimit = ':';
+
+namespace loc_core
+{
+using namespace std;
+
+enum NetworkType {
+    TYPE_MOBILE = 0,
+    TYPE_WIFI,
+    TYPE_ETHERNET,
+    TYPE_BLUETOOTH,
+    TYPE_MMS,
+    TYPE_SUPL,
+    TYPE_DUN,
+    TYPE_HIPRI,
+    TYPE_WIMAX,
+    TYPE_PROXY,
+    TYPE_UNKNOWN,
+};
+
+typedef struct NetworkInfoType
+{
+    // Unique network handle ID
+    uint64_t networkHandle;
+    // Type of network for corresponding network handle
+    NetworkType networkType;
+    NetworkInfoType() : networkHandle(NETWORK_HANDLE_UNKNOWN), networkType(TYPE_UNKNOWN) {}
+    NetworkInfoType(string strObj) {
+        size_t posDelimit = strObj.find(sDelimit);
+
+        if ( posDelimit != string::npos) {
+            int32_t type = TYPE_UNKNOWN;
+            string handleStr = strObj.substr(0, posDelimit);
+            string typeStr = strObj.substr(posDelimit + 1, strObj.length() - posDelimit - 1);
+            stringstream(handleStr) >> networkHandle;
+            stringstream(typeStr) >> type;
+            networkType = (NetworkType) type;
+        } else {
+            networkHandle = NETWORK_HANDLE_UNKNOWN;
+            networkType = TYPE_UNKNOWN;
+        }
+    }
+    bool operator== (const NetworkInfoType& other) {
+        return ((networkHandle == other.networkHandle) && (networkType == other.networkType));
+    }
+    string toString() {
+        string valueStr;
+        valueStr.clear ();
+        char nethandle [32];
+        memset (nethandle, 0, 32);
+        snprintf(nethandle, sizeof(nethandle), "%" PRIu64, networkHandle);
+        valueStr += string(nethandle);
+        valueStr += sDelimit;
+        char type [12];
+        memset (type, 0, 12);
+        snprintf (type, 12, "%u", networkType);
+        valueStr += string (type);
+        return valueStr;
+    }
+} NetworkInfoType;
+
+
+class AirplaneModeDataItemBase : public IDataItemCore  {
+public:
+    AirplaneModeDataItemBase(bool mode):
+        mMode(mode),
+        mId(AIRPLANEMODE_DATA_ITEM_ID) {}
+    virtual ~AirplaneModeDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    bool mMode;
+
+protected:
+    DataItemId mId;
+};
+
+class ENHDataItemBase : public IDataItemCore {
+public:
+    ENHDataItemBase(bool enabled) :
+        mEnabled(enabled),
+        mId(ENH_DATA_ITEM_ID) {}
+    virtual ~ENHDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    bool mEnabled;
+protected:
+    DataItemId mId;
+};
+
+class GPSStateDataItemBase : public IDataItemCore {
+public:
+    GPSStateDataItemBase(bool enabled) :
+        mEnabled(enabled),
+        mId(GPSSTATE_DATA_ITEM_ID) {}
+    virtual ~GPSStateDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    bool mEnabled;
+protected:
+    DataItemId mId;
+};
+
+class NLPStatusDataItemBase : public IDataItemCore {
+public:
+    NLPStatusDataItemBase(bool enabled) :
+        mEnabled(enabled),
+        mId(NLPSTATUS_DATA_ITEM_ID) {}
+    virtual ~NLPStatusDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    bool mEnabled;
+protected:
+    DataItemId mId;
+};
+
+class WifiHardwareStateDataItemBase : public IDataItemCore {
+public:
+    WifiHardwareStateDataItemBase(bool enabled) :
+        mEnabled(enabled),
+        mId(WIFIHARDWARESTATE_DATA_ITEM_ID) {}
+    virtual ~WifiHardwareStateDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    bool mEnabled;
+protected:
+    DataItemId mId;
+};
+
+class ScreenStateDataItemBase : public IDataItemCore {
+public:
+    ScreenStateDataItemBase(bool state) :
+        mState(state),
+        mId(SCREEN_STATE_DATA_ITEM_ID) {}
+    virtual ~ScreenStateDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    bool mState;
+protected:
+    DataItemId mId;
+};
+
+class PowerConnectStateDataItemBase : public IDataItemCore {
+public:
+    PowerConnectStateDataItemBase(bool state) :
+        mState(state),
+        mId(POWER_CONNECTED_STATE_DATA_ITEM_ID) {}
+    virtual ~PowerConnectStateDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    bool mState;
+protected:
+    DataItemId mId;
+};
+
+class TimeZoneChangeDataItemBase : public IDataItemCore {
+public:
+    TimeZoneChangeDataItemBase(int64_t currTimeMillis, int32_t rawOffset, int32_t dstOffset) :
+        mCurrTimeMillis (currTimeMillis),
+        mRawOffsetTZ (rawOffset),
+        mDstOffsetTZ (dstOffset),
+        mId(TIMEZONE_CHANGE_DATA_ITEM_ID) {}
+    virtual ~TimeZoneChangeDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    int64_t mCurrTimeMillis;
+    int32_t mRawOffsetTZ;
+    int32_t mDstOffsetTZ;
+protected:
+    DataItemId mId;
+};
+
+class TimeChangeDataItemBase : public IDataItemCore {
+public:
+    TimeChangeDataItemBase(int64_t currTimeMillis, int32_t rawOffset, int32_t dstOffset) :
+        mCurrTimeMillis (currTimeMillis),
+        mRawOffsetTZ (rawOffset),
+        mDstOffsetTZ (dstOffset),
+        mId(TIME_CHANGE_DATA_ITEM_ID) {}
+    virtual ~TimeChangeDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    int64_t mCurrTimeMillis;
+    int32_t mRawOffsetTZ;
+    int32_t mDstOffsetTZ;
+protected:
+    DataItemId mId;
+};
+
+class ShutdownStateDataItemBase : public IDataItemCore {
+public:
+    ShutdownStateDataItemBase(bool state) :
+        mState (state),
+        mId(SHUTDOWN_STATE_DATA_ITEM_ID) {}
+    virtual ~ShutdownStateDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    bool mState;
+protected:
+    DataItemId mId;
+};
+
+class AssistedGpsDataItemBase : public IDataItemCore {
+public:
+    AssistedGpsDataItemBase(bool enabled) :
+        mEnabled(enabled),
+        mId(ASSISTED_GPS_DATA_ITEM_ID) {}
+    virtual ~AssistedGpsDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    bool mEnabled;
+protected:
+    DataItemId mId;
+};
+
+class NetworkInfoDataItemBase : public IDataItemCore {
+public:
+    NetworkInfoDataItemBase(
+    NetworkType initialType, int32_t type, string typeName, string subTypeName,
+    bool available, bool connected, bool roaming, uint64_t networkHandle, string apn):
+            mAllTypes(typeToAllTypes(initialType)),
+            mType(type),
+            mTypeName(typeName),
+            mSubTypeName(subTypeName),
+            mAvailable(available),
+            mConnected(connected),
+            mRoaming(roaming),
+            mNetworkHandle(networkHandle),
+            mId(NETWORKINFO_DATA_ITEM_ID), mApn(apn) {
+                mAllNetworkHandles[0].networkHandle = networkHandle;
+                mAllNetworkHandles[0].networkType = initialType;
+            }
+    virtual ~NetworkInfoDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+    inline virtual NetworkType getType(void) const {
+        return (NetworkType)mType;
+    }
+    inline uint64_t getAllTypes() { return mAllTypes; }
+    inline NetworkInfoType* getNetworkHandle() {
+        return &mAllNetworkHandles[0];
+    }
+    // Data members
+    uint64_t mAllTypes;
+    int32_t mType;
+    string mTypeName;
+    string mSubTypeName;
+    bool mAvailable;
+    bool mConnected;
+    bool mRoaming;
+    NetworkInfoType mAllNetworkHandles[MAX_NETWORK_HANDLES];
+    uint64_t mNetworkHandle;
+    string mApn;
+protected:
+    DataItemId mId;
+    inline uint64_t typeToAllTypes(NetworkType type) {
+        return (type >= TYPE_UNKNOWN || type < TYPE_MOBILE) ?  0 : (1<<type);
+    }
+};
+
+class ServiceStatusDataItemBase : public IDataItemCore {
+public:
+    ServiceStatusDataItemBase(int32_t serviceState) :
+        mServiceState (serviceState),
+        mId(SERVICESTATUS_DATA_ITEM_ID) {}
+    virtual ~ServiceStatusDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    int32_t mServiceState;
+protected:
+    DataItemId mId;
+};
+
+class ModelDataItemBase : public IDataItemCore {
+public:
+    ModelDataItemBase(const string & name) :
+        mModel (name),
+        mId(MODEL_DATA_ITEM_ID) {}
+    virtual ~ModelDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    string mModel;
+protected:
+    DataItemId mId;
+};
+
+class ManufacturerDataItemBase : public IDataItemCore {
+public:
+    ManufacturerDataItemBase(const string & name) :
+        mManufacturer (name),
+        mId(MANUFACTURER_DATA_ITEM_ID) {}
+    virtual ~ManufacturerDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    string mManufacturer;
+protected:
+    DataItemId mId;
+};
+
+class RilServiceInfoDataItemBase : public IDataItemCore {
+public:
+    inline RilServiceInfoDataItemBase() :
+            mData(nullptr), mId(RILSERVICEINFO_DATA_ITEM_ID) {}
+    inline virtual ~RilServiceInfoDataItemBase() { if (nullptr != mData) free(mData); }
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+    inline RilServiceInfoDataItemBase(const RilServiceInfoDataItemBase& peer) :
+            RilServiceInfoDataItemBase() {
+        peer.setPeerData(*this);
+    }
+    inline virtual bool operator==(const RilServiceInfoDataItemBase& other) const {
+        return other.mData == mData;
+    }
+    inline virtual void setPeerData(RilServiceInfoDataItemBase& /*peer*/) const {}
+    void* mData;
+protected:
+    DataItemId mId;
+};
+
+class RilCellInfoDataItemBase : public IDataItemCore {
+public:
+    inline RilCellInfoDataItemBase() :
+            mData(nullptr), mId(RILCELLINFO_DATA_ITEM_ID) {}
+    inline virtual ~RilCellInfoDataItemBase() { if (nullptr != mData) free(mData); }
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+    inline RilCellInfoDataItemBase(const RilCellInfoDataItemBase& peer) :
+            RilCellInfoDataItemBase() {
+        peer.setPeerData(*this);
+    }
+    inline virtual bool operator==(const RilCellInfoDataItemBase& other) const {
+        return other.mData == mData;
+    }
+    inline virtual void setPeerData(RilCellInfoDataItemBase& /*peer*/) const {}
+    void* mData;
+protected:
+    DataItemId mId;
+};
+
+class WifiSupplicantStatusDataItemBase : public IDataItemCore {
+public:
+    WifiSupplicantStatusDataItemBase() :
+        mState((WifiSupplicantState)WIFI_SUPPLICANT_DEFAULT_STATE),
+        mApMacAddressValid(false),
+        mWifiApSsidValid(false),
+        mId(WIFI_SUPPLICANT_STATUS_DATA_ITEM_ID) {
+            memset (&mApMacAddress, 0, sizeof (mApMacAddress));
+            mWifiApSsid.clear();
+        }
+    virtual ~WifiSupplicantStatusDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+    // Data members
+    typedef enum WifiSupplicantState {
+        DISCONNECTED,
+        INTERFACE_DISABLED,
+        INACTIVE,
+        SCANNING,
+        AUTHENTICATING,
+        ASSOCIATING,
+        ASSOCIATED,
+        FOUR_WAY_HANDSHAKE,
+        GROUP_HANDSHAKE,
+        COMPLETED,
+        DORMANT,
+        UNINITIALIZED,
+        INVALID
+    } WifiSupplicantState;
+    /* Represents whether access point attach state*/
+    WifiSupplicantState mState;
+    /* Represents info on whether ap mac address is valid */
+    bool mApMacAddressValid;
+    /* Represents mac address of the wifi access point*/
+    uint8_t mApMacAddress[MAC_ADDRESS_LENGTH];
+    /* Represents info on whether ap SSID is valid */
+    bool mWifiApSsidValid;
+    /* Represents Wifi SSID string*/
+    string mWifiApSsid;
+protected:
+    DataItemId mId;
+};
+
+class TacDataItemBase : public IDataItemCore {
+public:
+    TacDataItemBase(const string & name) :
+        mValue (name),
+        mId(TAC_DATA_ITEM_ID) {}
+    virtual ~TacDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    string mValue;
+protected:
+    DataItemId mId;
+};
+
+class MccmncDataItemBase : public IDataItemCore {
+public:
+    MccmncDataItemBase(const string & name) :
+        mValue(name),
+        mId(MCCMNC_DATA_ITEM_ID) {}
+    virtual ~MccmncDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+// Data members
+    string mValue;
+protected:
+    DataItemId mId;
+};
+
+class SrnDeviceScanDetailsDataItemBase : public IDataItemCore {
+public:
+    SrnDeviceScanDetailsDataItemBase(DataItemId Id) :
+        mValidSrnData(false),
+        mApSrnRssi(-1),
+        mApSrnTimestamp(0),
+        mRequestTimestamp(0),
+        mReceiveTimestamp(0),
+        mErrorCause(-1),
+        mId(Id) {}
+    virtual ~SrnDeviceScanDetailsDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+    // Data members common to all SRN tech types
+    /* Represents info on whether SRN data is valid (no error)*/
+    bool mValidSrnData;
+    /* SRN device RSSI reported */
+    int32_t mApSrnRssi;
+    /* MAC adress of SRN device */
+    uint8_t mApSrnMacAddress[SRN_MAC_ADDRESS_LENGTH];
+    /* UTC timestamp at which the scan was requested.for this SRN device*/
+    int64_t mApSrnTimestamp;
+    /* UTC timestamp at which the scan was started. */
+    int64_t mRequestTimestamp;
+    /* UTC timestamp at which the scan was received.*/
+    int64_t mReceiveTimestamp;
+    /* Reason for the error/failure if SRN details are not valid */
+    int32_t mErrorCause;
+protected:
+    DataItemId mId;
+};
+
+class BtDeviceScanDetailsDataItemBase : public SrnDeviceScanDetailsDataItemBase {
+
+public:
+    BtDeviceScanDetailsDataItemBase() :
+        SrnDeviceScanDetailsDataItemBase(BT_SCAN_DATA_ITEM_ID) {}
+    virtual ~BtDeviceScanDetailsDataItemBase() {}
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+};
+
+class BtLeDeviceScanDetailsDataItemBase : public SrnDeviceScanDetailsDataItemBase {
+
+public:
+    BtLeDeviceScanDetailsDataItemBase() :
+        SrnDeviceScanDetailsDataItemBase(BTLE_SCAN_DATA_ITEM_ID) {}
+    virtual ~BtLeDeviceScanDetailsDataItemBase() {}
+    virtual void stringify(string& /*valueStr*/) {}
+    virtual int32_t copy(IDataItemCore* /*src*/, bool* /*dataItemCopied = NULL*/) {return 1;}
+};
+
+class BatteryLevelDataItemBase : public IDataItemCore {
+public:
+    inline BatteryLevelDataItemBase(uint8_t batteryPct) :
+            mBatteryPct(batteryPct), mId(BATTERY_LEVEL_DATA_ITEM_ID) {}
+    inline ~BatteryLevelDataItemBase() {}
+    inline virtual DataItemId getId() { return mId; }
+// Data members
+    uint8_t mBatteryPct;
+protected:
+    DataItemId mId;
+};
+
+} // namespace loc_core
+
+#endif //__DATAITEMCONCRETEBASETYPES__

gps/core/data-items/DataItemId.h

@@ -0,0 +1,79 @@
+/* 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,
+
+    // 26 -
+    BATTERY_LEVEL_DATA_ITEM_ID,
+
+    MAX_DATA_ITEM_ID_1_1,
+} DataItemId;
+
+#endif // #ifndef __DATAITEMID_H__

gps/core/data-items/DataItemsFactoryProxy.cpp

@@ -0,0 +1,82 @@
+/* Copyright (c) 2017-2020, 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 <dlfcn.h>
+#include <DataItemId.h>
+#include <IDataItemCore.h>
+#include <DataItemsFactoryProxy.h>
+#include <loc_pla.h>
+#include <log_util.h>
+#include "loc_misc_utils.h"
+
+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 {
+        getConcreteDIFunc = (get_concrete_data_item_fn * )
+                dlGetSymFromLib(dataItemLibHandle, DATA_ITEMS_LIB_NAME, DATA_ITEMS_GET_CONCRETE_DI);
+
+        if (NULL != getConcreteDIFunc) {
+            LOC_LOGd("Loaded function %s : %p", DATA_ITEMS_GET_CONCRETE_DI, getConcreteDIFunc);
+            mydi = (*getConcreteDIFunc)(id);
+        }
+        else {
+            // dlysm failed.
+            const char * err = dlerror();
+            if (NULL == err)
+            {
+                err = "Unknown";
+            }
+            LOC_LOGe("failed to find symbol %s; error=%s", DATA_ITEMS_GET_CONCRETE_DI, err);
+        }
+    }
+    return mydi;
+}
+
+void DataItemsFactoryProxy::closeDataItemLibraryHandle()
+{
+    if (NULL != dataItemLibHandle) {
+        dlclose(dataItemLibHandle);
+        dataItemLibHandle = NULL;
+    }
+}
+
+} // namespace loc_core
+
+

gps/core/data-items/DataItemsFactoryProxy.h

@@ -0,0 +1,55 @@
+/* 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 __DATAITEMFACTORYBASE__
+#define __DATAITEMFACTORYBASE__
+
+#include <DataItemId.h>
+#include <IDataItemCore.h>
+
+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__
+

gps/core/data-items/IDataItemCore.h

@@ -0,0 +1,82 @@
+/* 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 __IDATAITEMCORE_H__
+#define __IDATAITEMCORE_H__
+
+#include <string>
+#include <DataItemId.h>
+
+namespace loc_core {
+
+using namespace std;
+
+/**
+ * @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;
+
+    /**
+     * @brief Stringify.
+     * @details Stringify.
+     *
+     * @param valueStr Reference to string.
+     */
+    virtual void stringify (string & valueStr) = 0;
+
+    /**
+     * @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;
+
+    /**
+     * @brief Destructor.
+     * @details Destructor.
+     */
+    virtual ~IDataItemCore () {}
+};
+
+} // namespace loc_core
+
+#endif // __IDATAITEMCORE_H__

gps/core/loc-core.pc.in

@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: loc-core
+Description: QTI GPS Loc Core
+Version: @VERSION@
+Libs: -L${libdir} -lloc_core
+Cflags: -I${includedir}/loc-core

gps/core/loc_core_log.cpp

@@ -0,0 +1,215 @@
+/* Copyright (c) 2011-2015, 2020 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_core_log"
+
+#include <log_util.h>
+#include <loc_log.h>
+#include <loc_core_log.h>
+#include <loc_pla.h>
+
+void LocPosMode::logv() const
+{
+    LOC_LOGV ("Position mode: %s\n  Position recurrence: %s\n  "
+              "min interval: %d\n  preferred accuracy: %d\n  "
+              "preferred time: %d\n  credentials: %s  provider: %s \n  "
+              "power mode: %d\n  tbm %d",
+              loc_get_position_mode_name(mode),
+              loc_get_position_recurrence_name(recurrence),
+              min_interval,
+              preferred_accuracy,
+              preferred_time,
+              credentials,
+              provider,
+              powerMode,
+              timeBetweenMeasurements);
+}
+
+/* GPS status names */
+DECLARE_TBL(gps_status_name) =
+{
+    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 ),
+};
+
+/* Find Android GPS status name */
+const char* loc_get_gps_status_name(LocGpsStatusValue gps_status)
+{
+    return loc_get_name_from_val(gps_status_name_tbl, (int64_t) gps_status);
+}
+
+
+
+DECLARE_TBL(loc_eng_position_modes) =
+{
+    NAME_VAL( LOC_POSITION_MODE_STANDALONE ),
+    NAME_VAL( LOC_POSITION_MODE_MS_BASED ),
+    NAME_VAL( LOC_POSITION_MODE_MS_ASSISTED ),
+    NAME_VAL( LOC_POSITION_MODE_RESERVED_1 ),
+    NAME_VAL( LOC_POSITION_MODE_RESERVED_2 ),
+    NAME_VAL( LOC_POSITION_MODE_RESERVED_3 ),
+    NAME_VAL( LOC_POSITION_MODE_RESERVED_4 ),
+    NAME_VAL( LOC_POSITION_MODE_RESERVED_5 )
+};
+
+const char* loc_get_position_mode_name(LocGpsPositionMode mode)
+{
+    return loc_get_name_from_val(loc_eng_position_modes_tbl, (int64_t) mode);
+}
+
+
+
+DECLARE_TBL(loc_eng_position_recurrences) =
+{
+    NAME_VAL( LOC_GPS_POSITION_RECURRENCE_PERIODIC ),
+    NAME_VAL( LOC_GPS_POSITION_RECURRENCE_SINGLE )
+};
+
+const char* loc_get_position_recurrence_name(LocGpsPositionRecurrence recur)
+{
+    return loc_get_name_from_val(loc_eng_position_recurrences_tbl, (int64_t) recur);
+}
+
+const char* loc_get_aiding_data_mask_names(LocGpsAidingData /*data*/)
+{
+    return NULL;
+}
+
+
+DECLARE_TBL(loc_eng_agps_types) =
+{
+    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 )
+};
+
+const char* loc_get_agps_type_name(LocAGpsType type)
+{
+    return loc_get_name_from_val(loc_eng_agps_types_tbl, (int64_t) type);
+}
+
+
+DECLARE_TBL(loc_eng_ni_types) =
+{
+    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 )
+};
+
+const char* loc_get_ni_type_name(LocGpsNiType type)
+{
+    return loc_get_name_from_val(loc_eng_ni_types_tbl, (int64_t) type);
+}
+
+
+DECLARE_TBL(loc_eng_ni_responses) =
+{
+    NAME_VAL( LOC_GPS_NI_RESPONSE_ACCEPT ),
+    NAME_VAL( LOC_GPS_NI_RESPONSE_DENY ),
+    NAME_VAL( LOC_GPS_NI_RESPONSE_DENY )
+};
+
+const char* loc_get_ni_response_name(LocGpsUserResponseType response)
+{
+    return loc_get_name_from_val(loc_eng_ni_responses_tbl, (int64_t) response);
+}
+
+
+DECLARE_TBL(loc_eng_ni_encodings) =
+{
+    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 )
+};
+
+const char* loc_get_ni_encoding_name(LocGpsNiEncodingType encoding)
+{
+    return loc_get_name_from_val(loc_eng_ni_encodings_tbl, (int64_t) encoding);
+}
+
+DECLARE_TBL(loc_eng_agps_bears) =
+{
+    NAME_VAL( AGPS_APN_BEARER_INVALID ),
+    NAME_VAL( AGPS_APN_BEARER_IPV4 ),
+    NAME_VAL( AGPS_APN_BEARER_IPV6 ),
+    NAME_VAL( AGPS_APN_BEARER_IPV4V6 )
+};
+
+const char* loc_get_agps_bear_name(AGpsBearerType bearer)
+{
+    return loc_get_name_from_val(loc_eng_agps_bears_tbl, (int64_t) bearer);
+}
+
+DECLARE_TBL(loc_eng_server_types) =
+{
+    NAME_VAL( LOC_AGPS_CDMA_PDE_SERVER ),
+    NAME_VAL( LOC_AGPS_CUSTOM_PDE_SERVER ),
+    NAME_VAL( LOC_AGPS_MPC_SERVER ),
+    NAME_VAL( LOC_AGPS_SUPL_SERVER )
+};
+
+const char* loc_get_server_type_name(LocServerType type)
+{
+    return loc_get_name_from_val(loc_eng_server_types_tbl, (int64_t) type);
+}
+
+DECLARE_TBL(loc_eng_position_sess_status_types) =
+{
+    NAME_VAL( LOC_SESS_SUCCESS ),
+    NAME_VAL( LOC_SESS_INTERMEDIATE ),
+    NAME_VAL( LOC_SESS_FAILURE )
+};
+
+const char* loc_get_position_sess_status_name(enum loc_sess_status status)
+{
+    return loc_get_name_from_val(loc_eng_position_sess_status_types_tbl, (int64_t) status);
+}
+
+DECLARE_TBL(loc_eng_agps_status_names) =
+{
+    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 )
+};
+
+const char* loc_get_agps_status_name(LocAGpsStatusValue status)
+{
+    return loc_get_name_from_val(loc_eng_agps_status_names_tbl, (int64_t) status);
+}

gps/core/loc_core_log.h

@@ -0,0 +1,58 @@
+/* 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
+ * 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_CORE_LOG_H
+#define LOC_CORE_LOG_H
+
+#include <ctype.h>
+#include <gps_extended.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+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(LocAGpsStatusValue status);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LOC_CORE_LOG_H */

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  <list>
+#include <string>
+
+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 <IDataItemCore *> & dlist)  = 0;
+
+    /**
+     * @brief Destructor
+     * @details Destructor
+     */
+    virtual ~IDataItemObserver () {}
+};
+
+} // namespace loc_core
+
+#endif // #ifndef __IDATAITEMOBSERVER_H__

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  <list>
+#include  <DataItemId.h>
+
+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 <DataItemId> & 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 <DataItemId> & 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 <DataItemId> & 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 <DataItemId> & 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__
+

gps/core/observer/IFrameworkActionReq.h

@@ -0,0 +1,104 @@
+/* Copyright (c) 2017, 2020 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 <string>
+#include  <DataItemId.h>
+
+using namespace std;
+
+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;
+
+#ifdef USE_GLIB
+    /**
+     * @brief Setup WWAN backhaul
+     * @details  Setup WWAN backhaul
+     *
+     * @param None
+     */
+    virtual bool connectBackhaul(const string& clientName) = 0;
+
+    /**
+     * @brief Disconnects the WWANbackhaul
+     * @details Disconnects the WWANbackhaul, only if it was setup by us
+     *
+     * @param None
+     */
+    virtual bool disconnectBackhaul(const string& clientName) = 0;
+#endif
+
+    /**
+     * @brief Destructor
+     * @details Destructor
+     */
+    virtual ~IFrameworkActionReq () {}
+};
+
+} // namespace loc_core
+
+#endif // #ifndef __IFRAMEWORKACTIONREQ_H__
+

gps/core/observer/IOsObserver.h

@@ -0,0 +1,107 @@
+/* Copyright (c) 2017, 2020 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  <list>
+#include <string>
+#include <IDataItemObserver.h>
+#include <IDataItemSubscription.h>
+#include <IFrameworkActionReq.h>
+
+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 <IDataItemCore *> & /*dlist*/) {}
+
+    // IDataItemSubscription Overrides
+    inline virtual void subscribe
+    (
+        const std :: list <DataItemId> & /*l*/,
+        IDataItemObserver * /*client*/
+    ){}
+    inline virtual void updateSubscription
+    (
+        const std :: list <DataItemId> & /*l*/,
+        IDataItemObserver * /*client*/
+    ){}
+    inline virtual void requestData
+    (
+        const std :: list <DataItemId> & /*l*/,
+        IDataItemObserver * /*client*/
+    ){}
+    inline virtual void unsubscribe
+    (
+        const std :: list <DataItemId> & /*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*/) {}
+#ifdef USE_GLIB
+    inline virtual bool connectBackhaul(const string& clientName) { return false; }
+    inline virtual bool disconnectBackhaul(const string& clientName) { return false; }
+#endif
+
+    /**
+     * @brief Destructor
+     * @details Destructor
+     */
+    virtual ~IOsObserver () {}
+};
+
+} // namespace loc_core
+
+#endif // #ifndef __IOSOBSERVER_H__