Batching and Geofence moved to GNSS HAL

Addition of BatchingAdapter and GeofenceAdapter.
Deprecated Background LOC QMI Client and renamed
LocDualContext renamed to LocContext.
Moved some common Adapter functions into LocAdapterBase.
Added Distance Based Tracking logic into GnssAdapter.
Addition of flp.conf
Deprecated GEOFENCE capabilities configuration in
gps.conf

CRs-fixed: 2342200
Change-Id: I6b6257c4cf296e5a8c56bc0b149e4de77cf6cdf9

9 files changed, 583 insertions, 252 deletions

diff --git a/core/Android.mk b/core/Android.mk
index 97614a1..bd955c1 100644
--- a/core/Android.mk
+++ b/core/Android.mk
@@ -21,7 +21,7 @@ LOCAL_SRC_FILES += \
     LocApiBase.cpp \
     LocAdapterBase.cpp \
     ContextBase.cpp \
-    LocDualContext.cpp \
+    LocContext.cpp \
     loc_core_log.cpp \
     data-items/DataItemsFactoryProxy.cpp \
     SystemStatusOsObserver.cpp \
diff --git a/core/LocAdapterBase.cpp b/core/LocAdapterBase.cpp
index cea72fa..5f6a0c8 100644
--- a/core/LocAdapterBase.cpp
+++ b/core/LocAdapterBase.cpp
@@ -46,7 +46,8 @@ LocAdapterBase::LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
                                LocAdapterProxyBase *adapterProxyBase) :
     mIsMaster(isMaster), mEvtMask(mask), mContext(context),
     mLocApi(context->getLocApi()), mLocAdapterProxyBase(adapterProxyBase),
-    mMsgTask(context->getMsgTask())
+    mMsgTask(context->getMsgTask()),
+    mIsEngineCapabilitiesKnown(ContextBase::sIsEngineCapabilitiesKnown)
 {
     mLocApi->addAdapter(this);
 }
@@ -203,4 +204,208 @@ 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;
+        }
+    } 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));
+}
+
 } // namespace loc_core
