FR 45623 - AGPM 1.0

Adding AGPM FR changes to add power
modes support.

CRs-Fixed: 2195518
Change-Id: Ifd1da6194b58ad5590ea755e3f6b237c4b4db2ad

7 files changed, 113 insertions, 65 deletions

diff --git a/location/ILocationAPI.h b/location/ILocationAPI.h
index ae695cf..3df6f79 100644
--- a/location/ILocationAPI.h
+++ b/location/ILocationAPI.h
@@ -53,7 +53,7 @@ public:
                 LOCATION_ERROR_ALREADY_STARTED if a startTracking session is already in progress
                 LOCATION_ERROR_CALLBACK_MISSING if no trackingCallback was passed
                 LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameter is invalid */
-    virtual uint32_t startTracking(LocationOptions&) = 0;
+    virtual uint32_t startTracking(TrackingOptions&) = 0;
 
     /** @brief Stops a tracking session associated with id parameter.
         responseCallback returns:
@@ -66,7 +66,7 @@ public:
                 LOCATION_ERROR_SUCCESS if successful
                 LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid
                 LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */
-    virtual void updateTrackingOptions(uint32_t id, LocationOptions&) = 0;
+    virtual void updateTrackingOptions(uint32_t id, TrackingOptions&) = 0;
 
     /* ================================== BATCHING ================================== */
 
@@ -86,7 +86,7 @@ public:
                 LOCATION_ERROR_CALLBACK_MISSING if no batchingCallback
                 LOCATION_ERROR_INVALID_PARAMETER if a parameter is invalid
                 LOCATION_ERROR_NOT_SUPPORTED if batching is not supported */
-    virtual uint32_t startBatching(LocationOptions&, BatchingOptions&) = 0;
+    virtual uint32_t startBatching(BatchingOptions&) = 0;
 
     /** @brief Stops a batching session associated with id parameter.
         responseCallback returns:
@@ -99,7 +99,7 @@ public:
                 LOCATION_ERROR_SUCCESS if successful
                 LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid
                 LOCATION_ERROR_ID_UNKNOWN if id is not associated with a batching session */
