Merge d17a81974b on remote branch

Change-Id: Ia1567eaf1e23500e2b9392b4c51784ec20c7245a

android/1.0/Android.mk

@@ -28,7 +28,8 @@ LOCAL_HEADER_LIBRARIES := \
     libgps.utils_headers \
     libloc_core_headers \
     libloc_pla_headers \
-    liblocation_api_headers
+    liblocation_api_headers \
+    liblocbatterylistener_headers
 
 LOCAL_SHARED_LIBRARIES := \
     liblog \
@@ -38,6 +39,10 @@ LOCAL_SHARED_LIBRARIES := \
     libcutils \
     libutils \
     android.hardware.gnss@1.0 \
+    android.hardware.health@1.0 \
+    android.hardware.health@2.0 \
+    android.hardware.power@1.2 \
+    libbase
 
 LOCAL_SHARED_LIBRARIES += \
     libloc_core \
@@ -46,6 +51,8 @@ LOCAL_SHARED_LIBRARIES += \
     liblocation_api \
 
 LOCAL_CFLAGS += $(GNSS_CFLAGS)
+LOCAL_STATIC_LIBRARIES := liblocbatterylistener
+LOCAL_STATIC_LIBRARIES += libhealthhalutils
 include $(BUILD_SHARED_LIBRARY)
 
 include $(CLEAR_VARS)

android/1.0/Gnss.cpp

@@ -19,6 +19,7 @@
  */
 
 #define LOG_TAG "LocSvc_GnssInterface"
+#define LOG_NDEBUG 0
 
 #include <fstream>
 #include <log_util.h>
@@ -26,6 +27,7 @@
 #include <cutils/properties.h>
 #include "Gnss.h"
 #include <LocationUtil.h>
+#include "battery_listener.h"
 
 typedef const GnssInterface* (getLocationInterface)();
 