diff --git a/core/LocAdapterBase.h b/core/LocAdapterBase.h
index 8aa7112..05b72db 100644
--- a/core/LocAdapterBase.h
+++ b/core/LocAdapterBase.h
@@ -51,8 +51,8 @@ inline bool operator ==(LocationSessionKey const& left, LocationSessionKey const
 inline bool operator !=(LocationSessionKey const& left, LocationSessionKey const& right) {
     return left.id != right.id || left.client != right.client;
 }
-typedef std::map<LocationSessionKey, LocationOptions> LocationSessionMap;
-typedef std::map<LocationSessionKey, TrackingOptions> TrackingOptionsMap;
+
+typedef void (*removeClientCompleteCallback)(LocationAPI* client);
 
 namespace loc_core {
 
@@ -62,6 +62,8 @@ class LocAdapterBase {
 private:
     static uint32_t mSessionIdCounter;
     const bool mIsMaster;
+    bool mIsEngineCapabilitiesKnown = false;
+
 protected:
     LOC_API_ADAPTER_EVENT_MASK_T mEvtMask;
     ContextBase* mContext;
@@ -71,6 +73,20 @@ protected:
     inline LocAdapterBase(const MsgTask* msgTask) :
         mIsMaster(false), mEvtMask(0), mContext(NULL), mLocApi(NULL),
         mLocAdapterProxyBase(NULL), mMsgTask(msgTask) {}
+
+    /* ==== 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); }
     LocAdapterBase(const LOC_API_ADAPTER_EVENT_MASK_T mask,
@@ -126,12 +142,11 @@ public:
         return mIsMaster;
     }
 
+    inline bool isEngineCapabilitiesKnown() { return mIsEngineCapabilitiesKnown;}
+    inline void setEngineCapabilitiesKnown(bool value) { mIsEngineCapabilitiesKnown = value;}
+
     virtual void handleEngineUpEvent();
     virtual void handleEngineDownEvent();
-    inline virtual void setPositionModeCommand(LocPosMode& posMode) {
-
-        (void)posMode;
-    }
     virtual void reportPositionEvent(const UlpLocation& location,
                                      const GpsLocationExtended& locationExtended,
                                      enum loc_sess_status status,
@@ -174,6 +189,28 @@ public:
     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);
+
 };
 
 } // namespace loc_core
diff --git a/core/LocApiBase.cpp b/core/LocApiBase.cpp
index fac81e7..3c67af2 100644
--- a/core/LocApiBase.cpp
+++ b/core/LocApiBase.cpp
@@ -35,7 +35,7 @@
 #include <LocApiBase.h>
 #include <LocAdapterBase.h>
 #include <log_util.h>
-#include <LocDualContext.h>
+#include <LocContext.h>
 
 namespace loc_core {
 
@@ -197,8 +197,8 @@ bool LocApiBase::isInSession()
 }
 
 bool LocApiBase::needReport(const UlpLocation& ulpLocation,
-                                   enum loc_sess_status status,
-                                   LocPosTechMask techMask)
+                            enum loc_sess_status status,
+                            LocPosTechMask techMask)
 {
     bool reported = false;
 
@@ -563,6 +563,41 @@ void LocApiBase::reportGnssSvTypeConfig(const GnssSvTypeConfig& config)
     TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportGnssSvTypeConfigEvent(config));
 }
 
+void LocApiBase::geofenceBreach(size_t count, uint32_t* hwIds, Location& location,
+                                GeofenceBreachType breachType, uint64_t timestamp)
+{
+    TO_ALL_LOCADAPTERS(mLocAdapters[i]->geofenceBreachEvent(count, hwIds, location, breachType,
+                                                            timestamp));
+}
+
+void LocApiBase::geofenceStatus(GeofenceStatusAvailable available)
+{
+    TO_ALL_LOCADAPTERS(mLocAdapters[i]->geofenceStatusEvent(available));
+}
+
+void LocApiBase::reportDBTPosition(UlpLocation &location, GpsLocationExtended &locationExtended,
+                                   enum loc_sess_status status, LocPosTechMask loc_technology_mask)
+{
+    TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportPositionEvent(location, locationExtended, status,
+                                                            loc_technology_mask));
+}
+
+void LocApiBase::reportLocations(Location* locations, size_t count, BatchingMode batchingMode)
+{
+    TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportLocationsEvent(locations, count, batchingMode));
+}
+
+void LocApiBase::reportCompletedTrips(uint32_t accumulated_distance)
+{
+    TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportCompletedTripsEvent(accumulated_distance));
+}
+
+void LocApiBase::handleBatchStatusEvent(BatchingStatus batchStatus)
+{
+    TO_ALL_LOCADAPTERS(mLocAdapters[i]->reportBatchStatusChangeEvent(batchStatus));
+}
+
+
 enum loc_api_adapter_err LocApiBase::
    open(LOC_API_ADAPTER_EVENT_MASK_T /*mask*/)
 DEFAULT_IMPL(LOC_API_ADAPTER_ERR_SUCCESS)
@@ -611,10 +646,6 @@ void LocApiBase::
     atlCloseStatus(int /*handle*/, int /*is_succ*/)
 DEFAULT_IMPL()
 
-void LocApiBase::
-    setPositionMode(const LocPosMode& /*posMode*/)
-DEFAULT_IMPL()
-
 LocationError LocApiBase::
     setServerSync(const char* /*url*/, int /*len*/, LocServerType /*type*/)
 DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
@@ -750,4 +781,101 @@ DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
 
 LocationError LocApiBase::getGnssEnergyConsumed()
 DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
+
+
+void LocApiBase::addGeofence(uint32_t /*clientId*/, const GeofenceOption& /*options*/,
+        const GeofenceInfo& /*info*/,
+        LocApiResponseData<LocApiGeofenceData>* /*adapterResponseData*/)
+DEFAULT_IMPL()
+
+void LocApiBase::removeGeofence(uint32_t /*hwId*/, uint32_t /*clientId*/,
+        LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+void LocApiBase::pauseGeofence(uint32_t /*hwId*/, uint32_t /*clientId*/,
+        LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+void LocApiBase::resumeGeofence(uint32_t /*hwId*/, uint32_t /*clientId*/,
+        LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+void LocApiBase::modifyGeofence(uint32_t /*hwId*/, uint32_t /*clientId*/,
+         const GeofenceOption& /*options*/, LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+void LocApiBase::startTimeBasedTracking(const TrackingOptions& /*options*/,
+        LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+void LocApiBase::stopTimeBasedTracking(LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+void LocApiBase::startDistanceBasedTracking(uint32_t /*sessionId*/,
+        const LocationOptions& /*options*/, LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+void LocApiBase::stopDistanceBasedTracking(uint32_t /*sessionId*/,
+        LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+void LocApiBase::startBatching(uint32_t /*sessionId*/, const LocationOptions& /*options*/,
+        uint32_t /*accuracy*/, uint32_t /*timeout*/, LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+void LocApiBase::stopBatching(uint32_t /*sessionId*/, LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+LocationError LocApiBase::startOutdoorTripBatchingSync(uint32_t /*tripDistance*/,
+        uint32_t /*tripTbf*/, uint32_t /*timeout*/)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
+
+void LocApiBase::startOutdoorTripBatching(uint32_t /*tripDistance*/, uint32_t /*tripTbf*/,
+        uint32_t /*timeout*/, LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+void LocApiBase::reStartOutdoorTripBatching(uint32_t /*ongoingTripDistance*/,
+        uint32_t /*ongoingTripInterval*/, uint32_t /*batchingTimeout,*/,
+        LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+LocationError LocApiBase::stopOutdoorTripBatchingSync(bool /*deallocBatchBuffer*/)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
+
+void LocApiBase::stopOutdoorTripBatching(bool /*deallocBatchBuffer*/,
+        LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+LocationError LocApiBase::getBatchedLocationsSync(size_t /*count*/)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
+
+void LocApiBase::getBatchedLocations(size_t /*count*/, LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+LocationError LocApiBase::getBatchedTripLocationsSync(size_t /*count*/,
+        uint32_t /*accumulatedDistance*/)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
+
+void LocApiBase::getBatchedTripLocations(size_t /*count*/, uint32_t /*accumulatedDistance*/,
+        LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+LocationError LocApiBase::queryAccumulatedTripDistanceSync(uint32_t& /*accumulated_trip_distance*/,
+        uint32_t& /*numOfBatchedPositions*/)
+DEFAULT_IMPL(LOCATION_ERROR_SUCCESS)
+
+void LocApiBase::queryAccumulatedTripDistance(
+        LocApiResponseData<LocApiBatchData>* /*adapterResponseData*/)
+DEFAULT_IMPL()
+
+void LocApiBase::setBatchSize(size_t /*size*/)
+DEFAULT_IMPL()
+
+void LocApiBase::setTripBatchSize(size_t /*size*/)
+DEFAULT_IMPL()
+
+void LocApiBase::addToCallQueue(LocApiResponse* /*adapterResponse*/)
+DEFAULT_IMPL()
+
+
 } // namespace loc_core
diff --git a/core/LocApiBase.h b/core/LocApiBase.h
index f0bd539..afdb83c 100644
--- a/core/LocApiBase.h
+++ b/core/LocApiBase.h
@@ -40,6 +40,7 @@ namespace loc_core {
 
 class ContextBase;
 struct LocApiResponse;
+template <typename> struct LocApiResponseData;
 
 int hexcode(char *hexstring, int string_size,
             const char *data, int data_size);
@@ -191,75 +192,50 @@ public:
     void reportGnssAdditionalSystemInfo(GnssAdditionalSystemInfo& additionalSystemInfo);
     void sendNfwNotification(GnssNfwNotification& notification);
 
-    // downward calls
-    // All below functions are to be defined by adapter specific modules:
-    // RPC, QMI, etc.  The default implementation is empty.
+    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);
-
-    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);
-
- //   // TODO:: called from izatapipds
-    virtual enum loc_api_adapter_err
-        setXtraData(char* data, int length);
-
-    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 void
-        setPositionMode(const LocPosMode& posMode);
-    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 void stopFix(LocApiResponse* adapterResponse);
+    virtual void deleteAidingData(const GnssAidingData& data, LocApiResponse* adapterResponse);
+    virtual void injectPosition(double latitude, double longitude, float accuracy);
+    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 enum loc_api_adapter_err setXtraData(char* data, int length);
+    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 enum loc_api_adapter_err setNMEATypesSync(uint32_t typesMask);
     virtual LocationError setLPPConfigSync(GnssConfigLppProfile profile);
-    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 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);
+            setAGLONASSProtocolSync(GnssConfigAGlonassPositionProtocolMask aGlonassProtocol);
     virtual LocationError setLPPeProtocolCpSync(GnssConfigLppeControlPlaneMask lppeCP);
     virtual LocationError setLPPeProtocolUpSync(GnssConfigLppeUserPlaneMask lppeUP);
     virtual GnssConfigSuplVersion convertSuplVersion(const uint32_t suplVersion);
@@ -270,23 +246,11 @@ public:
 
     virtual void getWwanZppFix();
     virtual void getBestAvailableZppFix();
-    virtual void installAGpsCert(const LocDerEncodedCertificate* pData,
-                                 size_t length,
-                                 uint32_t slotBitMask);
-    inline virtual void setInSession(bool inSession) {
-
-        (void)inSession;
-    }
-
-
-    void updateEvtMask();
-    void updateNmeaMask(uint32_t mask);
-
+    virtual void installAGpsCert(const LocDerEncodedCertificate* pData, size_t length,
+            uint32_t slotBitMask);
     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);
@@ -294,12 +258,55 @@ public:
     virtual void setConstellationControl(const GnssSvTypeConfig& config);
     virtual void getConstellationControl();
     virtual void resetConstellationControl();
-
-    virtual LocationError setConstrainedTuncMode(bool enabled,
-                                                 float tuncConstraint,
-                                                 uint32_t energyBudget);
+    virtual LocationError setConstrainedTuncMode(bool enabled, float tuncConstraint,
+            uint32_t energyBudget);
     virtual LocationError setPositionAssistedClockEstimatorMode(bool enabled);
     virtual LocationError 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);
+
 };
 
 typedef LocApiBase* (getLocApi_t)(LOC_API_ADAPTER_EVENT_MASK_T exMask,
diff --git a/core/LocContext.cpp b/core/LocContext.cpp
new file mode 100644
index 0000000..18d3f2d
--- /dev/null
+++ b/core/LocContext.cpp
@@ -0,0 +1,98 @@
+/* Copyright (c) 2011-2014, 2016-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.
+ *
+ */
+#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(LocThread::tCreate tCreator,
+                                          const char* name, bool joinable)
+{
+    if (NULL == mMsgTask) {
+        mMsgTask = new MsgTask(tCreator, name, joinable);
+    }
+    return mMsgTask;
+}
+
+inline
+const MsgTask* LocContext::getMsgTask(const char* name, bool joinable) {
+    return getMsgTask((LocThread::tCreate)NULL, name, joinable);
+}
+
+ContextBase* LocContext::getLocContext(LocThread::tCreate tCreator,
+            LocMsg* firstMsg, const char* name, bool joinable)
+{
+    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(tCreator, name, joinable);
+        mContext = new LocContext(msgTask);
+    }
+    pthread_mutex_unlock(&LocContext::mGetLocContextMutex);
+
+    if (firstMsg) {
+        mContext->sendMsg(firstMsg);
+    }
+
+    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)
+{
+}
+
+}
diff --git a/core/LocDualContext.h b/core/LocContext.h
index edfbfb7..fb7d009 100644
--- a/core/LocDualContext.h
+++ b/core/LocContext.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2014, 2017 The Linux Foundation. All rights reserved.
+/* Copyright (c) 2011-2014, 2017-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
@@ -26,8 +26,8 @@
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  */
-#ifndef __LOC_ENG_CONTEXT__
-#define __LOC_ENG_CONTEXT__
+#ifndef __LOC_CONTEXT__
+#define __LOC_CONTEXT__
 
 #include <stdbool.h>
 #include <ctype.h>
@@ -36,35 +36,26 @@
 
 namespace loc_core {
 
-class LocDualContext : public ContextBase {
+class LocContext : public ContextBase {
     static const MsgTask* mMsgTask;
-    static ContextBase* mFgContext;
-    static ContextBase* mBgContext;
+    static ContextBase* mContext;
     static const MsgTask* getMsgTask(LocThread::tCreate tCreator,
                                      const char* name, bool joinable = true);
     static const MsgTask* getMsgTask(const char* name, bool joinable = true);
     static pthread_mutex_t mGetLocContextMutex;
 
 protected:
-    LocDualContext(const MsgTask* msgTask,
-                   LOC_API_ADAPTER_EVENT_MASK_T exMask);
-    inline virtual ~LocDualContext() {}
+    LocContext(const MsgTask* msgTask);
+    inline virtual ~LocContext() {}
 
 public:
     static const char* mLBSLibName;
-    static const LOC_API_ADAPTER_EVENT_MASK_T mFgExclMask;
-    static const LOC_API_ADAPTER_EVENT_MASK_T mBgExclMask;
     static const char* mLocationHalName;
 
-    static ContextBase* getLocFgContext(LocThread::tCreate tCreator, LocMsg* firstMsg,
+    static ContextBase* getLocContext(LocThread::tCreate tCreator, LocMsg* firstMsg,
                                         const char* name, bool joinable = true);
-    inline static ContextBase* getLocFgContext(const char* name, bool joinable = true) {
-        return getLocFgContext(NULL, NULL, name, joinable);
-    }
-    static ContextBase* getLocBgContext(LocThread::tCreate tCreator, LocMsg* firstMsg,
-                                        const char* name, bool joinable = true);
-    inline static ContextBase* getLocBgContext(const char* name, bool joinable = true) {
-        return getLocBgContext(NULL, NULL, name, joinable);
+    inline static ContextBase* getLocContext(const char* name, bool joinable = true) {
+        return getLocContext(NULL, NULL, name, joinable);
     }
 
     static void injectFeatureConfig(ContextBase *context);
@@ -72,4 +63,4 @@ public:
 
 }
 
-#endif //__LOC_ENG_CONTEXT__
+#endif //__LOC_CONTEXT__
diff --git a/core/LocDualContext.cpp b/core/LocDualContext.cpp
deleted file mode 100644
index 9851d61..0000000
--- a/core/LocDualContext.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/* Copyright (c) 2011-2014, 2016-2017 The Linux Foundation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * 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_DualCtx"
-
-#include <cutils/sched_policy.h>
-#include <unistd.h>
-#include <LocDualContext.h>
-#include <msg_q.h>
-#include <log_util.h>
-#include <loc_log.h>
-
-namespace loc_core {
-
-// nothing exclude for foreground
-const LOC_API_ADAPTER_EVENT_MASK_T
-LocDualContext::mFgExclMask = 0;
-// excluded events for background clients
-const LOC_API_ADAPTER_EVENT_MASK_T
-LocDualContext::mBgExclMask =
-    (LOC_API_ADAPTER_BIT_SATELLITE_REPORT |
-     LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT |
-     LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT |
-     LOC_API_ADAPTER_BIT_IOCTL_REPORT |
-     LOC_API_ADAPTER_BIT_STATUS_REPORT |
-     LOC_API_ADAPTER_BIT_GEOFENCE_GEN_ALERT |
-     LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT);
-
-const MsgTask* LocDualContext::mMsgTask = NULL;
-ContextBase* LocDualContext::mFgContext = NULL;
-ContextBase* LocDualContext::mBgContext = NULL;
-// the name must be shorter than 15 chars
-const char* LocDualContext::mLocationHalName = "Loc_hal_worker";
-#ifndef USE_GLIB
-const char* LocDualContext::mLBSLibName = "liblbs_core.so";
-#else
-const char* LocDualContext::mLBSLibName = "liblbs_core.so.1";
-#endif
-
-pthread_mutex_t LocDualContext::mGetLocContextMutex = PTHREAD_MUTEX_INITIALIZER;
-
-const MsgTask* LocDualContext::getMsgTask(LocThread::tCreate tCreator,
-                                          const char* name, bool joinable)
-{
-    if (NULL == mMsgTask) {
-        mMsgTask = new MsgTask(tCreator, name, joinable);
-    }
-    return mMsgTask;
-}
-
-inline
-const MsgTask* LocDualContext::getMsgTask(const char* name, bool joinable) {
-    return getMsgTask((LocThread::tCreate)NULL, name, joinable);
-}
-
-ContextBase* LocDualContext::getLocFgContext(LocThread::tCreate tCreator,
-            LocMsg* firstMsg, const char* name, bool joinable)
-{
-    pthread_mutex_lock(&LocDualContext::mGetLocContextMutex);
-    LOC_LOGD("%s:%d]: querying ContextBase with tCreator", __func__, __LINE__);
-    if (NULL == mFgContext) {
-        LOC_LOGD("%s:%d]: creating msgTask with tCreator", __func__, __LINE__);
-        const MsgTask* msgTask = getMsgTask(tCreator, name, joinable);
-        mFgContext = new LocDualContext(msgTask,
-                                        mFgExclMask);
-    }
-    pthread_mutex_unlock(&LocDualContext::mGetLocContextMutex);
-
-    if (firstMsg) {
-        mFgContext->sendMsg(firstMsg);
-    }
-
-    return mFgContext;
-}
-
-ContextBase* LocDualContext::getLocBgContext(LocThread::tCreate tCreator,
-            LocMsg* firstMsg, const char* name, bool joinable)
-{
-    pthread_mutex_lock(&LocDualContext::mGetLocContextMutex);
-    LOC_LOGD("%s:%d]: querying ContextBase with tCreator", __func__, __LINE__);
-    if (NULL == mBgContext) {
-        LOC_LOGD("%s:%d]: creating msgTask with tCreator", __func__, __LINE__);
-        const MsgTask* msgTask = getMsgTask(tCreator, name, joinable);
-        mBgContext = new LocDualContext(msgTask,
-                                        mBgExclMask);
-    }
-    pthread_mutex_unlock(&LocDualContext::mGetLocContextMutex);
-
-    if (firstMsg) {
-        mBgContext->sendMsg(firstMsg);
-    }
-
-    return mBgContext;
-}
-
-void LocDualContext :: injectFeatureConfig(ContextBase *curContext)
-{
-    LOC_LOGD("%s:%d]: Calling LBSProxy (%p) to inject feature config",
-             __func__, __LINE__, ((LocDualContext *)curContext)->mLBSProxy);
-    ((LocDualContext *)curContext)->mLBSProxy->injectFeatureConfig(curContext);
-}
-
-LocDualContext::LocDualContext(const MsgTask* msgTask,
-                               LOC_API_ADAPTER_EVENT_MASK_T exMask) :
-    ContextBase(msgTask, exMask, mLBSLibName)
-{
-}
-
-}
diff --git a/core/Makefile.am b/core/Makefile.am
index 53059e4..ffd9357 100644
--- a/core/Makefile.am
+++ b/core/Makefile.am
@@ -15,7 +15,7 @@ libloc_core_la_h_sources = \
            LocApiBase.h \
            LocAdapterBase.h \
            ContextBase.h \
-           LocDualContext.h \
+           LocContext.h \
            LBSProxyBase.h \
            loc_core_log.h \
            LocAdapterProxyBase.h \
@@ -34,7 +34,7 @@ libloc_core_la_c_sources = \
            LocApiBase.cpp \
            LocAdapterBase.cpp \
            ContextBase.cpp \
-           LocDualContext.cpp \
+           LocContext.cpp \
            loc_core_log.cpp \
            data-items/DataItemsFactoryProxy.cpp \
            SystemStatusOsObserver.cpp \