-    virtual void updateBatchingOptions(uint32_t id, LocationOptions&, BatchingOptions&) = 0;
+    virtual void updateBatchingOptions(uint32_t id, BatchingOptions&) = 0;
 
     /** @brief Gets a number of locations that are currently stored/batched
        on the low power processor, delivered by the batchingCallback passed in createInstance.
diff --git a/location/LocationAPI.cpp b/location/LocationAPI.cpp
index 060ce5f..581158b 100644
--- a/location/LocationAPI.cpp
+++ b/location/LocationAPI.cpp
@@ -25,6 +25,7 @@
  * 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_LocationAPI"
 
 #include <location_interface.h>
@@ -289,21 +290,21 @@ LocationAPI::updateCallbacks(LocationCallbacks& locationCallbacks)
 }
 
 uint32_t
-LocationAPI::startTracking(LocationOptions& locationOptions)
+LocationAPI::startTracking(TrackingOptions& trackingOptions)
 {
     uint32_t id = 0;
     pthread_mutex_lock(&gDataMutex);
 
     auto it = gData.clientData.find(this);
     if (it != gData.clientData.end()) {
-        if (gData.flpInterface != NULL && locationOptions.minDistance > 0) {
-            id = gData.flpInterface->startTracking(this, locationOptions);
-        } else if (gData.gnssInterface != NULL && needsGnssTrackingInfo(it->second)) {
-            id = gData.gnssInterface->startTracking(this, locationOptions);
-        } else if (gData.flpInterface != NULL) {
-            id = gData.flpInterface->startTracking(this, locationOptions);
-        } else if (gData.gnssInterface != NULL) {
-            id = gData.gnssInterface->startTracking(this, locationOptions);
+        if (NULL != gData.flpInterface && trackingOptions.minDistance > 0) {
+            id = gData.flpInterface->startTracking(this, trackingOptions);
+        } else if (NULL != gData.gnssInterface && needsGnssTrackingInfo(it->second)) {
+            id = gData.gnssInterface->startTracking(this, trackingOptions);
+        } else if (NULL != gData.flpInterface) {
+            id = gData.flpInterface->startTracking(this, trackingOptions);
+        } else if (NULL != gData.gnssInterface) {
+            id = gData.gnssInterface->startTracking(this, trackingOptions);
         } else {
             LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ",
                      __func__, __LINE__, this);
@@ -345,7 +346,8 @@ LocationAPI::stopTracking(uint32_t id)
 }
 
 void
-LocationAPI::updateTrackingOptions(uint32_t id, LocationOptions& locationOptions)
+LocationAPI::updateTrackingOptions(
+        uint32_t id, TrackingOptions& trackingOptions)
 {
     pthread_mutex_lock(&gDataMutex);
 
@@ -354,10 +356,10 @@ LocationAPI::updateTrackingOptions(uint32_t id, LocationOptions& locationOptions
         // we don't know if tracking was started on flp or gnss, so we call update on both, where
         // updateTracking call to the incorrect interface will fail without response back to client
         if (gData.gnssInterface != NULL) {
-            gData.gnssInterface->updateTrackingOptions(this, id, locationOptions);
+            gData.gnssInterface->updateTrackingOptions(this, id, trackingOptions);
         }
         if (gData.flpInterface != NULL) {
-            gData.flpInterface->updateTrackingOptions(this, id, locationOptions);
+            gData.flpInterface->updateTrackingOptions(this, id, trackingOptions);
         }
         if (gData.flpInterface == NULL && gData.gnssInterface == NULL) {
             LOC_LOGE("%s:%d]: No gnss/flp interface available for Location API client %p ",
@@ -372,13 +374,13 @@ LocationAPI::updateTrackingOptions(uint32_t id, LocationOptions& locationOptions
 }
 
 uint32_t
-LocationAPI::startBatching(LocationOptions& locationOptions, BatchingOptions &batchingOptions)
+LocationAPI::startBatching(BatchingOptions &batchingOptions)
 {
     uint32_t id = 0;
     pthread_mutex_lock(&gDataMutex);
 
-    if (gData.flpInterface != NULL) {
-        id = gData.flpInterface->startBatching(this, locationOptions, batchingOptions);
+    if (NULL != gData.flpInterface) {
+        id = gData.flpInterface->startBatching(this, batchingOptions);
     } else {
         LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
                  __func__, __LINE__, this);
@@ -393,7 +395,7 @@ LocationAPI::stopBatching(uint32_t id)
 {
     pthread_mutex_lock(&gDataMutex);
 
-    if (gData.flpInterface != NULL) {
+    if (NULL != gData.flpInterface) {
         gData.flpInterface->stopBatching(this, id);
     } else {
         LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
@@ -404,16 +406,12 @@ LocationAPI::stopBatching(uint32_t id)
 }
 
 void
-LocationAPI::updateBatchingOptions(uint32_t id,
-        LocationOptions& locationOptions, BatchingOptions& batchOptions)
+LocationAPI::updateBatchingOptions(uint32_t id, BatchingOptions& batchOptions)
 {
     pthread_mutex_lock(&gDataMutex);
 
-    if (gData.flpInterface != NULL) {
-        gData.flpInterface->updateBatchingOptions(this,
-                                                  id,
-                                                  locationOptions,
-                                                  batchOptions);
+    if (NULL != gData.flpInterface) {
+        gData.flpInterface->updateBatchingOptions(this, id, batchOptions);
     } else {
         LOC_LOGE("%s:%d]: No flp interface available for Location API client %p ",
                  __func__, __LINE__, this);
diff --git a/location/LocationAPI.h b/location/LocationAPI.h
index cfdb19f..f4f31f9 100644
--- a/location/LocationAPI.h
+++ b/location/LocationAPI.h
@@ -63,8 +63,8 @@ public:
                 LOCATION_ERROR_SUCCESS if session was successfully started
                 LOCATION_ERROR_ALREADY_STARTED if a startTracking session is already in progress
                 LOCATION_ERROR_CALLBACK_MISSING if no trackingCallback was passed in createInstance
-                LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameter is invalid */
-    virtual uint32_t startTracking(LocationOptions&) override;
+                LOCATION_ERROR_INVALID_PARAMETER if TrackingOptions parameter is invalid */
+    virtual uint32_t startTracking(TrackingOptions&) override;
 
     /* stopTracking stops a tracking session associated with id parameter.
         responseCallback returns:
@@ -72,12 +72,12 @@ public:
                 LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */
     virtual void stopTracking(uint32_t id) override;
 
-    /* updateTrackingOptions changes the LocationOptions of a tracking session associated with id
+    /* updateTrackingOptions changes the TrackingOptions of a tracking session associated with id
         responseCallback returns:
                 LOCATION_ERROR_SUCCESS if successful
-                LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid
+                LOCATION_ERROR_INVALID_PARAMETER if TrackingOptions parameters are invalid
                 LOCATION_ERROR_ID_UNKNOWN if id is not associated with a tracking session */