@@ -35,6 +37,7 @@ namespace gnss {
 namespace V1_0 {
 namespace implementation {
 
+static sp<Gnss> sGnss;
 void Gnss::GnssDeathRecipient::serviceDied(uint64_t cookie, const wp<IBase>& who) {
     LOC_LOGE("%s] service died. cookie: %llu, who: %p",
             __FUNCTION__, static_cast<unsigned long long>(cookie), &who);
@@ -44,8 +47,17 @@ void Gnss::GnssDeathRecipient::serviceDied(uint64_t cookie, const wp<IBase>& who
     }
 }
 
+void location_on_battery_status_changed(bool charging) {
+    LOC_LOGd("battery status changed to %s charging", charging ? "" : "not ");
+    if (sGnss != nullptr) {
+        sGnss->getGnssInterface()->updateBatteryStatus(charging);
+    }
+}
 Gnss::Gnss() {
     ENTRY_LOG_CALLFLOW();
+    sGnss = this;
+    // register health client to listen on battery change
+    loc_extn_battery_properties_listener_init(location_on_battery_status_changed);
     // clear pending GnssConfig
     memset(&mPendingConfig, 0, sizeof(GnssConfig));
 
@@ -58,6 +70,7 @@ Gnss::~Gnss() {
         delete mApi;
         mApi = nullptr;
     }
+    sGnss = nullptr;
 }
 
 GnssAPIClient* Gnss::getApi() {

android/1.1/Android.mk

@@ -28,7 +28,8 @@ LOCAL_HEADER_LIBRARIES := \
     libgps.utils_headers \
     libloc_core_headers \
     libloc_pla_headers \
-    liblocation_api_headers
+    liblocation_api_headers \
+    liblocbatterylistener_headers
 
 LOCAL_SHARED_LIBRARIES := \
     liblog \
@@ -39,6 +40,10 @@ LOCAL_SHARED_LIBRARIES := \
     libutils \
     android.hardware.gnss@1.0 \
     android.hardware.gnss@1.1 \
+    android.hardware.health@1.0 \
+    android.hardware.health@2.0 \
+    android.hardware.power@1.2 \
+    libbase
 
 LOCAL_SHARED_LIBRARIES += \
     libloc_core \
@@ -47,6 +52,8 @@ LOCAL_SHARED_LIBRARIES += \
     liblocation_api \
 
 LOCAL_CFLAGS += $(GNSS_CFLAGS)
+LOCAL_STATIC_LIBRARIES := liblocbatterylistener
+LOCAL_STATIC_LIBRARIES += libhealthhalutils
 include $(BUILD_SHARED_LIBRARY)
 
 include $(CLEAR_VARS)

android/1.1/Gnss.cpp

@@ -19,6 +19,7 @@
  */
 
 #define LOG_TAG "LocSvc_GnssInterface"
+#define LOG_NDEBUG 0
 
 #include <fstream>
 #include <log_util.h>
@@ -27,6 +28,8 @@
 #include "Gnss.h"
 #include <LocationUtil.h>
 
+#include "battery_listener.h"
+
 typedef const GnssInterface* (getLocationInterface)();
 
 #define IMAGES_INFO_FILE "/sys/devices/soc0/images"
@@ -38,6 +41,7 @@ namespace gnss {
 namespace V1_1 {
 namespace implementation {
 
+static sp<Gnss> sGnss;
 static std::string getVersionString() {
     static std::string version;
     if (!version.empty())
@@ -84,8 +88,17 @@ void Gnss::GnssDeathRecipient::serviceDied(uint64_t cookie, const wp<IBase>& who
     }
 }
 
+void location_on_battery_status_changed(bool charging) {
+    LOC_LOGd("battery status changed to %s charging", charging ? "" : "not");
+    if (sGnss != nullptr) {
+        sGnss->getGnssInterface()->updateBatteryStatus(charging);
+    }
+}
 Gnss::Gnss() {
     ENTRY_LOG_CALLFLOW();
+    sGnss = this;
+    // register health client to listen on battery change
+    loc_extn_battery_properties_listener_init(location_on_battery_status_changed);
     // clear pending GnssConfig
     memset(&mPendingConfig, 0, sizeof(GnssConfig));
 
@@ -98,6 +111,7 @@ Gnss::~Gnss() {
         delete mApi;
         mApi = nullptr;
     }
+    sGnss = nullptr;
 }
 
 GnssAPIClient* Gnss::getApi() {

android/2.0/Android.mk

@@ -37,7 +37,8 @@ LOCAL_HEADER_LIBRARIES := \
     libgps.utils_headers \
     libloc_core_headers \
     libloc_pla_headers \
-    liblocation_api_headers
+    liblocation_api_headers \
+    liblocbatterylistener_headers
 
 LOCAL_SHARED_LIBRARIES := \
     liblog \
@@ -50,7 +51,11 @@ LOCAL_SHARED_LIBRARIES := \
     android.hardware.gnss@1.1 \
     android.hardware.gnss@2.0 \
     android.hardware.gnss.measurement_corrections@1.0 \
-    android.hardware.gnss.visibility_control@1.0
+    android.hardware.gnss.visibility_control@1.0 \
+    android.hardware.health@1.0 \
+    android.hardware.health@2.0 \
+    android.hardware.power@1.2 \
+    libbase
 
 LOCAL_SHARED_LIBRARIES += \
     libloc_core \
@@ -59,6 +64,8 @@ LOCAL_SHARED_LIBRARIES += \
     liblocation_api \
 
 LOCAL_CFLAGS += $(GNSS_CFLAGS)
+LOCAL_STATIC_LIBRARIES := liblocbatterylistener
+LOCAL_STATIC_LIBRARIES += libhealthhalutils
 include $(BUILD_SHARED_LIBRARY)
 
 include $(CLEAR_VARS)

android/2.0/Gnss.cpp

@@ -19,6 +19,7 @@
  */
 
 #define LOG_TAG "LocSvc_GnssInterface"
+#define LOG_NDEBUG 0
 
 #include <fstream>
 #include <log_util.h>
@@ -26,6 +27,7 @@
 #include <cutils/properties.h>
 #include "Gnss.h"
 #include "LocationUtil.h"
+#include "battery_listener.h"
 
 typedef const GnssInterface* (getLocationInterface)();
 
@@ -39,7 +41,7 @@ namespace V2_0 {
 namespace implementation {
 
 using ::android::hardware::gnss::visibility_control::V1_0::implementation::GnssVisibilityControl;
-
+static sp<Gnss> sGnss;
 static std::string getVersionString() {
     static std::string version;
     if (!version.empty())
@@ -85,8 +87,17 @@ void Gnss::GnssDeathRecipient::serviceDied(uint64_t cookie, const wp<IBase>& who
     }
 }
 
+void location_on_battery_status_changed(bool charging) {
+    LOC_LOGd("battery status changed to %s charging", charging ? "" : "not");
+    if (sGnss != nullptr) {
+        sGnss->getGnssInterface()->updateBatteryStatus(charging);
+    }
+}
 Gnss::Gnss() {
     ENTRY_LOG_CALLFLOW();
+    sGnss = this;
+    // register health client to listen on battery change
+    loc_extn_battery_properties_listener_init(location_on_battery_status_changed);
     // clear pending GnssConfig
     memset(&mPendingConfig, 0, sizeof(GnssConfig));
     mGnssDeathRecipient = new GnssDeathRecipient(this);
@@ -98,6 +109,7 @@ Gnss::~Gnss() {
         delete mApi;
         mApi = nullptr;
     }
+    sGnss = nullptr;
 }
 
 GnssAPIClient* Gnss::getApi() {

android/2.0/location_api/GnssAPIClient.cpp

@@ -61,6 +61,7 @@ GnssAPIClient::GnssAPIClient(const sp<V1_0::IGnssCallback>& gpsCb,
     mControlClient(new LocationAPIControlClient()),
     mLocationCapabilitiesMask(0),
     mLocationCapabilitiesCached(false),
+    mTracking(false),
     mGnssCbIface_2_0(nullptr)
 {
     LOC_LOGD("%s]: (%p %p)", __FUNCTION__, &gpsCb, &niCb);
@@ -76,6 +77,7 @@ GnssAPIClient::GnssAPIClient(const sp<V2_0::IGnssCallback>& gpsCb) :
     mControlClient(new LocationAPIControlClient()),
     mLocationCapabilitiesMask(0),
     mLocationCapabilitiesCached(false),
+    mTracking(false),
     mGnssCbIface_2_0(nullptr)
 {
     LOC_LOGD("%s]: (%p)", __FUNCTION__, &gpsCb);
@@ -179,6 +181,11 @@ void GnssAPIClient::gnssUpdateCallbacks_2_0(const sp<V2_0::IGnssCallback>& gpsCb
 bool GnssAPIClient::gnssStart()
 {
     LOC_LOGD("%s]: ()", __FUNCTION__);
+
+    mMutex.lock();
+    mTracking = true;
+    mMutex.unlock();
+
     bool retVal = true;
     locAPIStartTracking(mTrackingOptions);
     return retVal;
@@ -187,6 +194,11 @@ bool GnssAPIClient::gnssStart()
 bool GnssAPIClient::gnssStop()
 {
     LOC_LOGD("%s]: ()", __FUNCTION__);
+
+    mMutex.lock();
+    mTracking = false;
+    mMutex.unlock();
+
     bool retVal = true;
     locAPIStopTracking();
     return retVal;
@@ -412,12 +424,18 @@ void GnssAPIClient::onCapabilitiesCb(LocationCapabilitiesMask capabilitiesMask)
 
 void GnssAPIClient::onTrackingCb(Location location)
 {
-    LOC_LOGD("%s]: (flags: %02x)", __FUNCTION__, location.flags);
     mMutex.lock();
     auto gnssCbIface(mGnssCbIface);
     auto gnssCbIface_2_0(mGnssCbIface_2_0);
+    bool isTracking = mTracking;
     mMutex.unlock();
 
+    LOC_LOGD("%s]: (flags: %02x isTracking: %d)", __FUNCTION__, location.flags, isTracking);
+
+    if (!isTracking) {
+        return;
+    }
+
     if (gnssCbIface_2_0 != nullptr) {
         V2_0::GnssLocation gnssLocation;
         convertGnssLocation(location, gnssLocation);

android/2.0/location_api/GnssAPIClient.h

@@ -102,6 +102,7 @@ private:
     LocationCapabilitiesMask mLocationCapabilitiesMask;
     bool mLocationCapabilitiesCached;
     TrackingOptions mTrackingOptions;
+    bool mTracking;
     sp<V2_0::IGnssCallback> mGnssCbIface_2_0;
 };
 

android/2.0/location_api/MeasurementAPIClient.cpp

@@ -217,7 +217,7 @@ void MeasurementAPIClient::onGnssMeasurementsCb(
 static void convertGnssMeasurement(GnssMeasurementsData& in,
         V1_0::IGnssMeasurementCallback::GnssMeasurement& out)
 {
-    memset(&out, 0, sizeof(IGnssMeasurementCallback::GnssMeasurement));
+    memset(&out, 0, sizeof(out));
     if (in.flags & GNSS_MEASUREMENTS_DATA_SIGNAL_TO_NOISE_RATIO_BIT)
         out.flags |= IGnssMeasurementCallback::GnssMeasurementFlags::HAS_SNR;
     if (in.flags & GNSS_MEASUREMENTS_DATA_CARRIER_FREQUENCY_BIT)

android/Android.mk

@@ -1,12 +1,15 @@
 LOCAL_PATH := $(call my-dir)
 ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
+include $(CLEAR_VARS)
+DIR_LIST := $(LOCAL_PATH)
+include $(DIR_LIST)/utils/Android.mk
 ifeq ($(GNSS_HIDL_VERSION),2.0)
-include $(LOCAL_PATH)/2.0/Android.mk
+include $(DIR_LIST)/2.0/Android.mk
 else
 ifeq ($(GNSS_HIDL_VERSION),1.1)
-include $(LOCAL_PATH)/1.1/Android.mk
+include $(DIR_LIST)/1.1/Android.mk
 else
-include $(LOCAL_PATH)/1.0/Android.mk
+include $(DIR_LIST)/1.0/Android.mk
 endif #GNSS HIDL 1.1
 endif #GNSS HIDL 2.0
 else #QMAA flag set, build dummy android.hardware.gnss@1.0-impl-qti

android/utils/Android.mk

@@ -0,0 +1,37 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := liblocbatterylistener
+LOCAL_VENDOR_MODULE := true
+
+LOCAL_CFLAGS += $(GNSS_CFLAGS)
+
+LOCAL_C_INCLUDES += \
+    $(LOCAL_PATH) \
+
+LOCAL_SRC_FILES:= \
+    battery_listener.cpp
+LOCAL_SHARED_LIBRARIES := \
+    liblog \
+    libhidlbase \
+    libhidltransport \
+    libhwbinder \
+    libcutils \
+    libutils \
+    android.hardware.health@1.0 \
+    android.hardware.health@2.0 \
+    android.hardware.power@1.2 \
+    libbase
+
+LOCAL_STATIC_LIBRARIES := libhealthhalutils
+LOCAL_CFLAGS += -DBATTERY_LISTENER_ENABLED
+
+include $(BUILD_STATIC_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := liblocbatterylistener_headers
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)
+
+include $(BUILD_HEADER_LIBRARY)
+
+

android/utils/battery_listener.cpp

@@ -0,0 +1,266 @@
+/*
+* Copyright (c) 2019, The Linux Foundation. All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of The Linux Foundation nor the names of its
+*       contributors may be used to endorse or promote products derived
+*       from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#include "battery_listener.h"
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "LocSvc_BatteryListener"
+
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <android/hardware/health/2.0/IHealth.h>
+#include <healthhalutils/HealthHalUtils.h>
+#include <hidl/HidlTransportSupport.h>
+#include <thread>
+using android::hardware::interfacesEqual;
+using android::hardware::Return;
+using android::hardware::Void;
+using android::hardware::health::V1_0::BatteryStatus;
+using android::hardware::health::V1_0::toString;
+using android::hardware::health::V2_0::get_health_service;
+using android::hardware::health::V2_0::HealthInfo;
+using android::hardware::health::V2_0::IHealth;
+using android::hardware::health::V2_0::Result;
+using android::hidl::manager::V1_0::IServiceManager;
+using namespace std::literals::chrono_literals;
+
+static bool sIsBatteryListened = false;
+namespace android {
+
+#define GET_HEALTH_SVC_RETRY_CNT 5
+#define GET_HEALTH_SVC_WAIT_TIME_MS 500
+
+struct BatteryListenerImpl : public hardware::health::V2_0::IHealthInfoCallback,
+                             public hardware::hidl_death_recipient {
+    typedef std::function<void(bool)> cb_fn_t;
+    BatteryListenerImpl(cb_fn_t cb);
+    virtual ~BatteryListenerImpl ();
+    virtual hardware::Return<void> healthInfoChanged(
+        const hardware::health::V2_0::HealthInfo& info);
+    virtual void serviceDied(uint64_t cookie,
+                             const wp<hidl::base::V1_0::IBase>& who);
+    bool isCharging() {
+        std::lock_guard<std::mutex> _l(mLock);
+        return statusToBool(mStatus);
+    }
+  private:
+    sp<hardware::health::V2_0::IHealth> mHealth;
+    status_t init();
+    BatteryStatus mStatus;
+    cb_fn_t mCb;
+    std::mutex mLock;
+    std::condition_variable mCond;
+    std::unique_ptr<std::thread> mThread;
+    bool mDone;
+    bool statusToBool(const BatteryStatus &s) const {
+        return (s == BatteryStatus::CHARGING) ||
+               (s ==  BatteryStatus::FULL);
+    }
+};
+
+status_t BatteryListenerImpl::init()
+{
+    int tries = 0;
+
+    if (mHealth != NULL)
+        return INVALID_OPERATION;
+
+    do {
+        mHealth = hardware::health::V2_0::get_health_service();
+        if (mHealth != NULL)
+            break;
+        usleep(GET_HEALTH_SVC_WAIT_TIME_MS * 1000);
+        tries++;
+    } while(tries < GET_HEALTH_SVC_RETRY_CNT);
+
+    if (mHealth == NULL) {
+        ALOGE("no health service found, retries %d", tries);
+        return NO_INIT;
+    } else {
+        ALOGI("Get health service in %d tries", tries);
+    }
+    mStatus = BatteryStatus::UNKNOWN;
+    auto ret = mHealth->getChargeStatus([&](Result r, BatteryStatus status) {
+        if (r != Result::SUCCESS) {
+            ALOGE("batterylistener: cannot get battery status");
+            return;
+        }
+        mStatus = status;
+    });
+    if (!ret.isOk())
+        ALOGE("batterylistener: get charge status transaction error");
+
+    if (mStatus == BatteryStatus::UNKNOWN)
+        ALOGW("batterylistener: init: invalid battery status");
+    mDone = false;
+    mThread = std::make_unique<std::thread>([this]() {
+            std::unique_lock<std::mutex> l(mLock);
+            BatteryStatus local_status = mStatus;
+            while (!mDone) {
+                if (local_status == mStatus) {
+                    mCond.wait(l);
+                    continue;
+                }
+                local_status = mStatus;
+                switch (local_status) {
+                    // NOT_CHARGING is a special event that indicates, a battery is connected,
+                    // but not charging. This is seen for approx a second
+                    // after charger is plugged in. A charging event is eventually received.
+                    // We must try to avoid an unnecessary cb to HAL
+                    // only to call it again shortly.
+                    // An option to deal with this transient event would be to ignore this.
+                    // Or process this event with a slight delay (i.e cancel this event
+                    // if a different event comes in within a timeout
+                    case BatteryStatus::NOT_CHARGING : {
+                        auto mStatusnot_ncharging =
+                                [this, local_status]() { return mStatus != local_status; };
+                        mCond.wait_for(l, 3s, mStatusnot_ncharging);
+                        if (mStatusnot_ncharging()) // i.e event changed
+                            break;
+                        [[clang::fallthrough]]; //explicit fall-through between switch labels
+                    }
+                    default:
+                        bool c = statusToBool(local_status);
+                        ALOGI("healthInfo cb thread: cb %s", c ? "CHARGING" : "NOT CHARGING");
+                        l.unlock();
+                        mCb(c);
+                        l.lock();
+                        break;
+                }
+            }
+    });
+    auto reg = mHealth->registerCallback(this);
+    if (!reg.isOk()) {
+        ALOGE("Transaction error in registeringCb to HealthHAL death: %s",
+                reg.description().c_str());
+    }
+
+    auto linked = mHealth->linkToDeath(this, 0 /* cookie */);
+    if (!linked.isOk() || linked == false) {
+        ALOGE("Transaction error in linking to HealthHAL death: %s", linked.description().c_str());
+    }
+    return NO_ERROR;
+}
+
+BatteryListenerImpl::BatteryListenerImpl(cb_fn_t cb) :
+        mCb(cb)
+{
+    init();
+}
+
+BatteryListenerImpl::~BatteryListenerImpl()
+{
+    {
+        std::lock_guard<std::mutex> _l(mLock);
+        if (mHealth != NULL)
+            mHealth->unlinkToDeath(this);
+            auto r = mHealth->unlinkToDeath(this);
+            if (!r.isOk() || r == false) {
+                ALOGE("Transaction error in unregister to HealthHAL death: %s",
+                        r.description().c_str());
+            }
+    }
+    mDone = true;
+    mThread->join();
+}
+
+void BatteryListenerImpl::serviceDied(uint64_t cookie __unused,
+                                     const wp<hidl::base::V1_0::IBase>& who)
+{
+    {
+        std::lock_guard<std::mutex> _l(mLock);
+        if (mHealth == NULL || !interfacesEqual(mHealth, who.promote())) {
+            ALOGE("health not initialized or unknown interface died");
+            return;
+        }
+        ALOGI("health service died, reinit");
+        mDone = true;
+    }
+    mThread->join();
+    std::lock_guard<std::mutex> _l(mLock);
+    init();
+}
+
+// this callback seems to be a SYNC callback and so
+// waits for return before next event is issued.
+// therefore we need not have a queue to process
+// NOT_CHARGING and CHARGING concurrencies.
+// Replace single var by a list if this assumption is broken
+Return<void> BatteryListenerImpl::healthInfoChanged(
+        const hardware::health::V2_0::HealthInfo& info)
+{
+    ALOGV("healthInfoChanged: %d", info.legacy.batteryStatus);
+    std::unique_lock<std::mutex> l(mLock);
+    if (info.legacy.batteryStatus != mStatus) {
+        mStatus = info.legacy.batteryStatus;
+        mCond.notify_one();
+    }
+    return Void();
+}
+
+static sp<BatteryListenerImpl> batteryListener;
+status_t batteryPropertiesListenerInit(BatteryListenerImpl::cb_fn_t cb)
+{
+    ALOGV("batteryPropertiesListenerInit entry");
+    batteryListener = new BatteryListenerImpl(cb);
+    return NO_ERROR;
+}
+
+status_t batteryPropertiesListenerDeinit()
+{
+    batteryListener.clear();
+    return OK;
+}
+
+bool batteryPropertiesListenerIsCharging()
+{
+    return batteryListener->isCharging();
+}
+
+} // namespace android
+
+void loc_extn_battery_properties_listener_init(battery_status_change_fn_t fn)
+{
+    ALOGV("loc_extn_battery_properties_listener_init entry");
+    if (!sIsBatteryListened) {
+        std::thread t1(android::batteryPropertiesListenerInit,
+                [=](bool charging) { fn(charging); });
+        t1.detach();
+        sIsBatteryListened = true;
+    }
+}
+
+void loc_extn_battery_properties_listener_deinit()
+{
+    android::batteryPropertiesListenerDeinit();
+}
+
+bool loc_extn_battery_properties_is_charging()
+{
+    return android::batteryPropertiesListenerIsCharging();
+}

android/utils/battery_listener.h

@@ -0,0 +1,32 @@
+/*
+* Copyright (c) 2019, 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.
+*/
+typedef void (* battery_status_change_fn_t)(bool);
+void loc_extn_battery_properties_listener_init(battery_status_change_fn_t fn);
+void loc_extn_battery_properties_listener_deinit();
+bool loc_extn_battery_properties_is_charging();

core/SystemStatus.cpp

@@ -1723,5 +1723,18 @@ bool SystemStatus::eventConnectionStatus(bool connected, int8_t type,
     return true;
 }
 
+/******************************************************************************
+@brief      API to update power connect state
+
+@param[In]  power connect status
+
+@return     true when successfully done
+******************************************************************************/
+bool SystemStatus::updatePowerConnectState(bool charging)
+{
+    SystemStatusPowerConnectState s(charging);
+    mSysStatusObsvr.notify({&s});
+    return true;
+}
 } // namespace loc_core
 

core/SystemStatus.h

@@ -858,6 +858,7 @@ public:
     bool setDefaultGnssEngineStates(void);
     bool eventConnectionStatus(bool connected, int8_t type,
                                bool roaming, NetworkHandle networkHandle);
+    bool updatePowerConnectState(bool charging);
 };
 
 } // namespace loc_core

gnss/GnssAdapter.cpp

@@ -1636,9 +1636,10 @@ GnssAdapter::gnssSvTypeConfigUpdate(const GnssSvTypeConfig& config)
 void
 GnssAdapter::gnssSvTypeConfigUpdate(bool sendReset)
 {
-    LOC_LOGd("constellations blacklisted 0x%" PRIx64 ", enabled 0x%" PRIx64 ", sendReset %d",
+    LOC_LOGd("size %zu constellations blacklisted 0x%" PRIx64 ", enabled 0x%" PRIx64
-             mGnssSvTypeConfig.blacklistedSvTypesMask, mGnssSvTypeConfig.enabledSvTypesMask,
+             ", sendReset %d",
-             sendReset);
+             mGnssSvTypeConfig.size, mGnssSvTypeConfig.blacklistedSvTypesMask,
+             mGnssSvTypeConfig.enabledSvTypesMask, sendReset);
 
     if (mGnssSvTypeConfig.size == sizeof(mGnssSvTypeConfig)) {
 
@@ -1674,8 +1675,6 @@ GnssAdapter::gnssSvTypeConfigUpdate(bool sendReset)
             svTypeConfig.enabledSvTypesMask = mGnssSvTypeConfig.enabledSvTypesMask;
             mLocApi->setConstellationControl(svTypeConfig);
         }
-    } else {
-        LOC_LOGE("Invalid GnssSvTypeConfig size");
     }
 }
 

gnss/location_gnss.cpp

@@ -78,6 +78,7 @@ static void odcpiInject(const Location& location);
 
 static void blockCPI(double latitude, double longitude, float accuracy,
                      int blockDurationMsec, double latLonDiffThreshold);
+static void updateBatteryStatus(bool charging);
 
 static const GnssInterface gGnssInterface = {
     sizeof(GnssInterface),
@@ -115,7 +116,8 @@ static const GnssInterface gGnssInterface = {
     enableNfwLocationAccess,
     nfwInit,
     getPowerStateChanges,
-    injectLocationExt
+    injectLocationExt,
+    updateBatteryStatus
 };
 
 #ifndef DEBUG_X86
@@ -382,3 +384,9 @@ static void injectLocationExt(const GnssLocationInfoNotification &locationInfo)
        gGnssAdapter->injectLocationExtCommand(locationInfo);
    }
 }
+
+static void updateBatteryStatus(bool charging) {
+    if (NULL != gGnssAdapter) {
+        gGnssAdapter->getSystemStatus()->updatePowerConnectState(charging);
+    }
+}

location/LocationAPIClientBase.cpp

@@ -366,7 +366,7 @@ void LocationAPIClientBase::locAPIStopTracking()
             mLocationAPI->stopTracking(session);
             mTracking = false;
         } else {
-            LOC_LOGE("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, session);
+            LOC_LOGD("%s:%d] invalid session: %d.", __FUNCTION__, __LINE__, session);
         }
     }
     pthread_mutex_unlock(&mMutex);

location/location_interface.h

@@ -87,6 +87,7 @@ struct GnssInterface {
     void (*nfwInit)(const NfwCbInfo& cbInfo);
     void (*getPowerStateChanges)(void* powerStateCb);
     void (*injectLocationExt)(const GnssLocationInfoNotification &locationInfo);
+    void (*updateBatteryStatus)(bool charging);
 };
 
 struct BatchingInterface {

utils/LocIpc.cpp

@@ -354,20 +354,11 @@ unique_ptr<LocIpcRecver> LocIpc::getLocIpcQrtrRecver(const shared_ptr<ILocIpcLis
                                                      int service, int instance) {
     typedef unique_ptr<LocIpcRecver> (*creator_t)(const shared_ptr<ILocIpcListener>&, int, int);
     static creator_t creator = (creator_t)dlGetSymFromLib(sLibQrtrHandle, sLibQrtrName,
+#ifdef USE_GLIB
+            "_ZN8loc_util22createLocIpcQrtrRecverERKSt10shared_ptrINS_15ILocIpcListenerEEii");
+#else
             "_ZN8loc_util22createLocIpcQrtrRecverERKNSt3__110shared_ptrINS_15ILocIpcListenerEEEii");
-    return (nullptr == creator) ? nullptr : creator(listener, service, instance);
+#endif
-}
-shared_ptr<LocIpcSender> LocIpc::getLocIpcQsockSender(int service, int instance) {
-    typedef shared_ptr<LocIpcSender> (*creator_t) (int, int);
-    static creator_t creator = (creator_t)dlGetSymFromLib(sLibQrtrHandle, sLibQrtrName,
-            "_ZN8loc_util23createLocIpcQsockSenderEii");
-    return (nullptr == creator) ? nullptr : creator(service, instance);
-}
-unique_ptr<LocIpcRecver> LocIpc::getLocIpcQsockRecver(const shared_ptr<ILocIpcListener>& listener,
-                                                      int service, int instance) {
-    typedef unique_ptr<LocIpcRecver> (*creator_t)(const shared_ptr<ILocIpcListener>&, int, int);
-    static creator_t creator = (creator_t)dlGetSymFromLib(sLibQrtrHandle, sLibQrtrName,
-            "_ZN8loc_util23createLocIpcQsockRecverERKSt10shared_ptrINS_15ILocIpcListenerEEii");
     return (nullptr == creator) ? nullptr : creator(listener, service, instance);
 }
 shared_ptr<LocIpcSender> LocIpc::getLocIpcInetTcpSender(const char* serverName, int32_t port) {

utils/LocIpc.h

@@ -70,8 +70,6 @@ public:
             getLocIpcInetTcpSender(const char* serverName, int32_t port);
     static shared_ptr<LocIpcSender>
             getLocIpcQrtrSender(int service, int instance);
-    static shared_ptr<LocIpcSender>
-            getLocIpcQsockSender(int service, int instance);
 
     static unique_ptr<LocIpcRecver>
             getLocIpcLocalRecver(const shared_ptr<ILocIpcListener>& listener,
@@ -82,9 +80,6 @@ public:
     static unique_ptr<LocIpcRecver>
             getLocIpcQrtrRecver(const shared_ptr<ILocIpcListener>& listener,
                                 int service, int instance);
-    static unique_ptr<LocIpcRecver>
-            getLocIpcQsockRecver(const shared_ptr<ILocIpcListener>& listener,
-                                 int service, int instance);
 
     static pair<shared_ptr<LocIpcSender>, unique_ptr<LocIpcRecver>>
             getLocIpcQmiLocServiceSenderRecverPair(const shared_ptr<ILocIpcListener>& listener,

utils/loc_nmea.cpp

@@ -792,6 +792,7 @@ SIDE EFFECTS
 ===========================================================================*/
 static void loc_nmea_generate_DTM(const LocLla &ref_lla,
                                   const LocLla &local_lla,
+                                  char *talker,
                                   char *sentence,
                                   int bufSize)
 {
@@ -828,7 +829,7 @@ static void loc_nmea_generate_DTM(const LocLla &ref_lla,
         default:
             break;
     }
-    length = snprintf(pMarker , lengthRemaining , "$GPDTM,%s,," , local_datum);
+    length = snprintf(pMarker , lengthRemaining , "$%sDTM,%s,," , talker, local_datum);
     if (length < 0 || length >= lengthRemaining) {
         LOC_LOGE("NMEA Error in string formatting");
         return;
@@ -1226,7 +1227,7 @@ void loc_nmea_generate_pos(const UlpLocation &location,
         // -------------------
         // ------$--DTM-------
         // -------------------
-        loc_nmea_generate_DTM(ref_lla, local_lla, sentence_DTM, sizeof(sentence_DTM));
+        loc_nmea_generate_DTM(ref_lla, local_lla, talker, sentence_DTM, sizeof(sentence_DTM));
 
         // -------------------
         // ------$--RMC-------