-    virtual void updateTrackingOptions(uint32_t id, LocationOptions&) override;
+    virtual void updateTrackingOptions(uint32_t id, TrackingOptions&) override;
 
     /* ================================== BATCHING ================================== */
 
@@ -96,7 +96,7 @@ public:
                 LOCATION_ERROR_CALLBACK_MISSING if no batchingCallback was passed in createInstance
                 LOCATION_ERROR_INVALID_PARAMETER if a parameter is invalid
                 LOCATION_ERROR_NOT_SUPPORTED if batching is not supported */
-    virtual uint32_t startBatching(LocationOptions&, BatchingOptions&) override;
+    virtual uint32_t startBatching(BatchingOptions&) override;
 
     /* stopBatching stops a batching session associated with id parameter.
         responseCallback returns:
@@ -104,12 +104,12 @@ public:
                 LOCATION_ERROR_ID_UNKNOWN if id is not associated with batching session */
     virtual void stopBatching(uint32_t id) override;
 
-    /* updateBatchingOptions changes the LocationOptions of a batching session associated with id
+    /* updateBatchingOptions changes the BatchingOptions of a batching session associated with id
         responseCallback returns:
                 LOCATION_ERROR_SUCCESS if successful
-                LOCATION_ERROR_INVALID_PARAMETER if LocationOptions parameters are invalid
+                LOCATION_ERROR_INVALID_PARAMETER if BatchingOptions parameters are invalid
                 LOCATION_ERROR_ID_UNKNOWN if id is not associated with a batching session */
-    virtual void updateBatchingOptions(uint32_t id, LocationOptions&, BatchingOptions&) override;
+    virtual void updateBatchingOptions(uint32_t id, BatchingOptions&) override;
 
     /* getBatchedLocations gets a number of locations that are currently stored/batched
        on the low power processor, delivered by the batchingCallback passed in createInstance.
diff --git a/location/LocationAPIClientBase.cpp b/location/LocationAPIClientBase.cpp
index 65a0984..67e559b 100644
--- a/location/LocationAPIClientBase.cpp
+++ b/location/LocationAPIClientBase.cpp
@@ -330,7 +330,7 @@ LocationAPIClientBase::~LocationAPIClientBase()
     pthread_mutex_destroy(&mMutex);
 }
 
-uint32_t LocationAPIClientBase::locAPIStartTracking(LocationOptions& options)
+uint32_t LocationAPIClientBase::locAPIStartTracking(TrackingOptions& options)
 {
     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
     pthread_mutex_lock(&mMutex);
@@ -372,7 +372,7 @@ void LocationAPIClientBase::locAPIStopTracking()
     pthread_mutex_unlock(&mMutex);
 }
 
-void LocationAPIClientBase::locAPIUpdateTrackingOptions(LocationOptions& options)
+void LocationAPIClientBase::locAPIUpdateTrackingOptions(TrackingOptions& options)
 {
     pthread_mutex_lock(&mMutex);
     if (mLocationAPI) {
@@ -404,9 +404,8 @@ int32_t LocationAPIClientBase::locAPIGetBatchSize()
     return mBatchSize;
 }
 
-
-uint32_t LocationAPIClientBase::locAPIStartSession(uint32_t id, uint32_t sessionMode,
-        LocationOptions& locationOptions)
+uint32_t LocationAPIClientBase::locAPIStartSession(
+        uint32_t id, uint32_t sessionMode, TrackingOptions&& options)
 {
     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
     pthread_mutex_lock(&mMutex);
@@ -420,7 +419,7 @@ uint32_t LocationAPIClientBase::locAPIStartSession(uint32_t id, uint32_t session
             uint32_t batchingSession = 0;
 
             if (sessionMode == SESSION_MODE_ON_FIX) {
-                trackingSession = mLocationAPI->startTracking(locationOptions);
+                trackingSession = mLocationAPI->startTracking(options);
                 LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, trackingSession);
                 mRequestQueues[REQUEST_SESSION].push(new StartTrackingRequest(*this));
             } else {
@@ -439,7 +438,12 @@ uint32_t LocationAPIClientBase::locAPIStartSession(uint32_t id, uint32_t session
                     break;
                 }
 
-                batchingSession = mLocationAPI->startBatching(locationOptions, batchOptions);
+                // Populate location option values
+                batchOptions.minDistance = options.minDistance;
+                batchOptions.minInterval = options.minInterval;
+                batchOptions.mode = options.mode;
+
+                batchingSession = mLocationAPI->startBatching(batchOptions);
                 LOC_LOGI("%s:%d] start new session: %d", __FUNCTION__, __LINE__, batchingSession);
                 mRequestQueues[REQUEST_SESSION].setSession(batchingSession);
                 mRequestQueues[REQUEST_SESSION].push(new StartBatchingRequest(*this));
@@ -496,8 +500,8 @@ uint32_t LocationAPIClientBase::locAPIStopSession(uint32_t id)
     return retVal;
 }
 
-uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(uint32_t id, uint32_t sessionMode,
-        LocationOptions& options)
+uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(
+        uint32_t id, uint32_t sessionMode, TrackingOptions&& options)
 {
     uint32_t retVal = LOCATION_ERROR_GENERAL_FAILURE;
     pthread_mutex_lock(&mMutex);
@@ -554,13 +558,18 @@ uint32_t LocationAPIClientBase::locAPIUpdateSessionOptions(uint32_t id, uint32_t
                     mLocationAPI->stopTracking(trackingSession);
                     trackingSession = 0;
 
+                    // Populate location option values
+                    batchOptions.minDistance = options.minDistance;
+                    batchOptions.minInterval = options.minInterval;
+                    batchOptions.mode = options.mode;
+
                     // start batching
-                    batchingSession = mLocationAPI->startBatching(options, batchOptions);
+                    batchingSession = mLocationAPI->startBatching(batchOptions);
                     LOC_LOGI("%s:%d] start new session: %d",
                             __FUNCTION__, __LINE__, batchingSession);
                     mRequestQueues[REQUEST_SESSION].setSession(batchingSession);
                 } else {
-                    mLocationAPI->updateBatchingOptions(batchingSession, options, batchOptions);
+                    mLocationAPI->updateBatchingOptions(batchingSession, batchOptions);
                 }
 
             }
diff --git a/location/LocationAPIClientBase.h b/location/LocationAPIClientBase.h
index 4d48932..bcc39f3 100644
--- a/location/LocationAPIClientBase.h
+++ b/location/LocationAPIClientBase.h
@@ -209,16 +209,16 @@ public:
     LocationAPIRequest* getRequestBySession(uint32_t session);
 
     // LocationAPI
-    uint32_t locAPIStartTracking(LocationOptions& options);
+    uint32_t locAPIStartTracking(TrackingOptions& trackingOptions);
     void locAPIStopTracking();
-    void locAPIUpdateTrackingOptions(LocationOptions& options);
+    void locAPIUpdateTrackingOptions(TrackingOptions& trackingOptions);
 
     int32_t locAPIGetBatchSize();
-    uint32_t locAPIStartSession(uint32_t id, uint32_t sessionMode,
-            LocationOptions& options);
+    uint32_t locAPIStartSession(
+            uint32_t id, uint32_t sessionMode, TrackingOptions&& trackingOptions);
     uint32_t locAPIStopSession(uint32_t id);
-    uint32_t locAPIUpdateSessionOptions(uint32_t id, uint32_t sessionMode,
-            LocationOptions& options);
+    uint32_t locAPIUpdateSessionOptions(
+            uint32_t id, uint32_t sessionMode, TrackingOptions&& trackingOptions);
     uint32_t locAPIGetBatchedLocations(uint32_t id, size_t count);
 
     uint32_t locAPIAddGeofences(size_t count, uint32_t* ids,
diff --git a/location/LocationDataTypes.h b/location/LocationDataTypes.h
index 5d1c809..9809e61 100644
--- a/location/LocationDataTypes.h
+++ b/location/LocationDataTypes.h
@@ -533,18 +533,60 @@ typedef struct {
     LocationTechnologyMask techMask;
 } Location;
 
-typedef struct {
+struct LocationOptions {
     size_t size;          // set to sizeof(LocationOptions)
     uint32_t minInterval; // in milliseconds
     uint32_t minDistance; // in meters. if minDistance > 0, gnssSvCallback/gnssNmeaCallback/
                           // gnssMeasurementsCallback may not be called
     GnssSuplMode mode;    // Standalone/MS-Based/MS-Assisted
-} LocationOptions;
 
-typedef struct {
-    size_t size;
+    inline LocationOptions() :
+            size(0), minInterval(0), minDistance(0), mode(GNSS_SUPL_MODE_STANDALONE) {}
+};
+
+typedef enum {
+    GNSS_POWER_MODE_INVALID = 0,
+    GNSS_POWER_MODE_M1,  /* Improved Accuracy Mode */
+    GNSS_POWER_MODE_M2,  /* Normal Mode */
+    GNSS_POWER_MODE_M3,  /* Background Mode */
+    GNSS_POWER_MODE_M4,  /* Background Mode */
+    GNSS_POWER_MODE_M5   /* Background Mode */
+} GnssPowerMode;
+
+struct TrackingOptions : LocationOptions {
+    GnssPowerMode powerMode; /* Power Mode to be used for time based tracking
+                                sessions */
+    uint32_t tbm;  /* Time interval between measurements specified in millis.
+                      Applicable to background power modes */
+
+    inline TrackingOptions() :
+            LocationOptions(), powerMode(GNSS_POWER_MODE_INVALID), tbm(0) {}
+    inline TrackingOptions(size_t s, GnssPowerMode m, uint32_t t) :
+            LocationOptions(), powerMode(m), tbm(t) { LocationOptions::size = s; }
+    inline TrackingOptions(const LocationOptions& options) :
+            LocationOptions(options), powerMode(GNSS_POWER_MODE_INVALID), tbm(0) {}
+    inline void setLocationOptions(const LocationOptions& options) {
+        minInterval = options.minInterval;
+        minDistance = options.minDistance;
+        mode = options.mode;
+    }
+};
+
+struct BatchingOptions : LocationOptions {
     BatchingMode batchingMode;
-} BatchingOptions;
+
+    inline BatchingOptions() :
+            LocationOptions(), batchingMode(BATCHING_MODE_ROUTINE) {}
+    inline BatchingOptions(size_t s, BatchingMode m) :
+            LocationOptions(), batchingMode(m) { LocationOptions::size = s; }
+    inline BatchingOptions(const LocationOptions& options) :
+            LocationOptions(options), batchingMode(BATCHING_MODE_ROUTINE) {}
+    inline void setLocationOptions(const LocationOptions& options) {
+        minInterval = options.minInterval;
+        minDistance = options.minDistance;
+        mode = options.mode;
+    }
+};
 
 typedef struct {
     size_t size;
diff --git a/location/location_interface.h b/location/location_interface.h
index f4f904d..a460bb6 100644
--- a/location/location_interface.h
+++ b/location/location_interface.h
@@ -39,8 +39,8 @@ struct GnssInterface {
     void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks);
     void (*removeClient)(LocationAPI* client);
     void (*requestCapabilities)(LocationAPI* client);
-    uint32_t (*startTracking)(LocationAPI* client, LocationOptions& options);
-    void (*updateTrackingOptions)(LocationAPI* client, uint32_t id, LocationOptions& options);
+    uint32_t (*startTracking)(LocationAPI* client, TrackingOptions&);
+    void (*updateTrackingOptions)(LocationAPI* client, uint32_t id, TrackingOptions&);
     void (*stopTracking)(LocationAPI* client, uint32_t id);
     void (*gnssNiResponse)(LocationAPI* client, uint32_t id, GnssNiResponse response);
     void (*setControlCallbacks)(LocationControlCallbacks& controlCallbacks);
@@ -70,13 +70,12 @@ struct FlpInterface {
     void (*addClient)(LocationAPI* client, const LocationCallbacks& callbacks);
     void (*removeClient)(LocationAPI* client);
     void (*requestCapabilities)(LocationAPI* client);
-    uint32_t (*startTracking)(LocationAPI* client, LocationOptions& options);
-    void (*updateTrackingOptions)(LocationAPI* client, uint32_t id, LocationOptions& options);
+    uint32_t (*startTracking)(LocationAPI* client, TrackingOptions&);
+    void (*updateTrackingOptions)(LocationAPI* client, uint32_t id, TrackingOptions&);
     void (*stopTracking)(LocationAPI* client, uint32_t id);
-    uint32_t (*startBatching)(LocationAPI* client, LocationOptions&, BatchingOptions&);
+    uint32_t (*startBatching)(LocationAPI* client, BatchingOptions&);
     void (*stopBatching)(LocationAPI* client, uint32_t id);
-    void (*updateBatchingOptions)(LocationAPI* client, uint32_t id, LocationOptions&,
-            BatchingOptions&);
+    void (*updateBatchingOptions)(LocationAPI* client, uint32_t id, BatchingOptions&);
     void (*getBatchedLocations)(LocationAPI* client, uint32_t id, size_t count);
     void (*getPowerStateChanges)(void* powerStateCb);
 };