summaryrefslogtreecommitdiff
path: root/gps/gnss
diff options
context:
space:
mode:
authorIsaac Chen <isaacchen@isaacchen.cn>2018-07-13 10:12:35 +0800
committerIsaac Chen <isaacchen@isaacchen.cn>2018-07-13 00:03:17 +0000
commit6a15b2379f90ba4f9222fea0a5f8c12e8cecbae5 (patch)
tree6b1789235069c986567127aa57a51bbe4122e5ee /gps/gnss
parent71ad0c9e5399aba0ac3cd20f1df41c9757cd6ca5 (diff)
wayne: Import GPS
* QC Tag: LA.UM.6.2.r1-06100-sdm660.0 Change-Id: I26da3b90caa473ed5f88408627463ec7f7655f23 Signed-off-by: Isaac Chen <isaacchen@isaacchen.cn>
Diffstat (limited to 'gps/gnss')
-rw-r--r--gps/gnss/Agps.cpp912
-rw-r--r--gps/gnss/Agps.h383
-rw-r--r--gps/gnss/Android.mk47
-rw-r--r--gps/gnss/GnssAdapter.cpp3131
-rw-r--r--gps/gnss/GnssAdapter.h287
-rw-r--r--gps/gnss/Makefile.am99
-rw-r--r--gps/gnss/XtraSystemStatusObserver.cpp237
-rw-r--r--gps/gnss/XtraSystemStatusObserver.h71
-rw-r--r--gps/gnss/location_gnss.cpp258
9 files changed, 5425 insertions, 0 deletions
diff --git a/gps/gnss/Agps.cpp b/gps/gnss/Agps.cpp
new file mode 100644
index 0000000..72ce293
--- /dev/null
+++ b/gps/gnss/Agps.cpp
@@ -0,0 +1,912 @@
+/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#define LOG_TAG "LocSvc_Agps"
+
+#include <Agps.h>
+#include <platform_lib_includes.h>
+#include <ContextBase.h>
+#include <loc_timer.h>
+
+/* --------------------------------------------------------------------
+ * AGPS State Machine Methods
+ * -------------------------------------------------------------------*/
+void AgpsStateMachine::processAgpsEvent(AgpsEvent event){
+
+ LOC_LOGD("processAgpsEvent(): SM %p, Event %d, State %d",
+ this, event, mState);
+
+ switch (event) {
+
+ case AGPS_EVENT_SUBSCRIBE:
+ processAgpsEventSubscribe();
+ break;
+
+ case AGPS_EVENT_UNSUBSCRIBE:
+ processAgpsEventUnsubscribe();
+ break;
+
+ case AGPS_EVENT_GRANTED:
+ processAgpsEventGranted();
+ break;
+
+ case AGPS_EVENT_RELEASED:
+ processAgpsEventReleased();
+ break;
+
+ case AGPS_EVENT_DENIED:
+ processAgpsEventDenied();
+ break;
+
+ default:
+ LOC_LOGE("Invalid Loc Agps Event");
+ }
+}
+
+void AgpsStateMachine::processAgpsEventSubscribe(){
+
+ switch (mState) {
+
+ case AGPS_STATE_RELEASED:
+ /* Add subscriber to list
+ * No notifications until we get RSRC_GRANTED */
+ addSubscriber(mCurrentSubscriber);
+
+ /* Send data request
+ * The if condition below is added so that if the data call setup
+ * fails for DS State Machine, we want to retry in released state.
+ * for Agps State Machine, sendRsrcRequest() will always return
+ * success. */
+ if (requestOrReleaseDataConn(true) == 0) {
+ // If data request successful, move to pending state
+ transitionState(AGPS_STATE_PENDING);
+ }
+ break;
+
+ case AGPS_STATE_PENDING:
+ /* Already requested for data connection,
+ * do nothing until we get RSRC_GRANTED event;
+ * Just add this subscriber to the list, for notifications */
+ addSubscriber(mCurrentSubscriber);
+ break;
+
+ case AGPS_STATE_ACQUIRED:
+ /* We already have the data connection setup,
+ * Notify current subscriber with GRANTED event,
+ * And add it to the subscriber list for further notifications. */
+ notifyEventToSubscriber(AGPS_EVENT_GRANTED, mCurrentSubscriber, false);
+ addSubscriber(mCurrentSubscriber);
+ break;
+
+ case AGPS_STATE_RELEASING:
+ addSubscriber(mCurrentSubscriber);
+ break;
+
+ default:
+ LOC_LOGE("Invalid state: %d", mState);
+ }
+}
+
+void AgpsStateMachine::processAgpsEventUnsubscribe(){
+
+ switch (mState) {
+
+ case AGPS_STATE_RELEASED:
+ notifyEventToSubscriber(
+ AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, false);
+ break;
+
+ case AGPS_STATE_PENDING:
+ case AGPS_STATE_ACQUIRED:
+ /* If the subscriber wishes to wait for connection close,
+ * before being removed from list, move to inactive state
+ * and notify */
+ if (mCurrentSubscriber->mWaitForCloseComplete) {
+ mCurrentSubscriber->mIsInactive = true;
+ }
+ else {
+ /* Notify only current subscriber and then delete it from
+ * subscriberList */
+ notifyEventToSubscriber(
+ AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, true);
+ }
+
+ /* If no subscribers in list, release data connection */
+ if (mSubscriberList.empty()) {
+ transitionState(AGPS_STATE_RELEASED);
+ requestOrReleaseDataConn(false);
+ }
+ /* Some subscribers in list, but all inactive;
+ * Release data connection */
+ else if(!anyActiveSubscribers()) {
+ transitionState(AGPS_STATE_RELEASING);
+ requestOrReleaseDataConn(false);
+ }
+ break;
+
+ case AGPS_STATE_RELEASING:
+ /* If the subscriber wishes to wait for connection close,
+ * before being removed from list, move to inactive state
+ * and notify */
+ if (mCurrentSubscriber->mWaitForCloseComplete) {
+ mCurrentSubscriber->mIsInactive = true;
+ }
+ else {
+ /* Notify only current subscriber and then delete it from
+ * subscriberList */
+ notifyEventToSubscriber(
+ AGPS_EVENT_UNSUBSCRIBE, mCurrentSubscriber, true);
+ }
+
+ /* If no subscribers in list, just move the state.
+ * Request for releasing data connection should already have been
+ * sent */
+ if (mSubscriberList.empty()) {
+ transitionState(AGPS_STATE_RELEASED);
+ }
+ break;
+
+ default:
+ LOC_LOGE("Invalid state: %d", mState);
+ }
+}
+
+void AgpsStateMachine::processAgpsEventGranted(){
+
+ switch (mState) {
+
+ case AGPS_STATE_RELEASED:
+ case AGPS_STATE_ACQUIRED:
+ case AGPS_STATE_RELEASING:
+ LOC_LOGE("Unexpected event GRANTED in state %d", mState);
+ break;
+
+ case AGPS_STATE_PENDING:
+ // Move to acquired state
+ transitionState(AGPS_STATE_ACQUIRED);
+ notifyAllSubscribers(
+ AGPS_EVENT_GRANTED, false,
+ AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS);
+ break;
+
+ default:
+ LOC_LOGE("Invalid state: %d", mState);
+ }
+}
+
+void AgpsStateMachine::processAgpsEventReleased(){
+
+ switch (mState) {
+
+ case AGPS_STATE_RELEASED:
+ /* Subscriber list should be empty if we are in released state */
+ if (!mSubscriberList.empty()) {
+ LOC_LOGE("Unexpected event RELEASED in RELEASED state");
+ }
+ break;
+
+ case AGPS_STATE_ACQUIRED:
+ /* Force release received */
+ LOC_LOGW("Force RELEASED event in ACQUIRED state");
+ transitionState(AGPS_STATE_RELEASED);
+ notifyAllSubscribers(
+ AGPS_EVENT_RELEASED, true,
+ AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS);
+ break;
+
+ case AGPS_STATE_RELEASING:
+ /* Notify all inactive subscribers about the event */
+ notifyAllSubscribers(
+ AGPS_EVENT_RELEASED, true,
+ AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS);
+
+ /* If we have active subscribers now, they must be waiting for
+ * data conn setup */
+ if (anyActiveSubscribers()) {
+ transitionState(AGPS_STATE_PENDING);
+ requestOrReleaseDataConn(true);
+ }
+ /* No active subscribers, move to released state */
+ else {
+ transitionState(AGPS_STATE_RELEASED);
+ }
+ break;
+
+ case AGPS_STATE_PENDING:
+ /* NOOP */
+ break;
+
+ default:
+ LOC_LOGE("Invalid state: %d", mState);
+ }
+}
+
+void AgpsStateMachine::processAgpsEventDenied(){
+
+ switch (mState) {
+
+ case AGPS_STATE_RELEASED:
+ LOC_LOGE("Unexpected event DENIED in state %d", mState);
+ break;
+
+ case AGPS_STATE_ACQUIRED:
+ /* NOOP */
+ break;
+
+ case AGPS_STATE_RELEASING:
+ /* Notify all inactive subscribers about the event */
+ notifyAllSubscribers(
+ AGPS_EVENT_RELEASED, true,
+ AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS);
+
+ /* If we have active subscribers now, they must be waiting for
+ * data conn setup */
+ if (anyActiveSubscribers()) {
+ transitionState(AGPS_STATE_PENDING);
+ requestOrReleaseDataConn(true);
+ }
+ /* No active subscribers, move to released state */
+ else {
+ transitionState(AGPS_STATE_RELEASED);
+ }
+ break;
+
+ case AGPS_STATE_PENDING:
+ transitionState(AGPS_STATE_RELEASED);
+ notifyAllSubscribers(
+ AGPS_EVENT_DENIED, true,
+ AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS);
+ break;
+
+ default:
+ LOC_LOGE("Invalid state: %d", mState);
+ }
+}
+
+/* Request or Release data connection
+ * bool request :
+ * true = Request data connection
+ * false = Release data connection */
+int AgpsStateMachine::requestOrReleaseDataConn(bool request){
+
+ AGnssExtStatusIpV4 nifRequest;
+ memset(&nifRequest, 0, sizeof(nifRequest));
+
+ nifRequest.type = mAgpsType;
+
+ if (request) {
+ LOC_LOGD("AGPS Data Conn Request");
+ nifRequest.status = LOC_GPS_REQUEST_AGPS_DATA_CONN;
+ }
+ else{
+ LOC_LOGD("AGPS Data Conn Release");
+ nifRequest.status = LOC_GPS_RELEASE_AGPS_DATA_CONN;
+ }
+
+ mAgpsManager->mFrameworkStatusV4Cb(nifRequest);
+ return 0;
+}
+
+void AgpsStateMachine::notifyAllSubscribers(
+ AgpsEvent event, bool deleteSubscriberPostNotify,
+ AgpsNotificationType notificationType){
+
+ LOC_LOGD("notifyAllSubscribers(): "
+ "SM %p, Event %d Delete %d Notification Type %d",
+ this, event, deleteSubscriberPostNotify, notificationType);
+
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ while ( it != mSubscriberList.end() ) {
+
+ AgpsSubscriber* subscriber = *it;
+
+ if (notificationType == AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS ||
+ (notificationType == AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS &&
+ subscriber->mIsInactive) ||
+ (notificationType == AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS &&
+ !subscriber->mIsInactive)) {
+
+ /* Deleting via this call would require another traversal
+ * through subscriber list, inefficient; hence pass in false*/
+ notifyEventToSubscriber(event, subscriber, false);
+
+ if (deleteSubscriberPostNotify) {
+ it = mSubscriberList.erase(it);
+ delete subscriber;
+ } else {
+ it++;
+ }
+ } else {
+ it++;
+ }
+ }
+}
+
+void AgpsStateMachine::notifyEventToSubscriber(
+ AgpsEvent event, AgpsSubscriber* subscriberToNotify,
+ bool deleteSubscriberPostNotify) {
+
+ LOC_LOGD("notifyEventToSubscriber(): "
+ "SM %p, Event %d Subscriber %p Delete %d",
+ this, event, subscriberToNotify, deleteSubscriberPostNotify);
+
+ switch (event) {
+
+ case AGPS_EVENT_GRANTED:
+ mAgpsManager->mAtlOpenStatusCb(
+ subscriberToNotify->mConnHandle, 1, getAPN(),
+ getBearer(), mAgpsType);
+ break;
+
+ case AGPS_EVENT_DENIED:
+ mAgpsManager->mAtlOpenStatusCb(
+ subscriberToNotify->mConnHandle, 0, getAPN(),
+ getBearer(), mAgpsType);
+ break;
+
+ case AGPS_EVENT_UNSUBSCRIBE:
+ case AGPS_EVENT_RELEASED:
+ mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1);
+ break;
+
+ default:
+ LOC_LOGE("Invalid event %d", event);
+ }
+
+ /* Search this subscriber in list and delete */
+ if (deleteSubscriberPostNotify) {
+ deleteSubscriber(subscriberToNotify);
+ }
+}
+
+void AgpsStateMachine::transitionState(AgpsState newState){
+
+ LOC_LOGD("transitionState(): SM %p, old %d, new %d",
+ this, mState, newState);
+
+ mState = newState;
+
+ // notify state transitions to all subscribers ?
+}
+
+void AgpsStateMachine::addSubscriber(AgpsSubscriber* subscriberToAdd){
+
+ LOC_LOGD("addSubscriber(): SM %p, Subscriber %p",
+ this, subscriberToAdd);
+
+ // Check if subscriber is already present in the current list
+ // If not, then add
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ for (; it != mSubscriberList.end(); it++) {
+ AgpsSubscriber* subscriber = *it;
+ if (subscriber->equals(subscriberToAdd)) {
+ LOC_LOGE("Subscriber already in list");
+ return;
+ }
+ }
+
+ AgpsSubscriber* cloned = subscriberToAdd->clone();
+ LOC_LOGD("addSubscriber(): cloned subscriber: %p", cloned);
+ mSubscriberList.push_back(cloned);
+}
+
+void AgpsStateMachine::deleteSubscriber(AgpsSubscriber* subscriberToDelete){
+
+ LOC_LOGD("deleteSubscriber(): SM %p, Subscriber %p",
+ this, subscriberToDelete);
+
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ while ( it != mSubscriberList.end() ) {
+
+ AgpsSubscriber* subscriber = *it;
+ if (subscriber && subscriber->equals(subscriberToDelete)) {
+
+ it = mSubscriberList.erase(it);
+ delete subscriber;
+ } else {
+ it++;
+ }
+ }
+}
+
+bool AgpsStateMachine::anyActiveSubscribers(){
+
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ for (; it != mSubscriberList.end(); it++) {
+ AgpsSubscriber* subscriber = *it;
+ if (!subscriber->mIsInactive) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void AgpsStateMachine::setAPN(char* apn, unsigned int len){
+
+ if (NULL != mAPN) {
+ delete mAPN;
+ }
+
+ if (apn == NULL || len <= 0) {
+ LOC_LOGD("Invalid apn len (%d) or null apn", len);
+ mAPN = NULL;
+ mAPNLen = 0;
+ }
+
+ if (NULL != apn) {
+ mAPN = new char[len+1];
+ if (NULL != mAPN) {
+ memcpy(mAPN, apn, len);
+ mAPN[len] = '\0';
+ mAPNLen = len;
+ }
+ }
+}
+
+AgpsSubscriber* AgpsStateMachine::getSubscriber(int connHandle){
+
+ /* Go over the subscriber list */
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ for (; it != mSubscriberList.end(); it++) {
+ AgpsSubscriber* subscriber = *it;
+ if (subscriber->mConnHandle == connHandle) {
+ return subscriber;
+ }
+ }
+
+ /* Not found, return NULL */
+ return NULL;
+}
+
+AgpsSubscriber* AgpsStateMachine::getFirstSubscriber(bool isInactive){
+
+ /* Go over the subscriber list */
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ for (; it != mSubscriberList.end(); it++) {
+ AgpsSubscriber* subscriber = *it;
+ if(subscriber->mIsInactive == isInactive) {
+ return subscriber;
+ }
+ }
+
+ /* Not found, return NULL */
+ return NULL;
+}
+
+void AgpsStateMachine::dropAllSubscribers(){
+
+ LOC_LOGD("dropAllSubscribers(): SM %p", this);
+
+ /* Go over the subscriber list */
+ std::list<AgpsSubscriber*>::const_iterator it = mSubscriberList.begin();
+ while ( it != mSubscriberList.end() ) {
+ AgpsSubscriber* subscriber = *it;
+ it = mSubscriberList.erase(it);
+ delete subscriber;
+ }
+}
+
+/* --------------------------------------------------------------------
+ * DS State Machine Methods
+ * -------------------------------------------------------------------*/
+const int DSStateMachine::MAX_START_DATA_CALL_RETRIES = 4;
+const int DSStateMachine::DATA_CALL_RETRY_DELAY_MSEC = 500;
+
+/* Overridden method
+ * DS SM needs to handle one scenario differently */
+void DSStateMachine::processAgpsEvent(AgpsEvent event) {
+
+ LOC_LOGD("DSStateMachine::processAgpsEvent() %d", event);
+
+ /* DS Client call setup APIs don't return failure/closure separately.
+ * Hence we receive RELEASED event in both cases.
+ * If we are in pending, we should consider RELEASED as DENIED */
+ if (event == AGPS_EVENT_RELEASED && mState == AGPS_STATE_PENDING) {
+
+ LOC_LOGD("Translating RELEASED to DENIED event");
+ event = AGPS_EVENT_DENIED;
+ }
+
+ /* Redirect process to base class */
+ AgpsStateMachine::processAgpsEvent(event);
+}
+
+/* Timer Callback
+ * For the retry timer started in case of DS Client call setup failure */
+void delay_callback(void *callbackData, int result)
+{
+ LOC_LOGD("delay_callback(): cbData %p", callbackData);
+
+ (void)result;
+
+ if (callbackData == NULL) {
+ LOC_LOGE("delay_callback(): NULL argument received !");
+ return;
+ }
+ DSStateMachine* dsStateMachine = (DSStateMachine *)callbackData;
+ dsStateMachine->retryCallback();
+}
+
+/* Invoked from Timer Callback
+ * For the retry timer started in case of DS Client call setup failure */
+void DSStateMachine :: retryCallback()
+{
+ LOC_LOGD("DSStateMachine::retryCallback()");
+
+ /* Request SUPL ES
+ * There must be at least one active subscriber in list */
+ AgpsSubscriber* subscriber = getFirstSubscriber(false);
+ if (subscriber == NULL) {
+
+ LOC_LOGE("No active subscriber for DS Client call setup");
+ return;
+ }
+
+ /* Send message to retry */
+ mAgpsManager->mSendMsgToAdapterQueueFn(
+ new AgpsMsgRequestATL(
+ mAgpsManager, subscriber->mConnHandle,
+ LOC_AGPS_TYPE_SUPL_ES));
+}
+
+/* Overridden method
+ * Request or Release data connection
+ * bool request :
+ * true = Request data connection
+ * false = Release data connection */
+int DSStateMachine::requestOrReleaseDataConn(bool request){
+
+ LOC_LOGD("DSStateMachine::requestOrReleaseDataConn(): "
+ "request %d", request);
+
+ /* Release data connection required ? */
+ if (!request && mAgpsManager->mDSClientStopDataCallFn) {
+
+ mAgpsManager->mDSClientStopDataCallFn();
+ LOC_LOGD("DS Client release data call request sent !");
+ return 0;
+ }
+
+ /* Setup data connection request
+ * There must be at least one active subscriber in list */
+ AgpsSubscriber* subscriber = getFirstSubscriber(false);
+ if (subscriber == NULL) {
+
+ LOC_LOGE("No active subscriber for DS Client call setup");
+ return -1;
+ }
+
+ /* DS Client Fn registered ? */
+ if (!mAgpsManager->mDSClientOpenAndStartDataCallFn) {
+
+ LOC_LOGE("DS Client start fn not registered, fallback to SUPL ATL");
+ notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false);
+ return -1;
+ }
+
+ /* Setup the call */
+ int ret = mAgpsManager->mDSClientOpenAndStartDataCallFn();
+
+ /* Check if data call start failed */
+ switch (ret) {
+
+ case LOC_API_ADAPTER_ERR_ENGINE_BUSY:
+ LOC_LOGE("DS Client open call failed, err: %d", ret);
+ mRetries++;
+ if (mRetries > MAX_START_DATA_CALL_RETRIES) {
+
+ LOC_LOGE("DS Client call retries exhausted, "
+ "falling back to normal SUPL ATL");
+ notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false);
+ }
+ /* Retry DS Client call setup after some delay */
+ else if(loc_timer_start(
+ DATA_CALL_RETRY_DELAY_MSEC, delay_callback, this)) {
+ LOC_LOGE("Error: Could not start delay thread\n");
+ return -1;
+ }
+ break;
+
+ case LOC_API_ADAPTER_ERR_UNSUPPORTED:
+ LOC_LOGE("No emergency profile found. Fall back to normal SUPL ATL");
+ notifyEventToSubscriber(AGPS_EVENT_DENIED, subscriber, false);
+ break;
+
+ case LOC_API_ADAPTER_ERR_SUCCESS:
+ LOC_LOGD("Request to start data call sent");
+ break;
+
+ default:
+ LOC_LOGE("Unrecognized return value: %d", ret);
+ }
+
+ return ret;
+}
+
+void DSStateMachine::notifyEventToSubscriber(
+ AgpsEvent event, AgpsSubscriber* subscriberToNotify,
+ bool deleteSubscriberPostNotify) {
+
+ LOC_LOGD("DSStateMachine::notifyEventToSubscriber(): "
+ "SM %p, Event %d Subscriber %p Delete %d",
+ this, event, subscriberToNotify, deleteSubscriberPostNotify);
+
+ switch (event) {
+
+ case AGPS_EVENT_GRANTED:
+ mAgpsManager->mAtlOpenStatusCb(
+ subscriberToNotify->mConnHandle, 1, NULL,
+ AGPS_APN_BEARER_INVALID, LOC_AGPS_TYPE_SUPL_ES);
+ break;
+
+ case AGPS_EVENT_DENIED:
+ /* Now try with regular SUPL
+ * We need to send request via message queue */
+ mRetries = 0;
+ mAgpsManager->mSendMsgToAdapterQueueFn(
+ new AgpsMsgRequestATL(
+ mAgpsManager, subscriberToNotify->mConnHandle,
+ LOC_AGPS_TYPE_SUPL));
+ break;
+
+ case AGPS_EVENT_UNSUBSCRIBE:
+ mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1);
+ break;
+
+ case AGPS_EVENT_RELEASED:
+ mAgpsManager->mDSClientCloseDataCallFn();
+ mAgpsManager->mAtlCloseStatusCb(subscriberToNotify->mConnHandle, 1);
+ break;
+
+ default:
+ LOC_LOGE("Invalid event %d", event);
+ }
+
+ /* Search this subscriber in list and delete */
+ if (deleteSubscriberPostNotify) {
+ deleteSubscriber(subscriberToNotify);
+ }
+}
+
+/* --------------------------------------------------------------------
+ * Loc AGPS Manager Methods
+ * -------------------------------------------------------------------*/
+
+/* CREATE AGPS STATE MACHINES
+ * Must be invoked in Msg Handler context */
+void AgpsManager::createAgpsStateMachines() {
+
+ LOC_LOGD("AgpsManager::createAgpsStateMachines");
+
+ bool agpsCapable =
+ ((loc_core::ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSA) ||
+ (loc_core::ContextBase::mGps_conf.CAPABILITIES & LOC_GPS_CAPABILITY_MSB));
+
+ if (NULL == mInternetNif) {
+ mInternetNif = new AgpsStateMachine(this, LOC_AGPS_TYPE_WWAN_ANY);
+ LOC_LOGD("Internet NIF: %p", mInternetNif);
+ }
+ if (agpsCapable) {
+ if (NULL == mAgnssNif) {
+ mAgnssNif = new AgpsStateMachine(this, LOC_AGPS_TYPE_SUPL);
+ LOC_LOGD("AGNSS NIF: %p", mAgnssNif);
+ }
+ if (NULL == mDsNif &&
+ loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
+
+ if(!mDSClientInitFn){
+
+ LOC_LOGE("DS Client Init Fn not registered !");
+ return;
+ }
+ if (mDSClientInitFn(false) != 0) {
+
+ LOC_LOGE("Failed to init data service client");
+ return;
+ }
+ mDsNif = new DSStateMachine(this);
+ LOC_LOGD("DS NIF: %p", mDsNif);
+ }
+ }
+}
+
+AgpsStateMachine* AgpsManager::getAgpsStateMachine(AGpsExtType agpsType) {
+
+ LOC_LOGD("AgpsManager::getAgpsStateMachine(): agpsType %d", agpsType);
+
+ switch (agpsType) {
+
+ case LOC_AGPS_TYPE_INVALID:
+ case LOC_AGPS_TYPE_SUPL:
+ if (mAgnssNif == NULL) {
+ LOC_LOGE("NULL AGNSS NIF !");
+ }
+ return mAgnssNif;
+
+ case LOC_AGPS_TYPE_SUPL_ES:
+ if (loc_core::ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
+ if (mDsNif == NULL) {
+ createAgpsStateMachines();
+ }
+ return mDsNif;
+ } else {
+ return mAgnssNif;
+ }
+
+ default:
+ return mInternetNif;
+ }
+
+ LOC_LOGE("No SM found !");
+ return NULL;
+}
+
+void AgpsManager::requestATL(int connHandle, AGpsExtType agpsType){
+
+ LOC_LOGD("AgpsManager::requestATL(): connHandle %d, agpsType %d",
+ connHandle, agpsType);
+
+ AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
+
+ if (sm == NULL) {
+
+ LOC_LOGE("No AGPS State Machine for agpsType: %d", agpsType);
+ mAtlOpenStatusCb(
+ connHandle, 0, NULL, AGPS_APN_BEARER_INVALID, agpsType);
+ return;
+ }
+
+ /* Invoke AGPS SM processing */
+ AgpsSubscriber subscriber(connHandle, false, false);
+ sm->setCurrentSubscriber(&subscriber);
+
+ /* If DS State Machine, wait for close complete */
+ if (agpsType == LOC_AGPS_TYPE_SUPL_ES) {
+ subscriber.mWaitForCloseComplete = true;
+ }
+
+ /* Send subscriber event */
+ sm->processAgpsEvent(AGPS_EVENT_SUBSCRIBE);
+}
+
+void AgpsManager::releaseATL(int connHandle){
+
+ LOC_LOGD("AgpsManager::releaseATL(): connHandle %d", connHandle);
+
+ /* First find the subscriber with specified handle.
+ * We need to search in all state machines. */
+ AgpsStateMachine* sm = NULL;
+ AgpsSubscriber* subscriber = NULL;
+
+ if (mAgnssNif &&
+ (subscriber = mAgnssNif->getSubscriber(connHandle)) != NULL) {
+ sm = mAgnssNif;
+ }
+ else if (mInternetNif &&
+ (subscriber = mInternetNif->getSubscriber(connHandle)) != NULL) {
+ sm = mInternetNif;
+ }
+ else if (mDsNif &&
+ (subscriber = mDsNif->getSubscriber(connHandle)) != NULL) {
+ sm = mDsNif;
+ }
+
+ if (sm == NULL) {
+ LOC_LOGE("Subscriber with connHandle %d not found in any SM",
+ connHandle);
+ mAtlCloseStatusCb(connHandle, 0);
+ return;
+ }
+
+ /* Now send unsubscribe event */
+ sm->setCurrentSubscriber(subscriber);
+ sm->processAgpsEvent(AGPS_EVENT_UNSUBSCRIBE);
+}
+
+void AgpsManager::reportDataCallOpened(){
+
+ LOC_LOGD("AgpsManager::reportDataCallOpened");
+
+ if (mDsNif) {
+ mDsNif->processAgpsEvent(AGPS_EVENT_GRANTED);
+ }
+}
+
+void AgpsManager::reportDataCallClosed(){
+
+ LOC_LOGD("AgpsManager::reportDataCallClosed");
+
+ if (mDsNif) {
+ mDsNif->processAgpsEvent(AGPS_EVENT_RELEASED);
+ }
+}
+
+void AgpsManager::reportAtlOpenSuccess(
+ AGpsExtType agpsType, char* apnName, int apnLen,
+ AGpsBearerType bearerType){
+
+ LOC_LOGD("AgpsManager::reportAtlOpenSuccess(): "
+ "AgpsType %d, APN [%s], Len %d, BearerType %d",
+ agpsType, apnName, apnLen, bearerType);
+
+ /* Find the state machine instance */
+ AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
+
+ /* Set bearer and apn info in state machine instance */
+ sm->setBearer(bearerType);
+ sm->setAPN(apnName, apnLen);
+
+ /* Send GRANTED event to state machine */
+ sm->processAgpsEvent(AGPS_EVENT_GRANTED);
+}
+
+void AgpsManager::reportAtlOpenFailed(AGpsExtType agpsType){
+
+ LOC_LOGD("AgpsManager::reportAtlOpenFailed(): AgpsType %d", agpsType);
+
+ /* Fetch SM and send DENIED event */
+ AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
+ sm->processAgpsEvent(AGPS_EVENT_DENIED);
+}
+
+void AgpsManager::reportAtlClosed(AGpsExtType agpsType){
+
+ LOC_LOGD("AgpsManager::reportAtlClosed(): AgpsType %d", agpsType);
+
+ /* Fetch SM and send RELEASED event */
+ AgpsStateMachine* sm = getAgpsStateMachine(agpsType);
+ sm->processAgpsEvent(AGPS_EVENT_RELEASED);
+}
+
+void AgpsManager::handleModemSSR(){
+
+ LOC_LOGD("AgpsManager::handleModemSSR");
+
+ /* Drop subscribers from all state machines */
+ if (mAgnssNif) {
+ mAgnssNif->dropAllSubscribers();
+ }
+ if (mInternetNif) {
+ mInternetNif->dropAllSubscribers();
+ }
+ if (mDsNif) {
+ mDsNif->dropAllSubscribers();
+ }
+
+ // reinitialize DS client in SSR mode
+ if (loc_core::ContextBase::mGps_conf.
+ USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
+
+ mDSClientStopDataCallFn();
+ mDSClientCloseDataCallFn();
+ mDSClientReleaseFn();
+
+ mDSClientInitFn(true);
+ }
+}
diff --git a/gps/gnss/Agps.h b/gps/gnss/Agps.h
new file mode 100644
index 0000000..2f89c8c
--- /dev/null
+++ b/gps/gnss/Agps.h
@@ -0,0 +1,383 @@
+/* Copyright (c) 2012-2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef AGPS_H
+#define AGPS_H
+
+#include <functional>
+#include <list>
+#include <MsgTask.h>
+#include <gps_extended_c.h>
+#include <platform_lib_log_util.h>
+
+/* ATL callback function pointers
+ * Passed in by Adapter to AgpsManager */
+typedef std::function<void(
+ int handle, int isSuccess, char* apn,
+ AGpsBearerType bearerType, AGpsExtType agpsType)> AgpsAtlOpenStatusCb;
+
+typedef std::function<void(int handle, int isSuccess)> AgpsAtlCloseStatusCb;
+
+/* DS Client control APIs
+ * Passed in by Adapter to AgpsManager */
+typedef std::function<int(bool isDueToSSR)> AgpsDSClientInitFn;
+typedef std::function<int()> AgpsDSClientOpenAndStartDataCallFn;
+typedef std::function<void()> AgpsDSClientStopDataCallFn;
+typedef std::function<void()> AgpsDSClientCloseDataCallFn;
+typedef std::function<void()> AgpsDSClientReleaseFn;
+
+/* Post message to adapter's message queue */
+typedef std::function<void(LocMsg* msg)> SendMsgToAdapterMsgQueueFn;
+
+/* AGPS States */
+typedef enum {
+ AGPS_STATE_INVALID = 0,
+ AGPS_STATE_RELEASED,
+ AGPS_STATE_PENDING,
+ AGPS_STATE_ACQUIRED,
+ AGPS_STATE_RELEASING
+} AgpsState;
+
+typedef enum {
+ AGPS_EVENT_INVALID = 0,
+ AGPS_EVENT_SUBSCRIBE,
+ AGPS_EVENT_UNSUBSCRIBE,
+ AGPS_EVENT_GRANTED,
+ AGPS_EVENT_RELEASED,
+ AGPS_EVENT_DENIED
+} AgpsEvent;
+
+/* Notification Types sent to subscribers */
+typedef enum {
+ AGPS_NOTIFICATION_TYPE_INVALID = 0,
+
+ /* Meant for all subscribers, either active or inactive */
+ AGPS_NOTIFICATION_TYPE_FOR_ALL_SUBSCRIBERS,
+
+ /* Meant for only inactive subscribers */
+ AGPS_NOTIFICATION_TYPE_FOR_INACTIVE_SUBSCRIBERS,
+
+ /* Meant for only active subscribers */
+ AGPS_NOTIFICATION_TYPE_FOR_ACTIVE_SUBSCRIBERS
+} AgpsNotificationType;
+
+/* Classes in this header */
+class AgpsSubscriber;
+class AgpsManager;
+class AgpsStateMachine;
+class DSStateMachine;
+
+
+/* SUBSCRIBER
+ * Each Subscriber instance corresponds to one AGPS request,
+ * received by the AGPS state machine */
+class AgpsSubscriber {
+
+public:
+ int mConnHandle;
+
+ /* Does this subscriber wait for data call close complete,
+ * before being notified ATL close ?
+ * While waiting for data call close, subscriber will be in
+ * inactive state. */
+ bool mWaitForCloseComplete;
+ bool mIsInactive;
+
+ inline AgpsSubscriber(
+ int connHandle, bool waitForCloseComplete, bool isInactive) :
+ mConnHandle(connHandle),
+ mWaitForCloseComplete(waitForCloseComplete),
+ mIsInactive(isInactive) {}
+ inline virtual ~AgpsSubscriber() {}
+
+ inline virtual bool equals(const AgpsSubscriber *s) const
+ { return (mConnHandle == s->mConnHandle); }
+
+ inline virtual AgpsSubscriber* clone()
+ { return new AgpsSubscriber(
+ mConnHandle, mWaitForCloseComplete, mIsInactive); }
+};
+
+/* AGPS STATE MACHINE */
+class AgpsStateMachine {
+protected:
+ /* AGPS Manager instance, from where this state machine is created */
+ AgpsManager* mAgpsManager;
+
+ /* List of all subscribers for this State Machine.
+ * Once a subscriber is notified for ATL open/close status,
+ * it is deleted */
+ std::list<AgpsSubscriber*> mSubscriberList;
+
+ /* Current subscriber, whose request this State Machine is
+ * currently processing */
+ AgpsSubscriber* mCurrentSubscriber;
+
+ /* Current state for this state machine */
+ AgpsState mState;
+
+private:
+ /* AGPS Type for this state machine
+ LOC_AGPS_TYPE_ANY 0
+ LOC_AGPS_TYPE_SUPL 1
+ LOC_AGPS_TYPE_WWAN_ANY 3
+ LOC_AGPS_TYPE_SUPL_ES 5 */
+ AGpsExtType mAgpsType;
+
+ /* APN and IP Type info for AGPS Call */
+ char* mAPN;
+ unsigned int mAPNLen;
+ AGpsBearerType mBearer;
+
+public:
+ /* CONSTRUCTOR */
+ AgpsStateMachine(AgpsManager* agpsManager, AGpsExtType agpsType):
+ mAgpsManager(agpsManager), mSubscriberList(),
+ mCurrentSubscriber(NULL), mState(AGPS_STATE_RELEASED),
+ mAgpsType(agpsType), mAPN(NULL), mAPNLen(0),
+ mBearer(AGPS_APN_BEARER_INVALID) {};
+
+ virtual ~AgpsStateMachine() { if(NULL != mAPN) delete[] mAPN; };
+
+ /* Getter/Setter methods */
+ void setAPN(char* apn, unsigned int len);
+ inline char* getAPN() const { return (char*)mAPN; }
+ inline void setBearer(AGpsBearerType bearer) { mBearer = bearer; }
+ inline AGpsBearerType getBearer() const { return mBearer; }
+ inline AGpsExtType getType() const { return mAgpsType; }
+ inline void setCurrentSubscriber(AgpsSubscriber* subscriber)
+ { mCurrentSubscriber = subscriber; }
+
+ /* Fetch subscriber with specified handle */
+ AgpsSubscriber* getSubscriber(int connHandle);
+
+ /* Fetch first active or inactive subscriber in list
+ * isInactive = true : fetch first inactive subscriber
+ * isInactive = false : fetch first active subscriber */
+ AgpsSubscriber* getFirstSubscriber(bool isInactive);
+
+ /* Process LOC AGPS Event being passed in
+ * onRsrcEvent */
+ virtual void processAgpsEvent(AgpsEvent event);
+
+ /* Drop all subscribers, in case of Modem SSR */
+ void dropAllSubscribers();
+
+protected:
+ /* Remove the specified subscriber from list if present.
+ * Also delete the subscriber instance. */
+ void deleteSubscriber(AgpsSubscriber* subscriber);
+
+private:
+ /* Send call setup request to framework
+ * sendRsrcRequest(LOC_GPS_REQUEST_AGPS_DATA_CONN)
+ * sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN) */
+ virtual int requestOrReleaseDataConn(bool request);
+
+ /* Individual event processing methods */
+ void processAgpsEventSubscribe();
+ void processAgpsEventUnsubscribe();
+ void processAgpsEventGranted();
+ void processAgpsEventReleased();
+ void processAgpsEventDenied();
+
+ /* Clone the passed in subscriber and add to the subscriber list
+ * if not already present */
+ void addSubscriber(AgpsSubscriber* subscriber);
+
+ /* Notify subscribers about AGPS events */
+ void notifyAllSubscribers(
+ AgpsEvent event, bool deleteSubscriberPostNotify,
+ AgpsNotificationType notificationType);
+ virtual void notifyEventToSubscriber(
+ AgpsEvent event, AgpsSubscriber* subscriber,
+ bool deleteSubscriberPostNotify);
+
+ /* Do we have any subscribers in active state */
+ bool anyActiveSubscribers();
+
+ /* Transition state */
+ void transitionState(AgpsState newState);
+};
+
+/* DS STATE MACHINE */
+class DSStateMachine : public AgpsStateMachine {
+
+private:
+ static const int MAX_START_DATA_CALL_RETRIES;
+ static const int DATA_CALL_RETRY_DELAY_MSEC;
+
+ int mRetries;
+
+public:
+ /* CONSTRUCTOR */
+ DSStateMachine(AgpsManager* agpsManager):
+ AgpsStateMachine(agpsManager, LOC_AGPS_TYPE_SUPL_ES), mRetries(0) {}
+
+ /* Overridden method
+ * DS SM needs to handle one event differently */
+ void processAgpsEvent(AgpsEvent event);
+
+ /* Retry callback, used in case call failure */
+ void retryCallback();
+
+private:
+ /* Overridden method, different functionality for DS SM
+ * Send call setup request to framework
+ * sendRsrcRequest(LOC_GPS_REQUEST_AGPS_DATA_CONN)
+ * sendRsrcRequest(LOC_GPS_RELEASE_AGPS_DATA_CONN) */
+ int requestOrReleaseDataConn(bool request);
+
+ /* Overridden method, different functionality for DS SM */
+ void notifyEventToSubscriber(
+ AgpsEvent event, AgpsSubscriber* subscriber,
+ bool deleteSubscriberPostNotify);
+};
+
+/* LOC AGPS MANAGER */
+class AgpsManager {
+
+ friend class AgpsStateMachine;
+ friend class DSStateMachine;
+
+public:
+ /* CONSTRUCTOR */
+ AgpsManager():
+ mFrameworkStatusV4Cb(NULL),
+ mAtlOpenStatusCb(), mAtlCloseStatusCb(),
+ mDSClientInitFn(), mDSClientOpenAndStartDataCallFn(),
+ mDSClientStopDataCallFn(), mDSClientCloseDataCallFn(), mDSClientReleaseFn(),
+ mSendMsgToAdapterQueueFn(),
+ mAgnssNif(NULL), mInternetNif(NULL), mDsNif(NULL) {}
+
+ /* Register callbacks */
+ void registerCallbacks(
+ AgnssStatusIpV4Cb frameworkStatusV4Cb,
+
+ AgpsAtlOpenStatusCb atlOpenStatusCb,
+ AgpsAtlCloseStatusCb atlCloseStatusCb,
+
+ AgpsDSClientInitFn dsClientInitFn,
+ AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn,
+ AgpsDSClientStopDataCallFn dsClientStopDataCallFn,
+ AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn,
+ AgpsDSClientReleaseFn dsClientReleaseFn,
+
+ SendMsgToAdapterMsgQueueFn sendMsgToAdapterQueueFn ){
+
+ mFrameworkStatusV4Cb = frameworkStatusV4Cb;
+
+ mAtlOpenStatusCb = atlOpenStatusCb;
+ mAtlCloseStatusCb = atlCloseStatusCb;
+
+ mDSClientInitFn = dsClientInitFn;
+ mDSClientOpenAndStartDataCallFn = dsClientOpenAndStartDataCallFn;
+ mDSClientStopDataCallFn = dsClientStopDataCallFn;
+ mDSClientCloseDataCallFn = dsClientCloseDataCallFn;
+ mDSClientReleaseFn = dsClientReleaseFn;
+
+ mSendMsgToAdapterQueueFn = sendMsgToAdapterQueueFn;
+ }
+
+ /* Create all AGPS state machines */
+ void createAgpsStateMachines();
+
+ /* Process incoming ATL requests */
+ void requestATL(int connHandle, AGpsExtType agpsType);
+ void releaseATL(int connHandle);
+
+ /* Process incoming DS Client data call events */
+ void reportDataCallOpened();
+ void reportDataCallClosed();
+
+ /* Process incoming framework data call events */
+ void reportAtlOpenSuccess(AGpsExtType agpsType, char* apnName, int apnLen,
+ AGpsBearerType bearerType);
+ void reportAtlOpenFailed(AGpsExtType agpsType);
+ void reportAtlClosed(AGpsExtType agpsType);
+
+ /* Handle Modem SSR */
+ void handleModemSSR();
+
+protected:
+ AgnssStatusIpV4Cb mFrameworkStatusV4Cb;
+
+ AgpsAtlOpenStatusCb mAtlOpenStatusCb;
+ AgpsAtlCloseStatusCb mAtlCloseStatusCb;
+
+ AgpsDSClientInitFn mDSClientInitFn;
+ AgpsDSClientOpenAndStartDataCallFn mDSClientOpenAndStartDataCallFn;
+ AgpsDSClientStopDataCallFn mDSClientStopDataCallFn;
+ AgpsDSClientCloseDataCallFn mDSClientCloseDataCallFn;
+ AgpsDSClientReleaseFn mDSClientReleaseFn;
+
+ SendMsgToAdapterMsgQueueFn mSendMsgToAdapterQueueFn;
+
+ AgpsStateMachine* mAgnssNif;
+ AgpsStateMachine* mInternetNif;
+ AgpsStateMachine* mDsNif;
+
+private:
+ /* Fetch state machine for handling request ATL call */
+ AgpsStateMachine* getAgpsStateMachine(AGpsExtType agpsType);
+};
+
+/* Request SUPL/INTERNET/SUPL_ES ATL
+ * This LocMsg is defined in this header since it has to be used from more
+ * than one place, other Agps LocMsg are restricted to GnssAdapter and
+ * declared inline */
+struct AgpsMsgRequestATL: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+ int mConnHandle;
+ AGpsExtType mAgpsType;
+
+ inline AgpsMsgRequestATL(AgpsManager* agpsManager, int connHandle,
+ AGpsExtType agpsType) :
+ LocMsg(), mAgpsManager(agpsManager), mConnHandle(connHandle), mAgpsType(
+ agpsType) {
+
+ LOC_LOGV("AgpsMsgRequestATL");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgRequestATL::proc()");
+ mAgpsManager->requestATL(mConnHandle, mAgpsType);
+ }
+};
+
+namespace AgpsUtils {
+
+AGpsBearerType ipTypeToBearerType(LocApnIpType ipType);
+LocApnIpType bearerTypeToIpType(AGpsBearerType bearerType);
+
+}
+
+#endif /* AGPS_H */
diff --git a/gps/gnss/Android.mk b/gps/gnss/Android.mk
new file mode 100644
index 0000000..4d738bd
--- /dev/null
+++ b/gps/gnss/Android.mk
@@ -0,0 +1,47 @@
+ifneq ($(BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE),)
+ifneq ($(BUILD_TINY_ANDROID),true)
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := libgnss
+LOCAL_MODULE_PATH_32 := $(TARGET_OUT_VENDOR)/lib
+LOCAL_MODULE_PATH_64 := $(TARGET_OUT_VENDOR)/lib64
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SHARED_LIBRARIES := \
+ libutils \
+ libcutils \
+ libdl \
+ liblog \
+ libloc_core \
+ libgps.utils
+
+LOCAL_SRC_FILES += \
+ location_gnss.cpp \
+ GnssAdapter.cpp \
+ Agps.cpp \
+ XtraSystemStatusObserver.cpp
+
+LOCAL_CFLAGS += \
+ -fno-short-enums \
+
+ifeq ($(TARGET_BUILD_VARIANT),user)
+ LOCAL_CFLAGS += -DTARGET_BUILD_VARIANT_USER
+endif
+
+LOCAL_HEADER_LIBRARIES := \
+ libgps.utils_headers \
+ libloc_core_headers \
+ libloc_pla_headers \
+ liblocation_api_headers
+
+LOCAL_CFLAGS += $(GNSS_CFLAGS)
+
+LOCAL_PRELINK_MODULE := false
+
+include $(BUILD_SHARED_LIBRARY)
+
+endif # not BUILD_TINY_ANDROID
+endif # BOARD_VENDOR_QCOM_GPS_LOC_API_HARDWARE
diff --git a/gps/gnss/GnssAdapter.cpp b/gps/gnss/GnssAdapter.cpp
new file mode 100644
index 0000000..cdda01d
--- /dev/null
+++ b/gps/gnss/GnssAdapter.cpp
@@ -0,0 +1,3131 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#define LOG_TAG "LocSvc_GnssAdapter"
+
+#include <inttypes.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <ctype.h>
+#include <cutils/properties.h>
+#include <math.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <GnssAdapter.h>
+#include <string>
+#include <loc_log.h>
+#include <loc_nmea.h>
+#include <Agps.h>
+#include <SystemStatus.h>
+
+#include <vector>
+
+#define RAD2DEG (180.0 / M_PI)
+
+using namespace loc_core;
+
+/* Method to fetch status cb from loc_net_iface library */
+typedef AgpsCbInfo& (*LocAgpsGetAgpsCbInfo)(LocAgpsOpenResultCb openResultCb,
+ LocAgpsCloseResultCb closeResultCb, void* userDataPtr);
+
+static void agpsOpenResultCb (bool isSuccess, AGpsExtType agpsType, const char* apn,
+ AGpsBearerType bearerType, void* userDataPtr);
+static void agpsCloseResultCb (bool isSuccess, AGpsExtType agpsType, void* userDataPtr);
+
+GnssAdapter::GnssAdapter() :
+ LocAdapterBase(0,
+ LocDualContext::getLocFgContext(NULL,
+ NULL,
+ LocDualContext::mLocationHalName,
+ false)),
+ mUlpProxy(new UlpProxyBase()),
+ mUlpPositionMode(),
+ mGnssSvIdUsedInPosition(),
+ mGnssSvIdUsedInPosAvail(false),
+ mControlCallbacks(),
+ mPowerVoteId(0),
+ mNmeaMask(0),
+ mNiData(),
+ mAgpsManager(),
+ mAgpsCbInfo(),
+ mSystemStatus(SystemStatus::getInstance(mMsgTask)),
+ mServerUrl(""),
+ mXtraObserver(mSystemStatus->getOsObserver(), mMsgTask)
+{
+ LOC_LOGD("%s]: Constructor %p", __func__, this);
+ mUlpPositionMode.mode = LOC_POSITION_MODE_INVALID;
+ readConfigCommand();
+ setConfigCommand();
+ initDefaultAgpsCommand();
+}
+
+void
+GnssAdapter::setControlCallbacksCommand(LocationControlCallbacks& controlCallbacks)
+{
+ struct MsgSetControlCallbacks : public LocMsg {
+ GnssAdapter& mAdapter;
+ const LocationControlCallbacks mControlCallbacks;
+ inline MsgSetControlCallbacks(GnssAdapter& adapter,
+ LocationControlCallbacks& controlCallbacks) :
+ LocMsg(),
+ mAdapter(adapter),
+ mControlCallbacks(controlCallbacks) {}
+ inline virtual void proc() const {
+ mAdapter.setControlCallbacks(mControlCallbacks);
+ }
+ };
+
+ sendMsg(new MsgSetControlCallbacks(*this, controlCallbacks));
+}
+
+void
+GnssAdapter::convertOptions(LocPosMode& out, const LocationOptions& options)
+{
+ LocPosMode locPosMode = {};
+ switch (options.mode) {
+ case GNSS_SUPL_MODE_MSB:
+ out.mode = LOC_POSITION_MODE_MS_BASED;
+ break;
+ case GNSS_SUPL_MODE_MSA:
+ out.mode = LOC_POSITION_MODE_MS_ASSISTED;
+ break;
+ default:
+ out.mode = LOC_POSITION_MODE_STANDALONE;
+ break;
+ }
+ out.share_position = true;
+ out.min_interval = options.minInterval;
+}
+
+void
+GnssAdapter::convertLocation(Location& out, const LocGpsLocation& locGpsLocation,
+ const GpsLocationExtended& locationExtended,
+ const LocPosTechMask techMask)
+{
+ memset(&out, 0, sizeof(Location));
+ out.size = sizeof(Location);
+ if (LOC_GPS_LOCATION_HAS_LAT_LONG & locGpsLocation.flags) {
+ out.flags |= LOCATION_HAS_LAT_LONG_BIT;
+ out.latitude = locGpsLocation.latitude;
+ out.longitude = locGpsLocation.longitude;
+ }
+ if (LOC_GPS_LOCATION_HAS_ALTITUDE & locGpsLocation.flags) {
+ out.flags |= LOCATION_HAS_ALTITUDE_BIT;
+ out.altitude = locGpsLocation.altitude;
+ }
+ if (LOC_GPS_LOCATION_HAS_SPEED & locGpsLocation.flags) {
+ out.flags |= LOCATION_HAS_SPEED_BIT;
+ out.speed = locGpsLocation.speed;
+ }
+ if (LOC_GPS_LOCATION_HAS_BEARING & locGpsLocation.flags) {
+ out.flags |= LOCATION_HAS_BEARING_BIT;
+ out.bearing = locGpsLocation.bearing;
+ }
+ if (LOC_GPS_LOCATION_HAS_ACCURACY & locGpsLocation.flags) {
+ out.flags |= LOCATION_HAS_ACCURACY_BIT;
+ out.accuracy = locGpsLocation.accuracy;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_VERT_UNC & locationExtended.flags) {
+ out.flags |= LOCATION_HAS_VERTICAL_ACCURACY_BIT;
+ out.verticalAccuracy = locationExtended.vert_unc;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_SPEED_UNC & locationExtended.flags) {
+ out.flags |= LOCATION_HAS_SPEED_ACCURACY_BIT;
+ out.speedAccuracy = locationExtended.speed_unc;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_BEARING_UNC & locationExtended.flags) {
+ out.flags |= LOCATION_HAS_BEARING_ACCURACY_BIT;
+ out.bearingAccuracy = locationExtended.bearing_unc;
+ }
+ out.timestamp = locGpsLocation.timestamp;
+ if (LOC_POS_TECH_MASK_SATELLITE & techMask) {
+ out.techMask |= LOCATION_TECHNOLOGY_GNSS_BIT;
+ }
+ if (LOC_POS_TECH_MASK_CELLID & techMask) {
+ out.techMask |= LOCATION_TECHNOLOGY_CELL_BIT;
+ }
+ if (LOC_POS_TECH_MASK_WIFI & techMask) {
+ out.techMask |= LOCATION_TECHNOLOGY_WIFI_BIT;
+ }
+ if (LOC_POS_TECH_MASK_SENSORS & techMask) {
+ out.techMask |= LOCATION_TECHNOLOGY_SENSORS_BIT;
+ }
+}
+
+void
+GnssAdapter::convertLocationInfo(GnssLocationInfoNotification& out,
+ const GpsLocationExtended& locationExtended)
+{
+ out.size = sizeof(GnssLocationInfoNotification);
+ if (GPS_LOCATION_EXTENDED_HAS_ALTITUDE_MEAN_SEA_LEVEL & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_ALTITUDE_MEAN_SEA_LEVEL_BIT;
+ out.altitudeMeanSeaLevel = locationExtended.altitudeMeanSeaLevel;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_DOP & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_DOP_BIT;
+ out.pdop = locationExtended.pdop;
+ out.hdop = locationExtended.hdop;
+ out.vdop = locationExtended.vdop;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_MAG_DEV & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_MAGNETIC_DEVIATION_BIT;
+ out.magneticDeviation = locationExtended.magneticDeviation;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_HOR_RELIABILITY & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_HOR_RELIABILITY_BIT;
+ switch (locationExtended.horizontal_reliability) {
+ case LOC_RELIABILITY_VERY_LOW:
+ out.horReliability = LOCATION_RELIABILITY_VERY_LOW;
+ break;
+ case LOC_RELIABILITY_LOW:
+ out.horReliability = LOCATION_RELIABILITY_LOW;
+ break;
+ case LOC_RELIABILITY_MEDIUM:
+ out.horReliability = LOCATION_RELIABILITY_MEDIUM;
+ break;
+ case LOC_RELIABILITY_HIGH:
+ out.horReliability = LOCATION_RELIABILITY_HIGH;
+ break;
+ default:
+ out.horReliability = LOCATION_RELIABILITY_NOT_SET;
+ break;
+ }
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_VERT_RELIABILITY & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_VER_RELIABILITY_BIT;
+ switch (locationExtended.vertical_reliability) {
+ case LOC_RELIABILITY_VERY_LOW:
+ out.verReliability = LOCATION_RELIABILITY_VERY_LOW;
+ break;
+ case LOC_RELIABILITY_LOW:
+ out.verReliability = LOCATION_RELIABILITY_LOW;
+ break;
+ case LOC_RELIABILITY_MEDIUM:
+ out.verReliability = LOCATION_RELIABILITY_MEDIUM;
+ break;
+ case LOC_RELIABILITY_HIGH:
+ out.verReliability = LOCATION_RELIABILITY_HIGH;
+ break;
+ default:
+ out.verReliability = LOCATION_RELIABILITY_NOT_SET;
+ break;
+ }
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MAJOR & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MAJOR_BIT;
+ out.horUncEllipseSemiMajor = locationExtended.horUncEllipseSemiMajor;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_MINOR & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_SEMI_MINOR_BIT;
+ out.horUncEllipseSemiMinor = locationExtended.horUncEllipseSemiMinor;
+ }
+ if (GPS_LOCATION_EXTENDED_HAS_HOR_ELIP_UNC_AZIMUTH & locationExtended.flags) {
+ out.flags |= GNSS_LOCATION_INFO_HOR_ACCURACY_ELIP_AZIMUTH_BIT;
+ out.horUncEllipseOrientAzimuth = locationExtended.horUncEllipseOrientAzimuth;
+ }
+}
+
+inline uint32_t
+GnssAdapter::convertGpsLock(const GnssConfigGpsLock gpsLock)
+{
+ switch (gpsLock) {
+ case GNSS_CONFIG_GPS_LOCK_MO:
+ return 1;
+ case GNSS_CONFIG_GPS_LOCK_NI:
+ return 2;
+ case GNSS_CONFIG_GPS_LOCK_MO_AND_NI:
+ return 3;
+ case GNSS_CONFIG_GPS_LOCK_NONE:
+ default:
+ return 0;
+ }
+}
+
+inline GnssConfigGpsLock
+GnssAdapter::convertGpsLock(const uint32_t gpsLock)
+{
+ switch (gpsLock) {
+ case 1:
+ return GNSS_CONFIG_GPS_LOCK_MO;
+ case 2:
+ return GNSS_CONFIG_GPS_LOCK_NI;
+ case 3:
+ return GNSS_CONFIG_GPS_LOCK_MO_AND_NI;
+ case 0:
+ default:
+ return GNSS_CONFIG_GPS_LOCK_NONE;
+ }
+}
+
+inline uint32_t
+GnssAdapter::convertSuplVersion(const GnssConfigSuplVersion suplVersion)
+{
+ switch (suplVersion) {
+ case GNSS_CONFIG_SUPL_VERSION_2_0_0:
+ return 0x00020000;
+ case GNSS_CONFIG_SUPL_VERSION_2_0_2:
+ return 0x00020002;
+ case GNSS_CONFIG_SUPL_VERSION_1_0_0:
+ default:
+ return 0x00010000;
+ }
+}
+
+inline GnssConfigSuplVersion
+GnssAdapter::convertSuplVersion(const uint32_t suplVersion)
+{
+ switch (suplVersion) {
+ case 0x00020000:
+ return GNSS_CONFIG_SUPL_VERSION_2_0_0;
+ case 0x00020002:
+ return GNSS_CONFIG_SUPL_VERSION_2_0_2;
+ case 0x00010000:
+ default:
+ return GNSS_CONFIG_SUPL_VERSION_1_0_0;
+ }
+}
+
+inline uint32_t
+GnssAdapter::convertLppProfile(const GnssConfigLppProfile lppProfile)
+{
+ switch (lppProfile) {
+ case GNSS_CONFIG_LPP_PROFILE_USER_PLANE:
+ return 1;
+ case GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE:
+ return 2;
+ case GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE:
+ return 3;
+ case GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE:
+ default:
+ return 0;
+ }
+}
+
+inline GnssConfigLppProfile
+GnssAdapter::convertLppProfile(const uint32_t lppProfile)
+{
+ switch (lppProfile) {
+ case 1:
+ return GNSS_CONFIG_LPP_PROFILE_USER_PLANE;
+ case 2:
+ return GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE;
+ case 3:
+ return GNSS_CONFIG_LPP_PROFILE_USER_PLANE_AND_CONTROL_PLANE;
+ case 0:
+ default:
+ return GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE;
+ }
+}
+
+uint32_t
+GnssAdapter::convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlaneMask)
+{
+ uint32_t mask = 0;
+ if (GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT & lppeControlPlaneMask) {
+ mask |= (1<<0);
+ }
+ if (GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT & lppeControlPlaneMask) {
+ mask |= (1<<1);
+ }
+ if (GNSS_CONFIG_LPPE_CONTROL_PLANE_SRN_AP_MEASUREMENTS_BIT & lppeControlPlaneMask) {
+ mask |= (1<<2);
+ }
+ if (GNSS_CONFIG_LPPE_CONTROL_PLANE_SENSOR_BARO_MEASUREMENTS_BIT & lppeControlPlaneMask) {
+ mask |= (1<<3);
+ }
+ return mask;
+}
+
+GnssConfigLppeControlPlaneMask
+GnssAdapter::convertLppeCp(const uint32_t lppeControlPlaneMask)
+{
+ GnssConfigLppeControlPlaneMask mask = 0;
+ if ((1<<0) & lppeControlPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_DBH_BIT;
+ }
+ if ((1<<1) & lppeControlPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_WLAN_AP_MEASUREMENTS_BIT;
+ }
+ if ((1<<2) & lppeControlPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_SRN_AP_MEASUREMENTS_BIT;
+ }
+ if ((1<<3) & lppeControlPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_CONTROL_PLANE_SENSOR_BARO_MEASUREMENTS_BIT;
+ }
+ return mask;
+}
+
+
+uint32_t
+GnssAdapter::convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask)
+{
+ uint32_t mask = 0;
+ if (GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT & lppeUserPlaneMask) {
+ mask |= (1<<0);
+ }
+ if (GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT & lppeUserPlaneMask) {
+ mask |= (1<<1);
+ }
+ if (GNSS_CONFIG_LPPE_USER_PLANE_SRN_AP_MEASUREMENTS_BIT & lppeUserPlaneMask) {
+ mask |= (1<<2);
+ }
+ if (GNSS_CONFIG_LPPE_USER_PLANE_SENSOR_BARO_MEASUREMENTS_BIT & lppeUserPlaneMask) {
+ mask |= (1<<3);
+ }
+ return mask;
+}
+
+GnssConfigLppeUserPlaneMask
+GnssAdapter::convertLppeUp(const uint32_t lppeUserPlaneMask)
+{
+ GnssConfigLppeUserPlaneMask mask = 0;
+ if ((1<<0) & lppeUserPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_USER_PLANE_DBH_BIT;
+ }
+ if ((1<<1) & lppeUserPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_USER_PLANE_WLAN_AP_MEASUREMENTS_BIT;
+ }
+ if ((1<<2) & lppeUserPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_USER_PLANE_SRN_AP_MEASUREMENTS_BIT;
+ }
+ if ((1<<3) & lppeUserPlaneMask) {
+ mask |= GNSS_CONFIG_LPPE_USER_PLANE_SENSOR_BARO_MEASUREMENTS_BIT;
+ }
+ return mask;
+}
+
+uint32_t
+GnssAdapter::convertAGloProt(const GnssConfigAGlonassPositionProtocolMask aGloPositionProtocolMask)
+{
+ uint32_t mask = 0;
+ if (GNSS_CONFIG_RRC_CONTROL_PLANE_BIT & aGloPositionProtocolMask) {
+ mask |= (1<<0);
+ }
+ if (GNSS_CONFIG_RRLP_USER_PLANE_BIT & aGloPositionProtocolMask) {
+ mask |= (1<<1);
+ }
+ if (GNSS_CONFIG_LLP_USER_PLANE_BIT & aGloPositionProtocolMask) {
+ mask |= (1<<2);
+ }
+ if (GNSS_CONFIG_LLP_CONTROL_PLANE_BIT & aGloPositionProtocolMask) {
+ mask |= (1<<3);
+ }
+ return mask;
+}
+
+uint32_t
+GnssAdapter::convertEP4ES(const GnssConfigEmergencyPdnForEmergencySupl emergencyPdnForEmergencySupl)
+{
+ switch (emergencyPdnForEmergencySupl) {
+ case GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES:
+ return 1;
+ case GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO:
+ default:
+ return 0;
+ }
+}
+
+uint32_t
+GnssAdapter::convertSuplEs(const GnssConfigSuplEmergencyServices suplEmergencyServices)
+{
+ switch (suplEmergencyServices) {
+ case GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_YES:
+ return 1;
+ case GNSS_CONFIG_SUPL_EMERGENCY_SERVICES_NO:
+ default:
+ return 0;
+ }
+}
+
+uint32_t
+GnssAdapter::convertSuplMode(const GnssConfigSuplModeMask suplModeMask)
+{
+ uint32_t mask = 0;
+ if (GNSS_CONFIG_SUPL_MODE_MSB_BIT & suplModeMask) {
+ mask |= (1<<0);
+ }
+ if (GNSS_CONFIG_SUPL_MODE_MSA_BIT & suplModeMask) {
+ mask |= (1<<1);
+ }
+ return mask;
+}
+
+bool
+GnssAdapter::resolveInAddress(const char* hostAddress, struct in_addr* inAddress)
+{
+ bool ret = true;
+
+ struct hostent* hp;
+ hp = gethostbyname(hostAddress);
+ if (hp != NULL) { /* DNS OK */
+ memcpy(inAddress, hp->h_addr_list[0], hp->h_length);
+ } else {
+ /* Try IP representation */
+ if (inet_aton(hostAddress, inAddress) == 0) {
+ /* IP not valid */
+ LOC_LOGE("%s]: DNS query on '%s' failed", __func__, hostAddress);
+ ret = false;
+ }
+ }
+
+ return ret;
+}
+
+void
+GnssAdapter::readConfigCommand()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgReadConfig : public LocMsg {
+ GnssAdapter* mAdapter;
+ ContextBase& mContext;
+ inline MsgReadConfig(GnssAdapter* adapter,
+ ContextBase& context) :
+ LocMsg(),
+ mAdapter(adapter),
+ mContext(context) {}
+ inline virtual void proc() const {
+ // reads config into mContext->mGps_conf
+ mContext.readConfig();
+ mContext.requestUlp((LocAdapterBase*)mAdapter, mContext.getCarrierCapabilities());
+ }
+ };
+
+ if (mContext != NULL) {
+ sendMsg(new MsgReadConfig(this, *mContext));
+ }
+}
+
+void
+GnssAdapter::setConfigCommand()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgSetConfig : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ inline MsgSetConfig(GnssAdapter& adapter,
+ LocApiBase& api) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api) {}
+ inline virtual void proc() const {
+ if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
+ mApi.setSUPLVersion(mAdapter.convertSuplVersion(ContextBase::mGps_conf.SUPL_VER));
+ mApi.setLPPConfig(mAdapter.convertLppProfile(ContextBase::mGps_conf.LPP_PROFILE));
+ mApi.setAGLONASSProtocol(ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT);
+ }
+ mApi.setSensorControlConfig(ContextBase::mSap_conf.SENSOR_USAGE,
+ ContextBase::mSap_conf.SENSOR_PROVIDER);
+ mApi.setLPPeProtocolCp(
+ mAdapter.convertLppeCp(ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY));
+ mApi.setLPPeProtocolUp(
+ mAdapter.convertLppeUp(ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY));
+
+ // set nmea mask type
+ uint32_t mask = 0;
+ if (NMEA_PROVIDER_MP == ContextBase::mGps_conf.NMEA_PROVIDER) {
+ mask |= LOC_NMEA_ALL_GENERAL_SUPPORTED_MASK;
+ }
+ if (mApi.isFeatureSupported(LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02)) {
+ mask |= LOC_NMEA_MASK_DEBUG_V02;
+ }
+ if (mask != 0) {
+ mApi.setNMEATypes(mask);
+ }
+ mAdapter.mNmeaMask= mask;
+
+ mApi.setXtraVersionCheck(ContextBase::mGps_conf.XTRA_VERSION_CHECK);
+ if (ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID ||
+ ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
+ ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
+ ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID ||
+ ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID ) {
+ mApi.setSensorProperties(
+ ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK_VALID,
+ ContextBase::mSap_conf.GYRO_BIAS_RANDOM_WALK,
+ ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+ ContextBase::mSap_conf.ACCEL_RANDOM_WALK_SPECTRAL_DENSITY,
+ ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+ ContextBase::mSap_conf.ANGLE_RANDOM_WALK_SPECTRAL_DENSITY,
+ ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+ ContextBase::mSap_conf.RATE_RANDOM_WALK_SPECTRAL_DENSITY,
+ ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY_VALID,
+ ContextBase::mSap_conf.VELOCITY_RANDOM_WALK_SPECTRAL_DENSITY);
+ }
+ mApi.setSensorPerfControlConfig(
+ ContextBase::mSap_conf.SENSOR_CONTROL_MODE,
+ ContextBase::mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH,
+ ContextBase::mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC,
+ ContextBase::mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH,
+ ContextBase::mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC,
+ ContextBase::mSap_conf.SENSOR_ACCEL_SAMPLES_PER_BATCH_HIGH,
+ ContextBase::mSap_conf.SENSOR_ACCEL_BATCHES_PER_SEC_HIGH,
+ ContextBase::mSap_conf.SENSOR_GYRO_SAMPLES_PER_BATCH_HIGH,
+ ContextBase::mSap_conf.SENSOR_GYRO_BATCHES_PER_SEC_HIGH,
+ ContextBase::mSap_conf.SENSOR_ALGORITHM_CONFIG_MASK);
+ }
+ };
+
+ sendMsg(new MsgSetConfig(*this, *mLocApi));
+}
+
+uint32_t*
+GnssAdapter::gnssUpdateConfigCommand(GnssConfig config)
+{
+ // count the number of bits set
+ GnssConfigFlagsMask flagsCopy = config.flags;
+ size_t count = 0;
+ while (flagsCopy > 0) {
+ if (flagsCopy & 1) {
+ count++;
+ }
+ flagsCopy >>= 1;
+ }
+ std::string idsString = "[";
+ uint32_t* ids = NULL;
+ if (count > 0) {
+ ids = new uint32_t[count];
+ if (ids == nullptr) {
+ LOC_LOGE("%s] new allocation failed, fatal error.", __func__);
+ return nullptr;
+ }
+ for (size_t i=0; i < count; ++i) {
+ ids[i] = generateSessionId();
+ IF_LOC_LOGD {
+ idsString += std::to_string(ids[i]) + " ";
+ }
+ }
+ }
+ idsString += "]";
+
+ LOC_LOGD("%s]: ids %s flags 0x%X", __func__, idsString.c_str(), config.flags);
+
+ struct MsgGnssUpdateConfig : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ GnssConfig mConfig;
+ uint32_t* mIds;
+ size_t mCount;
+ inline MsgGnssUpdateConfig(GnssAdapter& adapter,
+ LocApiBase& api,
+ GnssConfig config,
+ uint32_t* ids,
+ size_t count) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mConfig(config),
+ mIds(ids),
+ mCount(count) {}
+ inline virtual ~MsgGnssUpdateConfig()
+ {
+ delete[] mIds;
+ }
+ inline virtual void proc() const {
+ LocationError* errs = new LocationError[mCount];
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ uint32_t index = 0;
+
+ if (errs == nullptr) {
+ LOC_LOGE("%s] new allocation failed, fatal error.", __func__);
+ return;
+ }
+
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT) {
+ uint32_t newGpsLock = mAdapter.convertGpsLock(mConfig.gpsLock);
+ ContextBase::mGps_conf.GPS_LOCK = newGpsLock;
+ if (0 == mAdapter.getPowerVoteId()) {
+ err = mApi.setGpsLock(mConfig.gpsLock);
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT) {
+ uint32_t newSuplVersion = mAdapter.convertSuplVersion(mConfig.suplVersion);
+ if (newSuplVersion != ContextBase::mGps_conf.SUPL_VER &&
+ ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
+ ContextBase::mGps_conf.SUPL_VER = newSuplVersion;
+ err = mApi.setSUPLVersion(mConfig.suplVersion);
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_SET_ASSISTANCE_DATA_VALID_BIT) {
+ if (GNSS_ASSISTANCE_TYPE_SUPL == mConfig.assistanceServer.type) {
+ if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
+ char serverUrl[MAX_URL_LEN] = {};
+ int32_t length = 0;
+ const char noHost[] = "NONE";
+ if (NULL == mConfig.assistanceServer.hostName ||
+ strncasecmp(noHost,
+ mConfig.assistanceServer.hostName,
+ sizeof(noHost)) == 0) {
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ } else {
+ length = snprintf(serverUrl, sizeof(serverUrl), "%s:%u",
+ mConfig.assistanceServer.hostName,
+ mConfig.assistanceServer.port);
+ }
+
+ if (length > 0 && strncasecmp(mAdapter.getServerUrl().c_str(),
+ serverUrl, sizeof(serverUrl)) != 0) {
+ mAdapter.setServerUrl(serverUrl);
+ err = mApi.setServer(serverUrl, length);
+ }
+
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ } else if (GNSS_ASSISTANCE_TYPE_C2K == mConfig.assistanceServer.type) {
+ if (ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
+ struct in_addr addr;
+ if (!mAdapter.resolveInAddress(mConfig.assistanceServer.hostName,
+ &addr)) {
+ LOC_LOGE("%s]: hostName %s cannot be resolved",
+ __func__, mConfig.assistanceServer.hostName);
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ } else {
+ unsigned int ip = htonl(addr.s_addr);
+ err = mApi.setServer(ip, mConfig.assistanceServer.port,
+ LOC_AGPS_CDMA_PDE_SERVER);
+ }
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ } else {
+ LOC_LOGE("%s]: Not a valid gnss assistance type %u",
+ __func__, mConfig.assistanceServer.type);
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT) {
+ uint32_t newLppProfile = mAdapter.convertLppProfile(mConfig.lppProfile);
+ if (newLppProfile != ContextBase::mGps_conf.LPP_PROFILE &&
+ ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
+ ContextBase::mGps_conf.LPP_PROFILE = newLppProfile;
+ err = mApi.setLPPConfig(mConfig.lppProfile);
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_LPPE_CONTROL_PLANE_VALID_BIT) {
+ uint32_t newLppeControlPlaneMask =
+ mAdapter.convertLppeCp(mConfig.lppeControlPlaneMask);
+ if (newLppeControlPlaneMask != ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY) {
+ ContextBase::mGps_conf.LPPE_CP_TECHNOLOGY = newLppeControlPlaneMask;
+ err = mApi.setLPPeProtocolCp(mConfig.lppeControlPlaneMask);
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_LPPE_USER_PLANE_VALID_BIT) {
+ uint32_t newLppeUserPlaneMask =
+ mAdapter.convertLppeUp(mConfig.lppeUserPlaneMask);
+ if (newLppeUserPlaneMask != ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY) {
+ ContextBase::mGps_conf.LPPE_UP_TECHNOLOGY = newLppeUserPlaneMask;
+ err = mApi.setLPPeProtocolUp(mConfig.lppeUserPlaneMask);
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT) {
+ uint32_t newAGloProtMask =
+ mAdapter.convertAGloProt(mConfig.aGlonassPositionProtocolMask);
+ if (newAGloProtMask != ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT &&
+ ContextBase::mGps_conf.AGPS_CONFIG_INJECT) {
+ ContextBase::mGps_conf.A_GLONASS_POS_PROTOCOL_SELECT = newAGloProtMask;
+ err = mApi.setAGLONASSProtocol(mConfig.aGlonassPositionProtocolMask);
+ } else {
+ err = LOCATION_ERROR_SUCCESS;
+ }
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT) {
+ uint32_t newEP4ES = mAdapter.convertEP4ES(mConfig.emergencyPdnForEmergencySupl);
+ if (newEP4ES != ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL) {
+ ContextBase::mGps_conf.USE_EMERGENCY_PDN_FOR_EMERGENCY_SUPL = newEP4ES;
+ }
+ err = LOCATION_ERROR_SUCCESS;
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_EM_SERVICES_BIT) {
+ uint32_t newSuplEs = mAdapter.convertSuplEs(mConfig.suplEmergencyServices);
+ if (newSuplEs != ContextBase::mGps_conf.SUPL_ES) {
+ ContextBase::mGps_conf.SUPL_ES = newSuplEs;
+ }
+ err = LOCATION_ERROR_SUCCESS;
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+ if (mConfig.flags & GNSS_CONFIG_FLAGS_SUPL_MODE_BIT) {
+ uint32_t newSuplMode = mAdapter.convertSuplMode(mConfig.suplModeMask);
+ if (newSuplMode != ContextBase::mGps_conf.SUPL_MODE) {
+ ContextBase::mGps_conf.SUPL_MODE = newSuplMode;
+ mAdapter.getUlpProxy()->setCapabilities(
+ ContextBase::getCarrierCapabilities());
+ mAdapter.broadcastCapabilities(mAdapter.getCapabilities());
+ }
+ err = LOCATION_ERROR_SUCCESS;
+ if (index < mCount) {
+ errs[index++] = err;
+ }
+ }
+
+ mAdapter.reportResponse(index, errs, mIds);
+ delete[] errs;
+ }
+ };
+
+ if (NULL != ids) {
+ sendMsg(new MsgGnssUpdateConfig(*this, *mLocApi, config, ids, count));
+ } else {
+ LOC_LOGE("%s]: No GNSS config items to update", __func__);
+ }
+
+ return ids;
+}
+
+uint32_t
+GnssAdapter::gnssDeleteAidingDataCommand(GnssAidingData& data)
+{
+ uint32_t sessionId = generateSessionId();
+ LOC_LOGD("%s]: id %u", __func__, sessionId);
+
+ struct MsgDeleteAidingData : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ uint32_t mSessionId;
+ GnssAidingData mData;
+ inline MsgDeleteAidingData(GnssAdapter& adapter,
+ LocApiBase& api,
+ uint32_t sessionId,
+ GnssAidingData& data) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mSessionId(sessionId),
+ mData(data) {}
+ inline virtual void proc() const {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ err = mApi.deleteAidingData(mData);
+ mAdapter.reportResponse(err, mSessionId);
+ SystemStatus* s = mAdapter.getSystemStatus();
+ if ((nullptr != s) && (mData.deleteAll)) {
+ s->setDefaultReport();
+ }
+ }
+ };
+
+ sendMsg(new MsgDeleteAidingData(*this, *mLocApi, sessionId, data));
+ return sessionId;
+}
+
+void
+GnssAdapter::injectLocationCommand(double latitude, double longitude, float accuracy)
+{
+ LOC_LOGD("%s]: latitude %8.4f longitude %8.4f accuracy %8.4f",
+ __func__, latitude, longitude, accuracy);
+
+ struct MsgInjectLocation : public LocMsg {
+ LocApiBase& mApi;
+ ContextBase& mContext;
+ double mLatitude;
+ double mLongitude;
+ float mAccuracy;
+ inline MsgInjectLocation(LocApiBase& api,
+ ContextBase& context,
+ double latitude,
+ double longitude,
+ float accuracy) :
+ LocMsg(),
+ mApi(api),
+ mContext(context),
+ mLatitude(latitude),
+ mLongitude(longitude),
+ mAccuracy(accuracy) {}
+ inline virtual void proc() const {
+ if (!mContext.hasCPIExtendedCapabilities()) {
+ mApi.injectPosition(mLatitude, mLongitude, mAccuracy);
+ }
+ }
+ };
+
+ sendMsg(new MsgInjectLocation(*mLocApi, *mContext, latitude, longitude, accuracy));
+}
+
+void
+GnssAdapter::injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty)
+{
+ LOC_LOGD("%s]: time %lld timeReference %lld uncertainty %d",
+ __func__, (long long)time, (long long)timeReference, uncertainty);
+
+ struct MsgInjectTime : public LocMsg {
+ LocApiBase& mApi;
+ ContextBase& mContext;
+ int64_t mTime;
+ int64_t mTimeReference;
+ int32_t mUncertainty;
+ inline MsgInjectTime(LocApiBase& api,
+ ContextBase& context,
+ int64_t time,
+ int64_t timeReference,
+ int32_t uncertainty) :
+ LocMsg(),
+ mApi(api),
+ mContext(context),
+ mTime(time),
+ mTimeReference(timeReference),
+ mUncertainty(uncertainty) {}
+ inline virtual void proc() const {
+ mApi.setTime(mTime, mTimeReference, mUncertainty);
+ }
+ };
+
+ sendMsg(new MsgInjectTime(*mLocApi, *mContext, time, timeReference, uncertainty));
+}
+
+void
+GnssAdapter::setUlpProxyCommand(UlpProxyBase* ulp)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgSetUlpProxy : public LocMsg {
+ GnssAdapter& mAdapter;
+ UlpProxyBase* mUlp;
+ inline MsgSetUlpProxy(GnssAdapter& adapter,
+ UlpProxyBase* ulp) :
+ LocMsg(),
+ mAdapter(adapter),
+ mUlp(ulp) {}
+ inline virtual void proc() const {
+ mAdapter.setUlpProxy(mUlp);
+ if (mUlp) {
+ mUlp->setCapabilities(ContextBase::getCarrierCapabilities());
+ }
+ }
+ };
+
+ sendMsg(new MsgSetUlpProxy(*this, ulp));
+}
+
+void
+GnssAdapter::setUlpProxy(UlpProxyBase* ulp)
+{
+ if (ulp == mUlpProxy) {
+ //This takes care of the case when double initalization happens
+ //and we get the same object back for UlpProxyBase . Do nothing
+ return;
+ }
+
+ LOC_LOGV("%s]: %p", __func__, ulp);
+ if (NULL == ulp) {
+ LOC_LOGE("%s]: ulp pointer is NULL", __func__);
+ ulp = new UlpProxyBase();
+ }
+
+ if (LOC_POSITION_MODE_INVALID != mUlpProxy->mPosMode.mode) {
+ // need to send this mode and start msg to ULP
+ ulp->sendFixMode(mUlpProxy->mPosMode);
+ }
+
+ if (mUlpProxy->mFixSet) {
+ ulp->sendStartFix();
+ }
+
+ delete mUlpProxy;
+ mUlpProxy = ulp;
+}
+
+void
+GnssAdapter::addClientCommand(LocationAPI* client, const LocationCallbacks& callbacks)
+{
+ LOC_LOGD("%s]: client %p", __func__, client);
+
+ struct MsgAddClient : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocationAPI* mClient;
+ const LocationCallbacks mCallbacks;
+ inline MsgAddClient(GnssAdapter& adapter,
+ LocationAPI* client,
+ const LocationCallbacks& callbacks) :
+ LocMsg(),
+ mAdapter(adapter),
+ mClient(client),
+ mCallbacks(callbacks) {}
+ inline virtual void proc() const {
+ mAdapter.saveClient(mClient, mCallbacks);
+ }
+ };
+
+ sendMsg(new MsgAddClient(*this, client, callbacks));
+}
+
+void
+GnssAdapter::removeClientCommand(LocationAPI* client)
+{
+ LOC_LOGD("%s]: client %p", __func__, client);
+
+ struct MsgRemoveClient : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocationAPI* mClient;
+ inline MsgRemoveClient(GnssAdapter& adapter,
+ LocationAPI* client) :
+ LocMsg(),
+ mAdapter(adapter),
+ mClient(client) {}
+ inline virtual void proc() const {
+ mAdapter.stopClientSessions(mClient);
+ mAdapter.eraseClient(mClient);
+ }
+ };
+
+ sendMsg(new MsgRemoveClient(*this, client));
+}
+
+void
+GnssAdapter::stopClientSessions(LocationAPI* client)
+{
+ LOC_LOGD("%s]: client %p", __func__, client);
+ for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end();) {
+ if (client == it->first.client) {
+ LocationError err = stopTrackingMultiplex(it->first.client, it->first.id);
+ if (LOCATION_ERROR_SUCCESS == err) {
+ it = mTrackingSessions.erase(it);
+ continue;
+ }
+ }
+ ++it; // increment only when not erasing an iterator
+ }
+
+}
+
+void
+GnssAdapter::updateClientsEventMask()
+{
+ LOC_API_ADAPTER_EVENT_MASK_T mask = 0;
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (it->second.trackingCb != nullptr) {
+ mask |= LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT;
+ }
+ if (it->second.gnssNiCb != nullptr) {
+ mask |= LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST;
+ }
+ if (it->second.gnssSvCb != nullptr) {
+ mask |= LOC_API_ADAPTER_BIT_SATELLITE_REPORT;
+ }
+ if ((it->second.gnssNmeaCb != nullptr) && (mNmeaMask)) {
+ mask |= LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT;
+ }
+ if (it->second.gnssMeasurementsCb != nullptr) {
+ mask |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
+ }
+ }
+
+ /*
+ ** For Automotive use cases we need to enable MEASUREMENT and POLY
+ ** when QDR is enabled
+ */
+ if(1 == ContextBase::mGps_conf.EXTERNAL_DR_ENABLED) {
+ mask |= LOC_API_ADAPTER_BIT_GNSS_MEASUREMENT;
+ mask |= LOC_API_ADAPTER_BIT_GNSS_SV_POLYNOMIAL_REPORT;
+
+ LOC_LOGD("%s]: Auto usecase, Enable MEAS/POLY - mask 0x%x", __func__, mask);
+ }
+
+ updateEvtMask(mask, LOC_REGISTRATION_MASK_SET);
+}
+
+void
+GnssAdapter::handleEngineUpEvent()
+{
+ struct MsgRestartSessions : public LocMsg {
+ GnssAdapter& mAdapter;
+ inline MsgRestartSessions(GnssAdapter& adapter) :
+ LocMsg(),
+ mAdapter(adapter) {}
+ virtual void proc() const {
+ mAdapter.restartSessions();
+ }
+ };
+
+ setConfigCommand();
+ sendMsg(new MsgRestartSessions(*this));
+}
+
+void
+GnssAdapter::restartSessions()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ if (mTrackingSessions.empty()) {
+ return;
+ }
+
+ // get the LocationOptions that has the smallest interval, which should be the active one
+ LocationOptions smallestIntervalOptions = {}; // size is zero until set for the first time
+ for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end(); ++it) {
+ if (0 == smallestIntervalOptions.size || //size of zero means we havent set it yet
+ it->second.minInterval < smallestIntervalOptions.minInterval) {
+ smallestIntervalOptions = it->second;
+ }
+ }
+
+ LocPosMode locPosMode = {};
+ convertOptions(locPosMode, smallestIntervalOptions);
+ mLocApi->startFix(locPosMode);
+}
+
+void
+GnssAdapter::requestCapabilitiesCommand(LocationAPI* client)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgRequestCapabilities : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocationAPI* mClient;
+ inline MsgRequestCapabilities(GnssAdapter& adapter,
+ LocationAPI* client) :
+ LocMsg(),
+ mAdapter(adapter),
+ mClient(client) {}
+ inline virtual void proc() const {
+ LocationCallbacks callbacks = mAdapter.getClientCallbacks(mClient);
+ if (callbacks.capabilitiesCb == nullptr) {
+ LOC_LOGE("%s]: capabilitiesCb is NULL", __func__);
+ return;
+ }
+
+ LocationCapabilitiesMask mask = mAdapter.getCapabilities();
+ callbacks.capabilitiesCb(mask);
+ }
+ };
+
+ sendMsg(new MsgRequestCapabilities(*this, client));
+}
+
+LocationCapabilitiesMask
+GnssAdapter::getCapabilities()
+{
+ LocationCapabilitiesMask mask = 0;
+ uint32_t carrierCapabilities = ContextBase::getCarrierCapabilities();
+ // time based tracking always supported
+ mask |= LOCATION_CAPABILITIES_TIME_BASED_TRACKING_BIT;
+ // geofence always supported
+ mask |= LOCATION_CAPABILITIES_GEOFENCE_BIT;
+ if (carrierCapabilities & LOC_GPS_CAPABILITY_MSB) {
+ mask |= LOCATION_CAPABILITIES_GNSS_MSB_BIT;
+ }
+ if (LOC_GPS_CAPABILITY_MSA & carrierCapabilities) {
+ mask |= LOCATION_CAPABILITIES_GNSS_MSA_BIT;
+ }
+ if (mLocApi == nullptr)
+ return mask;
+ if (mLocApi->isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_LOCATION_BATCHING)) {
+ mask |= LOCATION_CAPABILITIES_TIME_BASED_BATCHING_BIT |
+ LOCATION_CAPABILITIES_DISTANCE_BASED_BATCHING_BIT;
+ }
+ if (mLocApi->isMessageSupported(LOC_API_ADAPTER_MESSAGE_DISTANCE_BASE_TRACKING)) {
+ mask |= LOCATION_CAPABILITIES_DISTANCE_BASED_TRACKING_BIT;
+ }
+ if (mLocApi->isMessageSupported(LOC_API_ADAPTER_MESSAGE_OUTDOOR_TRIP_BATCHING)) {
+ mask |= LOCATION_CAPABILITIES_OUTDOOR_TRIP_BATCHING_BIT;
+ }
+ if (mLocApi->gnssConstellationConfig()) {
+ mask |= LOCATION_CAPABILITIES_GNSS_MEASUREMENTS_BIT;
+ }
+ if (mLocApi->isFeatureSupported(LOC_SUPPORTED_FEATURE_DEBUG_NMEA_V02)) {
+ mask |= LOCATION_CAPABILITIES_DEBUG_NMEA_BIT;
+ }
+ return mask;
+}
+
+void
+GnssAdapter::broadcastCapabilities(LocationCapabilitiesMask mask)
+{
+ for (auto it = mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.capabilitiesCb) {
+ it->second.capabilitiesCb(mask);
+ }
+ }
+}
+
+LocationCallbacks
+GnssAdapter::getClientCallbacks(LocationAPI* client)
+{
+ LocationCallbacks callbacks = {};
+ auto it = mClientData.find(client);
+ if (it != mClientData.end()) {
+ callbacks = it->second;
+ }
+ return callbacks;
+}
+
+void
+GnssAdapter::saveClient(LocationAPI* client, const LocationCallbacks& callbacks)
+{
+ mClientData[client] = callbacks;
+ updateClientsEventMask();
+}
+
+void
+GnssAdapter::eraseClient(LocationAPI* client)
+{
+ auto it = mClientData.find(client);
+ if (it != mClientData.end()) {
+ mClientData.erase(it);
+ }
+ updateClientsEventMask();
+}
+
+bool
+GnssAdapter::hasTrackingCallback(LocationAPI* client)
+{
+ auto it = mClientData.find(client);
+ return (it != mClientData.end() && it->second.trackingCb);
+}
+
+bool
+GnssAdapter::hasMeasurementsCallback(LocationAPI* client)
+{
+ auto it = mClientData.find(client);
+ return (it != mClientData.end() && it->second.gnssMeasurementsCb);
+}
+
+bool
+GnssAdapter::isTrackingSession(LocationAPI* client, uint32_t sessionId)
+{
+ LocationSessionKey key(client, sessionId);
+ return (mTrackingSessions.find(key) != mTrackingSessions.end());
+}
+
+void
+GnssAdapter::saveTrackingSession(LocationAPI* client, uint32_t sessionId,
+ const LocationOptions& options)
+{
+ LocationSessionKey key(client, sessionId);
+ mTrackingSessions[key] = options;
+}
+
+void
+GnssAdapter::eraseTrackingSession(LocationAPI* client, uint32_t sessionId)
+{
+ LocationSessionKey key(client, sessionId);
+ auto it = mTrackingSessions.find(key);
+ if (it != mTrackingSessions.end()) {
+ mTrackingSessions.erase(it);
+ }
+
+}
+
+bool GnssAdapter::setUlpPositionMode(const LocPosMode& mode) {
+ if (!mUlpPositionMode.equals(mode)) {
+ mUlpPositionMode = mode;
+ return true;
+ } else {
+ return false;
+ }
+}
+
+void
+GnssAdapter::reportResponse(LocationAPI* client, LocationError err, uint32_t sessionId)
+{
+ LOC_LOGD("%s]: client %p id %u err %u", __func__, client, sessionId, err);
+
+ auto it = mClientData.find(client);
+ if (it != mClientData.end() &&
+ it->second.responseCb != nullptr) {
+ it->second.responseCb(err, sessionId);
+ } else {
+ LOC_LOGW("%s]: client %p id %u not found in data", __func__, client, sessionId);
+ }
+}
+
+void
+GnssAdapter::reportResponse(LocationError err, uint32_t sessionId)
+{
+ LOC_LOGD("%s]: id %u err %u", __func__, sessionId, err);
+
+ if (mControlCallbacks.size > 0 && mControlCallbacks.responseCb != nullptr) {
+ mControlCallbacks.responseCb(err, sessionId);
+ } else {
+ LOC_LOGW("%s]: control client response callback not found", __func__);
+ }
+}
+
+void
+GnssAdapter::reportResponse(size_t count, LocationError* errs, uint32_t* ids)
+{
+ IF_LOC_LOGD {
+ std::string idsString = "[";
+ std::string errsString = "[";
+ if (NULL != ids && NULL != errs) {
+ for (size_t i=0; i < count; ++i) {
+ idsString += std::to_string(ids[i]) + " ";
+ errsString += std::to_string(errs[i]) + " ";
+ }
+ }
+ idsString += "]";
+ errsString += "]";
+
+ LOC_LOGD("%s]: ids %s errs %s",
+ __func__, idsString.c_str(), errsString.c_str());
+ }
+
+ if (mControlCallbacks.size > 0 && mControlCallbacks.collectiveResponseCb != nullptr) {
+ mControlCallbacks.collectiveResponseCb(count, errs, ids);
+ } else {
+ LOC_LOGW("%s]: control client callback not found", __func__);
+ }
+}
+
+uint32_t
+GnssAdapter::startTrackingCommand(LocationAPI* client, LocationOptions& options)
+{
+ uint32_t sessionId = generateSessionId();
+ LOC_LOGD("%s]: client %p id %u minInterval %u mode %u",
+ __func__, client, sessionId, options.minInterval, options.mode);
+
+ struct MsgStartTracking : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ LocationAPI* mClient;
+ uint32_t mSessionId;
+ LocationOptions mOptions;
+ inline MsgStartTracking(GnssAdapter& adapter,
+ LocApiBase& api,
+ LocationAPI* client,
+ uint32_t sessionId,
+ LocationOptions options) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mClient(client),
+ mSessionId(sessionId),
+ mOptions(options) {}
+ inline virtual void proc() const {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ if (!mAdapter.hasTrackingCallback(mClient) &&
+ !mAdapter.hasMeasurementsCallback(mClient)) {
+ err = LOCATION_ERROR_CALLBACK_MISSING;
+ } else if (0 == mOptions.size) {
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ } else {
+ // Api doesn't support multiple clients for time based tracking, so mutiplex
+ err = mAdapter.startTrackingMultiplex(mOptions);
+ if (LOCATION_ERROR_SUCCESS == err) {
+ mAdapter.saveTrackingSession(mClient, mSessionId, mOptions);
+ }
+ }
+ mAdapter.reportResponse(mClient, err, mSessionId);
+ }
+ };
+
+ sendMsg(new MsgStartTracking(*this, *mLocApi, client, sessionId, options));
+ return sessionId;
+
+}
+
+LocationError
+GnssAdapter::startTrackingMultiplex(const LocationOptions& options)
+{
+ LocationError err = LOCATION_ERROR_SUCCESS;
+
+ if (mTrackingSessions.empty()) {
+ err = startTracking(options);
+ } else {
+ // get the LocationOptions that has the smallest interval, which should be the active one
+ LocationOptions smallestIntervalOptions = {}; // size is zero until set for the first time
+ for (auto it = mTrackingSessions.begin(); it != mTrackingSessions.end(); ++it) {
+ if (0 == smallestIntervalOptions.size || //size of zero means we havent set it yet
+ it->second.minInterval < smallestIntervalOptions.minInterval) {
+ smallestIntervalOptions = it->second;
+ }
+ }
+ // if new session's minInterval is smaller than any in other sessions
+ if (options.minInterval < smallestIntervalOptions.minInterval) {
+ // restart time based tracking with new options
+ err = startTracking(options);
+ }
+ }
+
+ return err;
+}
+
+LocationError
+GnssAdapter::startTracking(const LocationOptions& options)
+{
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ LocPosMode locPosMode = {};
+ convertOptions(locPosMode, options);
+ if (!mUlpProxy->sendFixMode(locPosMode)) {
+ // do nothing
+ }
+ if (!mUlpProxy->sendStartFix()) {
+ loc_api_adapter_err apiErr = mLocApi->startFix(locPosMode);
+ if (LOC_API_ADAPTER_ERR_SUCCESS == apiErr) {
+ err = LOCATION_ERROR_SUCCESS;
+ } else {
+ err = LOCATION_ERROR_GENERAL_FAILURE;
+ }
+ }
+
+ return err;
+}
+
+void
+GnssAdapter::setPositionModeCommand(LocPosMode& locPosMode)
+{
+ LOC_LOGD("%s]: min_interval %u mode %u",
+ __func__, locPosMode.min_interval, locPosMode.mode);
+
+ struct MsgSetPositionMode : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ LocPosMode mLocPosMode;
+ inline MsgSetPositionMode(GnssAdapter& adapter,
+ LocApiBase& api,
+ LocPosMode& locPosMode) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mLocPosMode(locPosMode) {}
+ inline virtual void proc() const {
+ // saves the mode in adapter to be used when startTrackingCommand is called from ULP
+ if (mAdapter.setUlpPositionMode(mLocPosMode)) {
+ mApi.setPositionMode(mLocPosMode);
+ }
+ }
+ };
+
+ sendMsg(new MsgSetPositionMode(*this, *mLocApi, locPosMode));
+}
+
+void
+GnssAdapter::startTrackingCommand()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgStartTracking : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ inline MsgStartTracking(GnssAdapter& adapter,
+ LocApiBase& api) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api) {}
+ inline virtual void proc() const {
+ // we get this call from ULP, so just call LocApi without multiplexing because
+ // ulp would be doing the multiplexing for us if it is present
+ if (!mAdapter.isInSession()) {
+ LocPosMode& ulpPositionMode = mAdapter.getUlpPositionMode();
+ mApi.startFix(ulpPositionMode);
+ }
+ }
+ };
+
+ sendMsg(new MsgStartTracking(*this, *mLocApi));
+}
+
+void
+GnssAdapter::updateTrackingOptionsCommand(LocationAPI* client, uint32_t id,
+ LocationOptions& options)
+{
+ LOC_LOGD("%s]: client %p id %u minInterval %u mode %u",
+ __func__, client, id, options.minInterval, options.mode);
+
+ struct MsgUpdateTracking : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ LocationAPI* mClient;
+ uint32_t mSessionId;
+ LocationOptions mOptions;
+ inline MsgUpdateTracking(GnssAdapter& adapter,
+ LocApiBase& api,
+ LocationAPI* client,
+ uint32_t sessionId,
+ LocationOptions options) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mClient(client),
+ mSessionId(sessionId),
+ mOptions(options) {}
+ inline virtual void proc() const {
+ if (mAdapter.isTrackingSession(mClient, mSessionId)) {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ if (0 == mOptions.size) {
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ } else {
+ // Api doesn't support multiple clients for time based tracking, so mutiplex
+ err = mAdapter.updateTrackingMultiplex(mClient, mSessionId, mOptions);
+ if (LOCATION_ERROR_SUCCESS == err) {
+ mAdapter.saveTrackingSession(mClient, mSessionId, mOptions);
+ }
+ }
+ mAdapter.reportResponse(mClient, err, mSessionId);
+ }
+ // we do not reportResponse for the case where there is no existing tracking session
+ // for the client and id being used, since updateTrackingCommand can be sent to both
+ // GnssAdapter & FlpAdapter by LocationAPI and we want to avoid incorrect error response
+ }
+ };
+
+ sendMsg(new MsgUpdateTracking(*this, *mLocApi, client, id, options));
+}
+
+LocationError
+GnssAdapter::updateTrackingMultiplex(LocationAPI* client, uint32_t id,
+ const LocationOptions& options)
+{
+ LocationError err = LOCATION_ERROR_SUCCESS;
+
+ if (1 == mTrackingSessions.size()) {
+ err = startTracking(options);
+ } else {
+ LocationSessionKey key(client, id);
+
+ // get the session we are updating
+ auto it = mTrackingSessions.find(key);
+ if (it != mTrackingSessions.end()) {
+ // find the smallest interval, other than the session we are updating
+ LocationOptions smallestIntervalOptions = {}; // size is 0 until set for the first time
+ for (auto it2 = mTrackingSessions.begin(); it2 != mTrackingSessions.end(); ++it2) {
+ // if session is not the one we are updating and either smallest interval is not set
+ // or there is a new smallest interval, then set the new smallest interval
+ if (it2->first != key && (0 == smallestIntervalOptions.size ||
+ it2->second.minInterval < smallestIntervalOptions.minInterval)) {
+ smallestIntervalOptions = it2->second;
+ }
+ }
+ // if session we are updating has smaller interval then next smallest
+ if (options.minInterval < smallestIntervalOptions.minInterval) {
+ // restart time based tracking with the newly updated interval
+ err = startTracking(options);
+ // else if the session we are updating used to be the smallest
+ } else if (it->second.minInterval < smallestIntervalOptions.minInterval) {
+ // restart time based tracking with the next smallest
+ err = startTracking(smallestIntervalOptions);
+ }
+ }
+ }
+
+ return err;
+}
+
+void
+GnssAdapter::stopTrackingCommand(LocationAPI* client, uint32_t id)
+{
+ LOC_LOGD("%s]: client %p id %u", __func__, client, id);
+
+ struct MsgStopTracking : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ LocationAPI* mClient;
+ uint32_t mSessionId;
+ inline MsgStopTracking(GnssAdapter& adapter,
+ LocApiBase& api,
+ LocationAPI* client,
+ uint32_t sessionId) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mClient(client),
+ mSessionId(sessionId) {}
+ inline virtual void proc() const {
+ if (mAdapter.isTrackingSession(mClient, mSessionId)) {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ // Api doesn't support multiple clients for time based tracking, so mutiplex
+ err = mAdapter.stopTrackingMultiplex(mClient, mSessionId);
+ if (LOCATION_ERROR_SUCCESS == err) {
+ mAdapter.eraseTrackingSession(mClient, mSessionId);
+ }
+ mAdapter.reportResponse(mClient, err, mSessionId);
+ }
+ // we do not reportResponse for the case where there is no existing tracking session
+ // for the client and id being used, since stopTrackingCommand can be sent to both
+ // GnssAdapter & FlpAdapter by LocationAPI and we want to avoid incorrect error response
+
+ }
+ };
+
+ sendMsg(new MsgStopTracking(*this, *mLocApi, client, id));
+}
+
+LocationError
+GnssAdapter::stopTrackingMultiplex(LocationAPI* client, uint32_t id)
+{
+ LocationError err = LOCATION_ERROR_SUCCESS;
+
+ if (1 == mTrackingSessions.size()) {
+ err = stopTracking();
+ } else {
+ LocationSessionKey key(client, id);
+
+ // get the session we are stopping
+ auto it = mTrackingSessions.find(key);
+ if (it != mTrackingSessions.end()) {
+ // find the next smallest interval, other than the session we are stopping
+ LocationOptions smallestIntervalOptions = {}; // size is 0 until set for the first time
+ for (auto it2 = mTrackingSessions.begin(); it2 != mTrackingSessions.end(); ++it2) {
+ // if session is not the one we are stopping and either smallest interval is not set
+ // or there is a new smallest interval, then set the new smallest interval
+ if (it2->first != key && (0 == smallestIntervalOptions.size ||
+ it2->second.minInterval < smallestIntervalOptions.minInterval)) {
+ smallestIntervalOptions = it2->second;
+ }
+ }
+ // if session we are stopping has smaller interval then next smallest
+ if (it->second.minInterval < smallestIntervalOptions.minInterval) {
+ // restart time based tracking with next smallest interval
+ err = startTracking(smallestIntervalOptions);
+ }
+ }
+ }
+
+ return err;
+}
+
+LocationError
+GnssAdapter::stopTracking()
+{
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ if (!mUlpProxy->sendStopFix()) {
+ loc_api_adapter_err apiErr = mLocApi->stopFix();
+ if (LOC_API_ADAPTER_ERR_SUCCESS == apiErr) {
+ err = LOCATION_ERROR_SUCCESS;
+ } else {
+ err = LOCATION_ERROR_GENERAL_FAILURE;
+ }
+ }
+
+ return err;
+}
+
+void
+GnssAdapter::stopTrackingCommand()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgStopTracking : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ inline MsgStopTracking(GnssAdapter& adapter,
+ LocApiBase& api) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api) {}
+ inline virtual void proc() const {
+ // clear the position mode
+ LocPosMode mLocPosMode = {};
+ mLocPosMode.mode = LOC_POSITION_MODE_INVALID;
+ mAdapter.setUlpPositionMode(mLocPosMode);
+ // don't need to multiplex because ULP will do that for us if it is present
+ mApi.stopFix();
+ }
+ };
+
+ sendMsg(new MsgStopTracking(*this, *mLocApi));
+}
+
+void
+GnssAdapter::getZppCommand()
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgGetZpp : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ inline MsgGetZpp(GnssAdapter& adapter,
+ LocApiBase& api) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api) {}
+ inline virtual void proc() const {
+ UlpLocation location = {};
+ LocPosTechMask techMask = LOC_POS_TECH_MASK_DEFAULT;
+ GpsLocationExtended locationExtended = {};
+ locationExtended.size = sizeof(locationExtended);
+
+ mApi.getBestAvailableZppFix(location.gpsLocation, locationExtended,
+ techMask);
+ //Mark the location source as from ZPP
+ location.gpsLocation.flags |= LOCATION_HAS_SOURCE_INFO;
+ location.position_source = ULP_LOCATION_IS_FROM_ZPP;
+
+ mAdapter.getUlpProxy()->reportPosition(location,
+ locationExtended,
+ LOC_SESS_SUCCESS,
+ techMask);
+ }
+ };
+
+ sendMsg(new MsgGetZpp(*this, *mLocApi));
+}
+
+bool
+GnssAdapter::hasNiNotifyCallback(LocationAPI* client)
+{
+ auto it = mClientData.find(client);
+ return (it != mClientData.end() && it->second.gnssNiCb);
+}
+
+void
+GnssAdapter::gnssNiResponseCommand(LocationAPI* client,
+ uint32_t id,
+ GnssNiResponse response)
+{
+ LOC_LOGD("%s]: client %p id %u response %u", __func__, client, id, response);
+
+ struct MsgGnssNiResponse : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocationAPI* mClient;
+ uint32_t mSessionId;
+ GnssNiResponse mResponse;
+ inline MsgGnssNiResponse(GnssAdapter& adapter,
+ LocationAPI* client,
+ uint32_t sessionId,
+ GnssNiResponse response) :
+ LocMsg(),
+ mAdapter(adapter),
+ mClient(client),
+ mSessionId(sessionId),
+ mResponse(response) {}
+ inline virtual void proc() const {
+ NiData& niData = mAdapter.getNiData();
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ if (!mAdapter.hasNiNotifyCallback(mClient)) {
+ err = LOCATION_ERROR_ID_UNKNOWN;
+ } else {
+ NiSession* pSession = NULL;
+ if (mSessionId == niData.sessionEs.reqID &&
+ NULL != niData.sessionEs.rawRequest) {
+ pSession = &niData.sessionEs;
+ // ignore any SUPL NI non-Es session if a SUPL NI ES is accepted
+ if (mResponse == GNSS_NI_RESPONSE_ACCEPT &&
+ NULL != niData.session.rawRequest) {
+ pthread_mutex_lock(&niData.session.tLock);
+ niData.session.resp = GNSS_NI_RESPONSE_IGNORE;
+ niData.session.respRecvd = true;
+ pthread_cond_signal(&niData.session.tCond);
+ pthread_mutex_unlock(&niData.session.tLock);
+ }
+ } else if (mSessionId == niData.session.reqID &&
+ NULL != niData.session.rawRequest) {
+ pSession = &niData.session;
+ }
+
+ if (pSession) {
+ LOC_LOGI("%s]: gnssNiResponseCommand: send user mResponse %u for id %u",
+ __func__, mResponse, mSessionId);
+ pthread_mutex_lock(&pSession->tLock);
+ pSession->resp = mResponse;
+ pSession->respRecvd = true;
+ pthread_cond_signal(&pSession->tCond);
+ pthread_mutex_unlock(&pSession->tLock);
+ } else {
+ err = LOCATION_ERROR_ID_UNKNOWN;
+ LOC_LOGE("%s]: gnssNiResponseCommand: id %u not an active session",
+ __func__, mSessionId);
+ }
+ }
+ mAdapter.reportResponse(mClient, err, mSessionId);
+ }
+ };
+
+ sendMsg(new MsgGnssNiResponse(*this, client, id, response));
+
+}
+
+void
+GnssAdapter::gnssNiResponseCommand(GnssNiResponse response, void* rawRequest)
+{
+ LOC_LOGD("%s]: response %u", __func__, response);
+
+ struct MsgGnssNiResponse : public LocMsg {
+ LocApiBase& mApi;
+ const GnssNiResponse mResponse;
+ const void* mPayload;
+ inline MsgGnssNiResponse(LocApiBase& api,
+ const GnssNiResponse response,
+ const void* rawRequest) :
+ LocMsg(),
+ mApi(api),
+ mResponse(response),
+ mPayload(rawRequest) {}
+ inline virtual ~MsgGnssNiResponse() {
+ // this is a bit weird since mPayload is not
+ // allocated by this class. But there is no better way.
+ // mPayload actually won't be NULL here.
+ free((void*)mPayload);
+ }
+ inline virtual void proc() const {
+ mApi.informNiResponse(mResponse, mPayload);
+ }
+ };
+
+ sendMsg(new MsgGnssNiResponse(*mLocApi, response, rawRequest));
+
+}
+
+uint32_t
+GnssAdapter::enableCommand(LocationTechnologyType techType)
+{
+ uint32_t sessionId = generateSessionId();
+ LOC_LOGD("%s]: id %u techType %u", __func__, sessionId, techType);
+
+ struct MsgEnableGnss : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ ContextBase& mContext;
+ uint32_t mSessionId;
+ LocationTechnologyType mTechType;
+ inline MsgEnableGnss(GnssAdapter& adapter,
+ LocApiBase& api,
+ ContextBase& context,
+ uint32_t sessionId,
+ LocationTechnologyType techType) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mContext(context),
+ mSessionId(sessionId),
+ mTechType(techType) {}
+ inline virtual void proc() const {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ uint32_t powerVoteId = mAdapter.getPowerVoteId();
+ if (mTechType != LOCATION_TECHNOLOGY_TYPE_GNSS) {
+ err = LOCATION_ERROR_INVALID_PARAMETER;
+ } else if (powerVoteId > 0) {
+ err = LOCATION_ERROR_ALREADY_STARTED;
+ } else {
+ mContext.modemPowerVote(true);
+ mAdapter.setPowerVoteId(mSessionId);
+ mApi.setGpsLock(GNSS_CONFIG_GPS_LOCK_NONE);
+ mAdapter.mXtraObserver.updateLockStatus(
+ mAdapter.convertGpsLock(GNSS_CONFIG_GPS_LOCK_NONE));
+ }
+ mAdapter.reportResponse(err, mSessionId);
+ }
+ };
+
+ if (mContext != NULL) {
+ sendMsg(new MsgEnableGnss(*this, *mLocApi, *mContext, sessionId, techType));
+ } else {
+ LOC_LOGE("%s]: Context is NULL", __func__);
+ }
+
+ return sessionId;
+}
+
+void
+GnssAdapter::disableCommand(uint32_t id)
+{
+ LOC_LOGD("%s]: id %u", __func__, id);
+
+ struct MsgDisableGnss : public LocMsg {
+ GnssAdapter& mAdapter;
+ LocApiBase& mApi;
+ ContextBase& mContext;
+ uint32_t mSessionId;
+ inline MsgDisableGnss(GnssAdapter& adapter,
+ LocApiBase& api,
+ ContextBase& context,
+ uint32_t sessionId) :
+ LocMsg(),
+ mAdapter(adapter),
+ mApi(api),
+ mContext(context),
+ mSessionId(sessionId) {}
+ inline virtual void proc() const {
+ LocationError err = LOCATION_ERROR_SUCCESS;
+ uint32_t powerVoteId = mAdapter.getPowerVoteId();
+ if (powerVoteId != mSessionId) {
+ err = LOCATION_ERROR_ID_UNKNOWN;
+ } else {
+ mContext.modemPowerVote(false);
+ mAdapter.setPowerVoteId(0);
+ mApi.setGpsLock(mAdapter.convertGpsLock(ContextBase::mGps_conf.GPS_LOCK));
+ mAdapter.mXtraObserver.updateLockStatus(
+ mAdapter.convertGpsLock(ContextBase::mGps_conf.GPS_LOCK));
+ }
+ mAdapter.reportResponse(err, mSessionId);
+ }
+ };
+
+ if (mContext != NULL) {
+ sendMsg(new MsgDisableGnss(*this, *mLocApi, *mContext, id));
+ }
+
+}
+
+void
+GnssAdapter::reportPositionEvent(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask techMask,
+ bool fromUlp)
+{
+ LOC_LOGD("%s]: fromUlp %u status %u", __func__, fromUlp, status);
+
+ // if this event is not called from ULP, then try to call into ULP and return if successfull
+ if (!fromUlp) {
+ if (mUlpProxy->reportPosition(ulpLocation, locationExtended,
+ status, techMask)) {
+ return;
+ }
+ }
+
+ struct MsgReportPosition : public LocMsg {
+ GnssAdapter& mAdapter;
+ const UlpLocation mUlpLocation;
+ const GpsLocationExtended mLocationExtended;
+ loc_sess_status mStatus;
+ LocPosTechMask mTechMask;
+ inline MsgReportPosition(GnssAdapter& adapter,
+ const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ loc_sess_status status,
+ LocPosTechMask techMask) :
+ LocMsg(),
+ mAdapter(adapter),
+ mUlpLocation(ulpLocation),
+ mLocationExtended(locationExtended),
+ mStatus(status),
+ mTechMask(techMask) {}
+ inline virtual void proc() const {
+ // extract bug report info - this returns true if consumed by systemstatus
+ SystemStatus* s = mAdapter.getSystemStatus();
+ if ((nullptr != s) && (LOC_SESS_SUCCESS == mStatus)){
+ s->eventPosition(mUlpLocation, mLocationExtended);
+ }
+ mAdapter.reportPosition(mUlpLocation, mLocationExtended, mStatus, mTechMask);
+ }
+ };
+
+ sendMsg(new MsgReportPosition(*this, ulpLocation, locationExtended, status, techMask));
+}
+
+void
+GnssAdapter::reportPosition(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask techMask)
+{
+ bool reported = false;
+ // what's in the if is... (line by line)
+ // 1. this is a final fix; and
+ // 1.1 it is a Satellite fix; or
+ // 1.2 it is a sensor fix
+ // 2. (must be intermediate fix... implicit)
+ // 2.1 we accepte intermediate; and
+ // 2.2 it is NOT the case that
+ // 2.2.1 there is inaccuracy; and
+ // 2.2.2 we care about inaccuracy; and
+ // 2.2.3 the inaccuracy exceeds our tolerance
+ if ((LOC_SESS_SUCCESS == status &&
+ ((LOC_POS_TECH_MASK_SATELLITE |
+ LOC_POS_TECH_MASK_SENSORS |
+ LOC_POS_TECH_MASK_HYBRID) &
+ techMask)) ||
+ (LOC_SESS_INTERMEDIATE == ContextBase::mGps_conf.INTERMEDIATE_POS &&
+ !((ulpLocation.gpsLocation.flags &
+ LOC_GPS_LOCATION_HAS_ACCURACY) &&
+ (ContextBase::mGps_conf.ACCURACY_THRES != 0) &&
+ (ulpLocation.gpsLocation.accuracy >
+ ContextBase::mGps_conf.ACCURACY_THRES)))) {
+ if (locationExtended.flags & GPS_LOCATION_EXTENDED_HAS_GNSS_SV_USED_DATA) {
+ mGnssSvIdUsedInPosAvail = true;
+ mGnssSvIdUsedInPosition = locationExtended.gnss_sv_used_ids;
+ }
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.trackingCb) {
+ Location location = {};
+ convertLocation(location, ulpLocation.gpsLocation, locationExtended, techMask);
+ it->second.trackingCb(location);
+ }
+ if (nullptr != it->second.gnssLocationInfoCb) {
+ GnssLocationInfoNotification locationInfo = {};
+ convertLocationInfo(locationInfo, locationExtended);
+ it->second.gnssLocationInfoCb(locationInfo);
+ }
+ }
+ reported = true;
+ }
+
+ if (NMEA_PROVIDER_AP == ContextBase::mGps_conf.NMEA_PROVIDER && !mTrackingSessions.empty()) {
+ /*Only BlankNMEA sentence needs to be processed and sent, if both lat, long is 0 &
+ horReliability is not set. */
+ bool blank_fix = ((0 == ulpLocation.gpsLocation.latitude) &&
+ (0 == ulpLocation.gpsLocation.longitude) &&
+ (LOC_RELIABILITY_NOT_SET == locationExtended.horizontal_reliability));
+ uint8_t generate_nmea = (reported && status != LOC_SESS_FAILURE && !blank_fix);
+ std::vector<std::string> nmeaArraystr;
+ loc_nmea_generate_pos(ulpLocation, locationExtended, generate_nmea, nmeaArraystr);
+ for (auto sentence : nmeaArraystr) {
+ reportNmea(sentence.c_str(), sentence.length());
+ }
+ }
+
+ // Free the allocated memory for rawData
+ UlpLocation* gp = (UlpLocation*)&(ulpLocation);
+ if (gp != NULL && gp->rawData != NULL)
+ {
+ delete (char*)gp->rawData;
+ gp->rawData = NULL;
+ gp->rawDataSize = 0;
+ }
+}
+
+void
+GnssAdapter::reportSvEvent(const GnssSvNotification& svNotify,
+ bool fromUlp)
+{
+ LOC_LOGD("%s]: fromUlp %u", __func__, fromUlp);
+
+ // if this event is not called from ULP, then try to call into ULP and return if successfull
+ if (!fromUlp) {
+ if (mUlpProxy->reportSv(svNotify)) {
+ return;
+ }
+ }
+
+ struct MsgReportSv : public LocMsg {
+ GnssAdapter& mAdapter;
+ const GnssSvNotification mSvNotify;
+ inline MsgReportSv(GnssAdapter& adapter,
+ const GnssSvNotification& svNotify) :
+ LocMsg(),
+ mAdapter(adapter),
+ mSvNotify(svNotify) {}
+ inline virtual void proc() const {
+ mAdapter.reportSv((GnssSvNotification&)mSvNotify);
+ }
+ };
+
+ sendMsg(new MsgReportSv(*this, svNotify));
+}
+
+void
+GnssAdapter::reportSv(GnssSvNotification& svNotify)
+{
+ int numSv = svNotify.count;
+ int16_t gnssSvId = 0;
+ uint64_t svUsedIdMask = 0;
+ for (int i=0; i < numSv; i++) {
+ svUsedIdMask = 0;
+ gnssSvId = svNotify.gnssSvs[i].svId;
+ switch (svNotify.gnssSvs[i].type) {
+ case GNSS_SV_TYPE_GPS:
+ if (mGnssSvIdUsedInPosAvail) {
+ svUsedIdMask = mGnssSvIdUsedInPosition.gps_sv_used_ids_mask;
+ }
+ break;
+ case GNSS_SV_TYPE_GLONASS:
+ if (mGnssSvIdUsedInPosAvail) {
+ svUsedIdMask = mGnssSvIdUsedInPosition.glo_sv_used_ids_mask;
+ }
+ break;
+ case GNSS_SV_TYPE_BEIDOU:
+ if (mGnssSvIdUsedInPosAvail) {
+ svUsedIdMask = mGnssSvIdUsedInPosition.bds_sv_used_ids_mask;
+ }
+ break;
+ case GNSS_SV_TYPE_GALILEO:
+ if (mGnssSvIdUsedInPosAvail) {
+ svUsedIdMask = mGnssSvIdUsedInPosition.gal_sv_used_ids_mask;
+ }
+ break;
+ case GNSS_SV_TYPE_QZSS:
+ if (mGnssSvIdUsedInPosAvail) {
+ svUsedIdMask = mGnssSvIdUsedInPosition.qzss_sv_used_ids_mask;
+ }
+ // QZSS SV id's need to reported as it is to framework, since
+ // framework expects it as it is. See GnssStatus.java.
+ // SV id passed to here by LocApi is 1-based.
+ svNotify.gnssSvs[i].svId += (QZSS_SV_PRN_MIN - 1);
+ break;
+ default:
+ svUsedIdMask = 0;
+ break;
+ }
+
+ // If SV ID was used in previous position fix, then set USED_IN_FIX
+ // flag, else clear the USED_IN_FIX flag.
+ if (svUsedIdMask & (1 << (gnssSvId - 1))) {
+ svNotify.gnssSvs[i].gnssSvOptionsMask |= GNSS_SV_OPTIONS_USED_IN_FIX_BIT;
+ }
+ }
+
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.gnssSvCb) {
+ it->second.gnssSvCb(svNotify);
+ }
+ }
+
+ if (NMEA_PROVIDER_AP == ContextBase::mGps_conf.NMEA_PROVIDER && !mTrackingSessions.empty()) {
+ std::vector<std::string> nmeaArraystr;
+ loc_nmea_generate_sv(svNotify, nmeaArraystr);
+ for (auto sentence : nmeaArraystr) {
+ reportNmea(sentence.c_str(), sentence.length());
+ }
+ }
+
+ mGnssSvIdUsedInPosAvail = false;
+}
+
+void
+GnssAdapter::reportNmeaEvent(const char* nmea, size_t length, bool fromUlp)
+{
+ // if this event is not called from ULP, then try to call into ULP and return if successfull
+ if (!fromUlp && !loc_nmea_is_debug(nmea, length)) {
+ if (mUlpProxy->reportNmea(nmea, length)) {
+ return;
+ }
+ }
+
+ struct MsgReportNmea : public LocMsg {
+ GnssAdapter& mAdapter;
+ const char* mNmea;
+ size_t mLength;
+ inline MsgReportNmea(GnssAdapter& adapter,
+ const char* nmea,
+ size_t length) :
+ LocMsg(),
+ mAdapter(adapter),
+ mNmea(new char[length+1]),
+ mLength(length) {
+ if (mNmea == nullptr) {
+ LOC_LOGE("%s] new allocation failed, fatal error.", __func__);
+ return;
+ }
+ strlcpy((char*)mNmea, nmea, length+1);
+ }
+ inline virtual ~MsgReportNmea()
+ {
+ delete[] mNmea;
+ }
+ inline virtual void proc() const {
+ // extract bug report info - this returns true if consumed by systemstatus
+ bool ret = false;
+ SystemStatus* s = mAdapter.getSystemStatus();
+ if (nullptr != s) {
+ ret = s->setNmeaString(mNmea, mLength);
+ }
+ if (false == ret) {
+ // forward NMEA message to upper layer
+ mAdapter.reportNmea(mNmea, mLength);
+ }
+ }
+ };
+
+ sendMsg(new MsgReportNmea(*this, nmea, length));
+}
+
+void
+GnssAdapter::reportNmea(const char* nmea, size_t length)
+{
+ GnssNmeaNotification nmeaNotification = {};
+ nmeaNotification.size = sizeof(GnssNmeaNotification);
+
+ struct timeval tv;
+ gettimeofday(&tv, (struct timezone *) NULL);
+ int64_t now = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
+ nmeaNotification.timestamp = now;
+ nmeaNotification.nmea = nmea;
+ nmeaNotification.length = length;
+
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.gnssNmeaCb) {
+ it->second.gnssNmeaCb(nmeaNotification);
+ }
+ }
+}
+
+bool
+GnssAdapter::requestNiNotifyEvent(const GnssNiNotification &notify, const void* data)
+{
+ LOC_LOGI("%s]: notif_type: %d, timeout: %d, default_resp: %d"
+ "requestor_id: %s (encoding: %d) text: %s text (encoding: %d) extras: %s",
+ __func__, notify.type, notify.timeout, notify.timeoutResponse,
+ notify.requestor, notify.requestorEncoding,
+ notify.message, notify.messageEncoding, notify.extras);
+
+ struct MsgReportNiNotify : public LocMsg {
+ GnssAdapter& mAdapter;
+ const GnssNiNotification mNotify;
+ const void* mData;
+ inline MsgReportNiNotify(GnssAdapter& adapter,
+ const GnssNiNotification& notify,
+ const void* data) :
+ LocMsg(),
+ mAdapter(adapter),
+ mNotify(notify),
+ mData(data) {}
+ inline virtual void proc() const {
+ mAdapter.requestNiNotify(mNotify, mData);
+ }
+ };
+
+ sendMsg(new MsgReportNiNotify(*this, notify, data));
+
+ return true;
+}
+
+static void* niThreadProc(void *args)
+{
+ NiSession* pSession = (NiSession*)args;
+ int rc = 0; /* return code from pthread calls */
+
+ struct timeval present_time;
+ struct timespec expire_time;
+
+ pthread_mutex_lock(&pSession->tLock);
+ /* Calculate absolute expire time */
+ gettimeofday(&present_time, NULL);
+ expire_time.tv_sec = present_time.tv_sec + pSession->respTimeLeft;
+ expire_time.tv_nsec = present_time.tv_usec * 1000;
+ LOC_LOGD("%s]: time out set for abs time %ld with delay %d sec",
+ __func__, (long)expire_time.tv_sec, pSession->respTimeLeft);
+
+ while (!pSession->respRecvd) {
+ rc = pthread_cond_timedwait(&pSession->tCond,
+ &pSession->tLock,
+ &expire_time);
+ if (rc == ETIMEDOUT) {
+ pSession->resp = GNSS_NI_RESPONSE_NO_RESPONSE;
+ LOC_LOGD("%s]: time out after valting for specified time. Ret Val %d",
+ __func__, rc);
+ break;
+ }
+ }
+ LOC_LOGD("%s]: Java layer has sent us a user response and return value from "
+ "pthread_cond_timedwait = %d pSession->resp is %u", __func__, rc, pSession->resp);
+ pSession->respRecvd = false; /* Reset the user response flag for the next session*/
+
+ // adding this check to support modem restart, in which case, we need the thread
+ // to exit without calling sending data. We made sure that rawRequest is NULL in
+ // loc_eng_ni_reset_on_engine_restart()
+ GnssAdapter* adapter = pSession->adapter;
+ GnssNiResponse resp;
+ void* rawRequest = NULL;
+ bool sendResponse = false;
+
+ if (NULL != pSession->rawRequest) {
+ if (pSession->resp != GNSS_NI_RESPONSE_IGNORE) {
+ resp = pSession->resp;
+ rawRequest = pSession->rawRequest;
+ sendResponse = true;
+ } else {
+ free(pSession->rawRequest);
+ }
+ pSession->rawRequest = NULL;
+ }
+ pthread_mutex_unlock(&pSession->tLock);
+
+ pSession->respTimeLeft = 0;
+ pSession->reqID = 0;
+
+ if (sendResponse) {
+ adapter->gnssNiResponseCommand(resp, rawRequest);
+ }
+
+ return NULL;
+}
+
+bool
+GnssAdapter::requestNiNotify(const GnssNiNotification& notify, const void* data)
+{
+ NiSession* pSession = NULL;
+ gnssNiCallback gnssNiCb = nullptr;
+
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.gnssNiCb) {
+ gnssNiCb = it->second.gnssNiCb;
+ break;
+ }
+ }
+ if (nullptr == gnssNiCb) {
+ EXIT_LOG(%s, "no clients with gnssNiCb.");
+ return false;
+ }
+
+ if (notify.type == GNSS_NI_TYPE_EMERGENCY_SUPL) {
+ if (NULL != mNiData.sessionEs.rawRequest) {
+ LOC_LOGI("%s]: supl es NI in progress, new supl es NI ignored, type: %d",
+ __func__, notify.type);
+ if (NULL != data) {
+ free((void*)data);
+ }
+ } else {
+ pSession = &mNiData.sessionEs;
+ }
+ } else {
+ if (NULL != mNiData.session.rawRequest ||
+ NULL != mNiData.sessionEs.rawRequest) {
+ LOC_LOGI("%s]: supl NI in progress, new supl NI ignored, type: %d",
+ __func__, notify.type);
+ if (NULL != data) {
+ free((void*)data);
+ }
+ } else {
+ pSession = &mNiData.session;
+ }
+ }
+
+ if (pSession) {
+ /* Save request */
+ pSession->rawRequest = (void*)data;
+ pSession->reqID = ++mNiData.reqIDCounter;
+ pSession->adapter = this;
+
+ int sessionId = pSession->reqID;
+
+ /* For robustness, spawn a thread at this point to timeout to clear up the notification
+ * status, even though the OEM layer in java does not do so.
+ **/
+ pSession->respTimeLeft =
+ 5 + (notify.timeout != 0 ? notify.timeout : LOC_NI_NO_RESPONSE_TIME);
+
+ int rc = 0;
+ rc = pthread_create(&pSession->thread, NULL, niThreadProc, pSession);
+ if (rc) {
+ LOC_LOGE("%s]: Loc NI thread is not created.", __func__);
+ }
+ rc = pthread_detach(pSession->thread);
+ if (rc) {
+ LOC_LOGE("%s]: Loc NI thread is not detached.", __func__);
+ }
+
+ if (nullptr != gnssNiCb) {
+ gnssNiCb(sessionId, notify);
+ }
+ }
+
+ return true;
+}
+
+void
+GnssAdapter::reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurements,
+ int msInWeek)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgReportGnssMeasurementData : public LocMsg {
+ GnssAdapter& mAdapter;
+ GnssMeasurementsNotification mMeasurementsNotify;
+ inline MsgReportGnssMeasurementData(GnssAdapter& adapter,
+ const GnssMeasurementsNotification& measurements,
+ int msInWeek) :
+ LocMsg(),
+ mAdapter(adapter),
+ mMeasurementsNotify(measurements) {
+ if (-1 != msInWeek) {
+ mAdapter.getAgcInformation(mMeasurementsNotify, msInWeek);
+ }
+ }
+ inline virtual void proc() const {
+ mAdapter.reportGnssMeasurementData(mMeasurementsNotify);
+ }
+ };
+
+ sendMsg(new MsgReportGnssMeasurementData(*this, measurements, msInWeek));
+}
+
+void
+GnssAdapter::reportGnssMeasurementData(const GnssMeasurementsNotification& measurements)
+{
+ for (auto it=mClientData.begin(); it != mClientData.end(); ++it) {
+ if (nullptr != it->second.gnssMeasurementsCb) {
+ it->second.gnssMeasurementsCb(measurements);
+ }
+ }
+}
+
+void
+GnssAdapter::reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary.
+ mUlpProxy->reportSvMeasurement(svMeasurementSet);
+}
+
+void
+GnssAdapter::reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ // We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary.
+ mUlpProxy->reportSvPolynomial(svPolynomial);
+}
+
+void GnssAdapter::initDefaultAgps() {
+ LOC_LOGD("%s]: ", __func__);
+
+ LocationCapabilitiesMask mask = getCapabilities();
+ if (!(mask & LOCATION_CAPABILITIES_GNSS_MSB_BIT) &&
+ !(mask & LOCATION_CAPABILITIES_GNSS_MSA_BIT)) {
+ LOC_LOGI("%s]: Target does not support MSB and MSA.", __func__);
+ return;
+ }
+
+ void *handle = nullptr;
+ if ((handle = dlopen("libloc_net_iface.so", RTLD_NOW)) == nullptr) {
+ LOC_LOGE("%s]: libloc_net_iface.so not found !", __func__);
+ return;
+ }
+
+ LocAgpsGetAgpsCbInfo getAgpsCbInfo = (LocAgpsGetAgpsCbInfo)
+ dlsym(handle, "LocNetIfaceAgps_getAgpsCbInfo");
+ if (getAgpsCbInfo == nullptr) {
+ LOC_LOGE("%s]: Failed to get method LocNetIfaceAgps_getStatusCb", __func__);
+ return;
+ }
+
+ AgpsCbInfo& cbInfo = getAgpsCbInfo(agpsOpenResultCb, agpsCloseResultCb, this);
+
+ if (cbInfo.statusV4Cb == nullptr) {
+ LOC_LOGE("%s]: statusV4Cb is nullptr!", __func__);
+ return;
+ }
+
+ initAgpsCommand(cbInfo);
+}
+
+void GnssAdapter::initDefaultAgpsCommand() {
+ LOC_LOGD("%s]: ", __func__);
+
+ struct MsgInitDefaultAgps : public LocMsg {
+ GnssAdapter& mAdapter;
+ inline MsgInitDefaultAgps(GnssAdapter& adapter) :
+ LocMsg(),
+ mAdapter(adapter) {
+ LOC_LOGV("MsgInitDefaultAgps");
+ }
+ inline virtual void proc() const {
+ mAdapter.initDefaultAgps();
+ }
+ };
+
+ sendMsg(new MsgInitDefaultAgps(*this));
+}
+
+/* INIT LOC AGPS MANAGER */
+void GnssAdapter::initAgpsCommand(const AgpsCbInfo& cbInfo){
+
+ LOC_LOGI("GnssAdapter::initAgpsCommand");
+
+ /* Set ATL open/close callbacks */
+ AgpsAtlOpenStatusCb atlOpenStatusCb =
+ [this](int handle, int isSuccess, char* apn,
+ AGpsBearerType bearerType, AGpsExtType agpsType) {
+
+ mLocApi->atlOpenStatus(
+ handle, isSuccess, apn, bearerType, agpsType);
+ };
+ AgpsAtlCloseStatusCb atlCloseStatusCb =
+ [this](int handle, int isSuccess) {
+
+ mLocApi->atlCloseStatus(handle, isSuccess);
+ };
+
+ /* Register DS Client APIs */
+ AgpsDSClientInitFn dsClientInitFn =
+ [this](bool isDueToSSR) {
+
+ return mLocApi->initDataServiceClient(isDueToSSR);
+ };
+
+ AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn =
+ [this] {
+
+ return mLocApi->openAndStartDataCall();
+ };
+
+ AgpsDSClientStopDataCallFn dsClientStopDataCallFn =
+ [this] {
+
+ mLocApi->stopDataCall();
+ };
+
+ AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn =
+ [this] {
+
+ mLocApi->closeDataCall();
+ };
+
+ AgpsDSClientReleaseFn dsClientReleaseFn =
+ [this] {
+
+ mLocApi->releaseDataServiceClient();
+ };
+
+ /* Send Msg function */
+ SendMsgToAdapterMsgQueueFn sendMsgFn =
+ [this](LocMsg* msg) {
+
+ sendMsg(msg);
+ };
+
+ /* Message to initialize AGPS module */
+ struct AgpsMsgInit: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+
+ AgnssStatusIpV4Cb mFrameworkStatusV4Cb;
+
+ AgpsAtlOpenStatusCb mAtlOpenStatusCb;
+ AgpsAtlCloseStatusCb mAtlCloseStatusCb;
+
+ AgpsDSClientInitFn mDSClientInitFn;
+ AgpsDSClientOpenAndStartDataCallFn mDSClientOpenAndStartDataCallFn;
+ AgpsDSClientStopDataCallFn mDSClientStopDataCallFn;
+ AgpsDSClientCloseDataCallFn mDSClientCloseDataCallFn;
+ AgpsDSClientReleaseFn mDSClientReleaseFn;
+
+ SendMsgToAdapterMsgQueueFn mSendMsgFn;
+ GnssAdapter& mAdapter;
+
+ inline AgpsMsgInit(AgpsManager* agpsManager,
+ AgnssStatusIpV4Cb frameworkStatusV4Cb,
+ AgpsAtlOpenStatusCb atlOpenStatusCb,
+ AgpsAtlCloseStatusCb atlCloseStatusCb,
+ AgpsDSClientInitFn dsClientInitFn,
+ AgpsDSClientOpenAndStartDataCallFn dsClientOpenAndStartDataCallFn,
+ AgpsDSClientStopDataCallFn dsClientStopDataCallFn,
+ AgpsDSClientCloseDataCallFn dsClientCloseDataCallFn,
+ AgpsDSClientReleaseFn dsClientReleaseFn,
+ SendMsgToAdapterMsgQueueFn sendMsgFn,
+ GnssAdapter& adapter) :
+ LocMsg(), mAgpsManager(agpsManager), mFrameworkStatusV4Cb(
+ frameworkStatusV4Cb), mAtlOpenStatusCb(atlOpenStatusCb), mAtlCloseStatusCb(
+ atlCloseStatusCb), mDSClientInitFn(dsClientInitFn), mDSClientOpenAndStartDataCallFn(
+ dsClientOpenAndStartDataCallFn), mDSClientStopDataCallFn(
+ dsClientStopDataCallFn), mDSClientCloseDataCallFn(
+ dsClientCloseDataCallFn), mDSClientReleaseFn(
+ dsClientReleaseFn), mSendMsgFn(sendMsgFn),
+ mAdapter(adapter) {
+
+ LOC_LOGV("AgpsMsgInit");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgInit::proc()");
+
+ mAgpsManager->registerCallbacks(mFrameworkStatusV4Cb, mAtlOpenStatusCb,
+ mAtlCloseStatusCb, mDSClientInitFn,
+ mDSClientOpenAndStartDataCallFn, mDSClientStopDataCallFn,
+ mDSClientCloseDataCallFn, mDSClientReleaseFn, mSendMsgFn);
+
+ mAgpsManager->createAgpsStateMachines();
+
+ /* Register for AGPS event mask */
+ mAdapter.updateEvtMask(LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST,
+ LOC_REGISTRATION_MASK_ENABLED);
+ }
+ };
+
+ if (mAgpsCbInfo.cbPriority > cbInfo.cbPriority) {
+ LOC_LOGI("Higher priority AGPS CB already registered (%d > %d) !",
+ mAgpsCbInfo.cbPriority, cbInfo.cbPriority);
+ return;
+ } else {
+ mAgpsCbInfo = cbInfo;
+ LOC_LOGI("Registering AGPS CB %p with priority %d",
+ mAgpsCbInfo.statusV4Cb, mAgpsCbInfo.cbPriority);
+ }
+
+ /* Send message to initialize AGPS Manager */
+ sendMsg(new AgpsMsgInit(
+ &mAgpsManager,
+ (AgnssStatusIpV4Cb)cbInfo.statusV4Cb,
+ atlOpenStatusCb, atlCloseStatusCb,
+ dsClientInitFn, dsClientOpenAndStartDataCallFn,
+ dsClientStopDataCallFn, dsClientCloseDataCallFn,
+ dsClientReleaseFn,
+ sendMsgFn,
+ *this));
+}
+
+/* GnssAdapter::requestATL
+ * Method triggered in QMI thread as part of handling below message:
+ * eQMI_LOC_SERVER_REQUEST_OPEN_V02
+ * Triggers the AGPS state machine to setup AGPS call for below WWAN types:
+ * eQMI_LOC_WWAN_TYPE_INTERNET_V02
+ * eQMI_LOC_WWAN_TYPE_AGNSS_V02 */
+bool GnssAdapter::requestATL(int connHandle, LocAGpsType agpsType){
+
+ LOC_LOGI("GnssAdapter::requestATL");
+
+ sendMsg( new AgpsMsgRequestATL(
+ &mAgpsManager, connHandle, (AGpsExtType)agpsType));
+
+ return true;
+}
+
+/* GnssAdapter::requestSuplES
+ * Method triggered in QMI thread as part of handling below message:
+ * eQMI_LOC_SERVER_REQUEST_OPEN_V02
+ * Triggers the AGPS state machine to setup AGPS call for below WWAN types:
+ * eQMI_LOC_WWAN_TYPE_AGNSS_EMERGENCY_V02 */
+bool GnssAdapter::requestSuplES(int connHandle){
+
+ LOC_LOGI("GnssAdapter::requestSuplES");
+
+ sendMsg( new AgpsMsgRequestATL(
+ &mAgpsManager, connHandle, LOC_AGPS_TYPE_SUPL_ES));
+
+ return true;
+}
+
+/* GnssAdapter::releaseATL
+ * Method triggered in QMI thread as part of handling below message:
+ * eQMI_LOC_SERVER_REQUEST_CLOSE_V02
+ * Triggers teardown of an existing AGPS call */
+bool GnssAdapter::releaseATL(int connHandle){
+
+ LOC_LOGI("GnssAdapter::releaseATL");
+
+ /* Release SUPL/INTERNET/SUPL_ES ATL */
+ struct AgpsMsgReleaseATL: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+ int mConnHandle;
+
+ inline AgpsMsgReleaseATL(AgpsManager* agpsManager, int connHandle) :
+ LocMsg(), mAgpsManager(agpsManager), mConnHandle(connHandle) {
+
+ LOC_LOGV("AgpsMsgReleaseATL");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgReleaseATL::proc()");
+ mAgpsManager->releaseATL(mConnHandle);
+ }
+ };
+
+ sendMsg( new AgpsMsgReleaseATL(&mAgpsManager, connHandle));
+
+ return true;
+}
+
+/* GnssAdapter::reportDataCallOpened
+ * DS Client data call opened successfully.
+ * Send message to AGPS Manager to handle. */
+bool GnssAdapter::reportDataCallOpened(){
+
+ LOC_LOGI("GnssAdapter::reportDataCallOpened");
+
+ struct AgpsMsgSuplEsOpened: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+
+ inline AgpsMsgSuplEsOpened(AgpsManager* agpsManager) :
+ LocMsg(), mAgpsManager(agpsManager) {
+
+ LOC_LOGV("AgpsMsgSuplEsOpened");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgSuplEsOpened::proc()");
+ mAgpsManager->reportDataCallOpened();
+ }
+ };
+
+ sendMsg( new AgpsMsgSuplEsOpened(&mAgpsManager));
+
+ return true;
+}
+
+/* GnssAdapter::reportDataCallClosed
+ * DS Client data call closed.
+ * Send message to AGPS Manager to handle. */
+bool GnssAdapter::reportDataCallClosed(){
+
+ LOC_LOGI("GnssAdapter::reportDataCallClosed");
+
+ struct AgpsMsgSuplEsClosed: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+
+ inline AgpsMsgSuplEsClosed(AgpsManager* agpsManager) :
+ LocMsg(), mAgpsManager(agpsManager) {
+
+ LOC_LOGV("AgpsMsgSuplEsClosed");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgSuplEsClosed::proc()");
+ mAgpsManager->reportDataCallClosed();
+ }
+ };
+
+ sendMsg( new AgpsMsgSuplEsClosed(&mAgpsManager));
+
+ return true;
+}
+
+void GnssAdapter::dataConnOpenCommand(
+ AGpsExtType agpsType,
+ const char* apnName, int apnLen, AGpsBearerType bearerType){
+
+ LOC_LOGI("GnssAdapter::frameworkDataConnOpen");
+
+ struct AgpsMsgAtlOpenSuccess: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+ AGpsExtType mAgpsType;
+ char* mApnName;
+ int mApnLen;
+ AGpsBearerType mBearerType;
+
+ inline AgpsMsgAtlOpenSuccess(AgpsManager* agpsManager, AGpsExtType agpsType,
+ const char* apnName, int apnLen, AGpsBearerType bearerType) :
+ LocMsg(), mAgpsManager(agpsManager), mAgpsType(agpsType), mApnName(
+ new char[apnLen + 1]), mApnLen(apnLen), mBearerType(bearerType) {
+
+ LOC_LOGV("AgpsMsgAtlOpenSuccess");
+ if (mApnName == nullptr) {
+ LOC_LOGE("%s] new allocation failed, fatal error.", __func__);
+ return;
+ }
+ memcpy(mApnName, apnName, apnLen);
+ mApnName[apnLen] = 0;
+ }
+
+ inline ~AgpsMsgAtlOpenSuccess() {
+ delete[] mApnName;
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgAtlOpenSuccess::proc()");
+ mAgpsManager->reportAtlOpenSuccess(mAgpsType, mApnName, mApnLen, mBearerType);
+ }
+ };
+
+ sendMsg( new AgpsMsgAtlOpenSuccess(
+ &mAgpsManager, agpsType, apnName, apnLen, bearerType));
+}
+
+void GnssAdapter::dataConnClosedCommand(AGpsExtType agpsType){
+
+ LOC_LOGI("GnssAdapter::frameworkDataConnClosed");
+
+ struct AgpsMsgAtlClosed: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+ AGpsExtType mAgpsType;
+
+ inline AgpsMsgAtlClosed(AgpsManager* agpsManager, AGpsExtType agpsType) :
+ LocMsg(), mAgpsManager(agpsManager), mAgpsType(agpsType) {
+
+ LOC_LOGV("AgpsMsgAtlClosed");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgAtlClosed::proc()");
+ mAgpsManager->reportAtlClosed(mAgpsType);
+ }
+ };
+
+ sendMsg( new AgpsMsgAtlClosed(&mAgpsManager, (AGpsExtType)agpsType));
+}
+
+void GnssAdapter::dataConnFailedCommand(AGpsExtType agpsType){
+
+ LOC_LOGI("GnssAdapter::frameworkDataConnFailed");
+
+ struct AgpsMsgAtlOpenFailed: public LocMsg {
+
+ AgpsManager* mAgpsManager;
+ AGpsExtType mAgpsType;
+
+ inline AgpsMsgAtlOpenFailed(AgpsManager* agpsManager, AGpsExtType agpsType) :
+ LocMsg(), mAgpsManager(agpsManager), mAgpsType(agpsType) {
+
+ LOC_LOGV("AgpsMsgAtlOpenFailed");
+ }
+
+ inline virtual void proc() const {
+
+ LOC_LOGV("AgpsMsgAtlOpenFailed::proc()");
+ mAgpsManager->reportAtlOpenFailed(mAgpsType);
+ }
+ };
+
+ sendMsg( new AgpsMsgAtlOpenFailed(&mAgpsManager, (AGpsExtType)agpsType));
+}
+
+void GnssAdapter::convertSatelliteInfo(std::vector<GnssDebugSatelliteInfo>& out,
+ const GnssSvType& in_constellation,
+ const SystemStatusReports& in)
+{
+ uint64_t sv_mask = 0ULL;
+ uint32_t svid_min = 0;
+ uint32_t svid_num = 0;
+ uint32_t svid_idx = 0;
+
+ uint64_t eph_health_good_mask = 0ULL;
+ uint64_t eph_health_bad_mask = 0ULL;
+ uint64_t server_perdiction_available_mask = 0ULL;
+ float server_perdiction_age = 0.0f;
+
+ // set constellationi based parameters
+ switch (in_constellation) {
+ case GNSS_SV_TYPE_GPS:
+ svid_min = GNSS_BUGREPORT_GPS_MIN;
+ svid_num = GPS_NUM;
+ svid_idx = 0;
+ if (!in.mSvHealth.empty()) {
+ eph_health_good_mask = in.mSvHealth.back().mGpsGoodMask;
+ eph_health_bad_mask = in.mSvHealth.back().mGpsBadMask;
+ }
+ if (!in.mXtra.empty()) {
+ server_perdiction_available_mask = in.mXtra.back().mGpsXtraValid;
+ server_perdiction_age = (float)(in.mXtra.back().mGpsXtraAge);
+ }
+ break;
+ case GNSS_SV_TYPE_GLONASS:
+ svid_min = GNSS_BUGREPORT_GLO_MIN;
+ svid_num = GLO_NUM;
+ svid_idx = GPS_NUM;
+ if (!in.mSvHealth.empty()) {
+ eph_health_good_mask = in.mSvHealth.back().mGloGoodMask;
+ eph_health_bad_mask = in.mSvHealth.back().mGloBadMask;
+ }
+ if (!in.mXtra.empty()) {
+ server_perdiction_available_mask = in.mXtra.back().mGloXtraValid;
+ server_perdiction_age = (float)(in.mXtra.back().mGloXtraAge);
+ }
+ break;
+ case GNSS_SV_TYPE_QZSS:
+ svid_min = GNSS_BUGREPORT_QZSS_MIN;
+ svid_num = QZSS_NUM;
+ svid_idx = GPS_NUM+GLO_NUM+BDS_NUM+GAL_NUM;
+ if (!in.mSvHealth.empty()) {
+ eph_health_good_mask = in.mSvHealth.back().mQzssGoodMask;
+ eph_health_bad_mask = in.mSvHealth.back().mQzssBadMask;
+ }
+ if (!in.mXtra.empty()) {
+ server_perdiction_available_mask = in.mXtra.back().mQzssXtraValid;
+ server_perdiction_age = (float)(in.mXtra.back().mQzssXtraAge);
+ }
+ break;
+ case GNSS_SV_TYPE_BEIDOU:
+ svid_min = GNSS_BUGREPORT_BDS_MIN;
+ svid_num = BDS_NUM;
+ svid_idx = GPS_NUM+GLO_NUM;
+ if (!in.mSvHealth.empty()) {
+ eph_health_good_mask = in.mSvHealth.back().mBdsGoodMask;
+ eph_health_bad_mask = in.mSvHealth.back().mBdsBadMask;
+ }
+ if (!in.mXtra.empty()) {
+ server_perdiction_available_mask = in.mXtra.back().mBdsXtraValid;
+ server_perdiction_age = (float)(in.mXtra.back().mBdsXtraAge);
+ }
+ break;
+ case GNSS_SV_TYPE_GALILEO:
+ svid_min = GNSS_BUGREPORT_GAL_MIN;
+ svid_num = GAL_NUM;
+ svid_idx = GPS_NUM+GLO_NUM+BDS_NUM;
+ if (!in.mSvHealth.empty()) {
+ eph_health_good_mask = in.mSvHealth.back().mGalGoodMask;
+ eph_health_bad_mask = in.mSvHealth.back().mGalBadMask;
+ }
+ if (!in.mXtra.empty()) {
+ server_perdiction_available_mask = in.mXtra.back().mGalXtraValid;
+ server_perdiction_age = (float)(in.mXtra.back().mGalXtraAge);
+ }
+ break;
+ default:
+ return;
+ }
+
+ // extract each sv info from systemstatus report
+ for(uint32_t i=0; i<svid_num && (svid_idx+i)<SV_ALL_NUM; i++) {
+
+ GnssDebugSatelliteInfo s = {};
+ s.size = sizeof(s);
+ s.svid = i + svid_min;
+ s.constellation = in_constellation;
+
+ if (!in.mNavData.empty()) {
+ s.mEphemerisType = in.mNavData.back().mNav[svid_idx+i].mType;
+ s.mEphemerisSource = in.mNavData.back().mNav[svid_idx+i].mSource;
+ }
+ else {
+ s.mEphemerisType = GNSS_EPH_TYPE_UNKNOWN;
+ s.mEphemerisSource = GNSS_EPH_SOURCE_UNKNOWN;
+ }
+
+ sv_mask = 0x1ULL << i;
+ if (eph_health_good_mask & sv_mask) {
+ s.mEphemerisHealth = GNSS_EPH_HEALTH_GOOD;
+ }
+ else if (eph_health_bad_mask & sv_mask) {
+ s.mEphemerisHealth = GNSS_EPH_HEALTH_BAD;
+ }
+ else {
+ s.mEphemerisHealth = GNSS_EPH_HEALTH_UNKNOWN;
+ }
+
+ if (!in.mNavData.empty()) {
+ s.ephemerisAgeSeconds =
+ (float)(in.mNavData.back().mNav[svid_idx+i].mAgeSec);
+ }
+ else {
+ s.ephemerisAgeSeconds = 0.0f;
+ }
+
+ if (server_perdiction_available_mask & sv_mask) {
+ s.serverPredictionIsAvailable = true;
+ }
+ else {
+ s.serverPredictionIsAvailable = false;
+ }
+
+ s.serverPredictionAgeSeconds = server_perdiction_age;
+ out.push_back(s);
+ }
+
+ return;
+}
+
+bool GnssAdapter::getDebugReport(GnssDebugReport& r)
+{
+ LOC_LOGD("%s]: ", __func__);
+
+ SystemStatus* systemstatus = getSystemStatus();
+ if (nullptr == systemstatus) {
+ return false;
+ }
+
+ SystemStatusReports reports = {};
+ systemstatus->getReport(reports, true);
+
+ r.size = sizeof(r);
+
+ // location block
+ r.mLocation.size = sizeof(r.mLocation);
+ if(!reports.mLocation.empty() && reports.mLocation.back().mValid) {
+ r.mLocation.mValid = true;
+ r.mLocation.mLocation.latitude =
+ reports.mLocation.back().mLocation.gpsLocation.latitude;
+ r.mLocation.mLocation.longitude =
+ reports.mLocation.back().mLocation.gpsLocation.longitude;
+ r.mLocation.mLocation.altitude =
+ reports.mLocation.back().mLocation.gpsLocation.altitude;
+ r.mLocation.mLocation.speed =
+ (double)(reports.mLocation.back().mLocation.gpsLocation.speed);
+ r.mLocation.mLocation.bearing =
+ (double)(reports.mLocation.back().mLocation.gpsLocation.bearing);
+ r.mLocation.mLocation.accuracy =
+ (double)(reports.mLocation.back().mLocation.gpsLocation.accuracy);
+
+ r.mLocation.verticalAccuracyMeters =
+ reports.mLocation.back().mLocationEx.vert_unc;
+ r.mLocation.speedAccuracyMetersPerSecond =
+ reports.mLocation.back().mLocationEx.speed_unc;
+ r.mLocation.bearingAccuracyDegrees =
+ reports.mLocation.back().mLocationEx.bearing_unc;
+
+ r.mLocation.mUtcReported =
+ reports.mLocation.back().mUtcReported;
+ }
+ else if(!reports.mBestPosition.empty() && reports.mBestPosition.back().mValid) {
+ r.mLocation.mValid = true;
+ r.mLocation.mLocation.latitude =
+ (double)(reports.mBestPosition.back().mBestLat) * RAD2DEG;
+ r.mLocation.mLocation.longitude =
+ (double)(reports.mBestPosition.back().mBestLon) * RAD2DEG;
+ r.mLocation.mLocation.altitude = reports.mBestPosition.back().mBestAlt;
+ r.mLocation.mUtcReported = reports.mBestPosition.back().mUtcReported;
+ }
+ else {
+ r.mLocation.mValid = false;
+ }
+
+ if (r.mLocation.mValid) {
+ LOC_LOGV("getDebugReport - lat=%f lon=%f alt=%f speed=%f",
+ r.mLocation.mLocation.latitude,
+ r.mLocation.mLocation.longitude,
+ r.mLocation.mLocation.altitude,
+ r.mLocation.mLocation.speed);
+ }
+
+ // time block
+ r.mTime.size = sizeof(r.mTime);
+ if(!reports.mTimeAndClock.empty() && reports.mTimeAndClock.back().mTimeValid) {
+ r.mTime.mValid = true;
+ r.mTime.timeEstimate =
+ (((int64_t)(reports.mTimeAndClock.back().mGpsWeek)*7 +
+ GNSS_UTC_TIME_OFFSET)*24*60*60 -
+ (int64_t)(reports.mTimeAndClock.back().mLeapSeconds))*1000ULL +
+ (int64_t)(reports.mTimeAndClock.back().mGpsTowMs);
+
+ r.mTime.timeUncertaintyNs =
+ (float)((reports.mTimeAndClock.back().mTimeUnc +
+ reports.mTimeAndClock.back().mLeapSecUnc)*1000);
+ r.mTime.frequencyUncertaintyNsPerSec =
+ (float)(reports.mTimeAndClock.back().mClockFreqBiasUnc);
+ LOC_LOGV("getDebugReport - timeestimate=%" PRIu64 " unc=%f frequnc=%f",
+ r.mTime.timeEstimate,
+ r.mTime.timeUncertaintyNs, r.mTime.frequencyUncertaintyNsPerSec);
+ }
+ else {
+ r.mTime.mValid = false;
+ }
+
+ // satellite info block
+ convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_GPS, reports);
+ convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_GLONASS, reports);
+ convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_QZSS, reports);
+ convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_BEIDOU, reports);
+ convertSatelliteInfo(r.mSatelliteInfo, GNSS_SV_TYPE_GALILEO, reports);
+ LOC_LOGV("getDebugReport - satellite=%zu", r.mSatelliteInfo.size());
+
+ return true;
+}
+
+/* get AGC information from system status and fill it */
+void
+GnssAdapter::getAgcInformation(GnssMeasurementsNotification& measurements, int msInWeek)
+{
+ SystemStatus* systemstatus = getSystemStatus();
+
+ if (nullptr != systemstatus) {
+ SystemStatusReports reports = {};
+ systemstatus->getReport(reports, true);
+
+ if ((!reports.mRfAndParams.empty()) && (!reports.mTimeAndClock.empty()) &&
+ reports.mTimeAndClock.back().mTimeValid &&
+ (abs(msInWeek - (int)reports.mTimeAndClock.back().mGpsTowMs) < 2000)) {
+
+ for (size_t i = 0; i < measurements.count; i++) {
+ switch (measurements.measurements[i].svType) {
+ case GNSS_SV_TYPE_GPS:
+ measurements.measurements[i].agcLevelDb =
+ reports.mRfAndParams.back().mAgcGps;
+ measurements.measurements[i].flags |=
+ GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT;
+ break;
+
+ case GNSS_SV_TYPE_GALILEO:
+ measurements.measurements[i].agcLevelDb =
+ reports.mRfAndParams.back().mAgcGal;
+ measurements.measurements[i].flags |=
+ GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT;
+ break;
+
+ case GNSS_SV_TYPE_GLONASS:
+ measurements.measurements[i].agcLevelDb =
+ reports.mRfAndParams.back().mAgcGlo;
+ measurements.measurements[i].flags |=
+ GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT;
+ break;
+
+ case GNSS_SV_TYPE_BEIDOU:
+ measurements.measurements[i].agcLevelDb =
+ reports.mRfAndParams.back().mAgcBds;
+ measurements.measurements[i].flags |=
+ GNSS_MEASUREMENTS_DATA_AUTOMATIC_GAIN_CONTROL_BIT;
+ break;
+
+ case GNSS_SV_TYPE_QZSS:
+ case GNSS_SV_TYPE_SBAS:
+ case GNSS_SV_TYPE_UNKNOWN:
+ default:
+ break;
+ }
+ }
+ }
+ }
+}
+
+/* Callbacks registered with loc_net_iface library */
+static void agpsOpenResultCb (bool isSuccess, AGpsExtType agpsType, const char* apn,
+ AGpsBearerType bearerType, void* userDataPtr) {
+ LOC_LOGD("%s]: ", __func__);
+ if (userDataPtr == nullptr) {
+ LOC_LOGE("%s]: userDataPtr is nullptr.", __func__);
+ return;
+ }
+ if (apn == nullptr) {
+ LOC_LOGE("%s]: apn is nullptr.", __func__);
+ return;
+ }
+ GnssAdapter* adapter = (GnssAdapter*)userDataPtr;
+ if (isSuccess) {
+ adapter->dataConnOpenCommand(agpsType, apn, strlen(apn), bearerType);
+ } else {
+ adapter->dataConnFailedCommand(agpsType);
+ }
+}
+
+static void agpsCloseResultCb (bool isSuccess, AGpsExtType agpsType, void* userDataPtr) {
+ LOC_LOGD("%s]: ", __func__);
+ if (userDataPtr == nullptr) {
+ LOC_LOGE("%s]: userDataPtr is nullptr.", __func__);
+ return;
+ }
+ GnssAdapter* adapter = (GnssAdapter*)userDataPtr;
+ if (isSuccess) {
+ adapter->dataConnClosedCommand(agpsType);
+ } else {
+ adapter->dataConnFailedCommand(agpsType);
+ }
+}
diff --git a/gps/gnss/GnssAdapter.h b/gps/gnss/GnssAdapter.h
new file mode 100644
index 0000000..e7605f9
--- /dev/null
+++ b/gps/gnss/GnssAdapter.h
@@ -0,0 +1,287 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ifndef GNSS_ADAPTER_H
+#define GNSS_ADAPTER_H
+
+#include <LocAdapterBase.h>
+#include <LocDualContext.h>
+#include <UlpProxyBase.h>
+#include <LocationAPI.h>
+#include <Agps.h>
+#include <SystemStatus.h>
+#include <XtraSystemStatusObserver.h>
+
+#define MAX_URL_LEN 256
+#define NMEA_SENTENCE_MAX_LENGTH 200
+#define GLONASS_SV_ID_OFFSET 64
+#define MAX_SATELLITES_IN_USE 12
+#define LOC_NI_NO_RESPONSE_TIME 20
+#define LOC_GPS_NI_RESPONSE_IGNORE 4
+
+class GnssAdapter;
+
+typedef struct {
+ pthread_t thread; /* NI thread */
+ uint32_t respTimeLeft; /* examine time for NI response */
+ bool respRecvd; /* NI User reponse received or not from Java layer*/
+ void* rawRequest;
+ uint32_t reqID; /* ID to check against response */
+ GnssNiResponse resp;
+ pthread_cond_t tCond;
+ pthread_mutex_t tLock;
+ GnssAdapter* adapter;
+} NiSession;
+typedef struct {
+ NiSession session; /* SUPL NI Session */
+ NiSession sessionEs; /* Emergency SUPL NI Session */
+ uint32_t reqIDCounter;
+} NiData;
+
+typedef enum {
+ NMEA_PROVIDER_AP = 0, // Application Processor Provider of NMEA
+ NMEA_PROVIDER_MP // Modem Processor Provider of NMEA
+} NmeaProviderType;
+typedef struct {
+ GnssSvType svType;
+ const char* talker;
+ uint64_t mask;
+ uint32_t svIdOffset;
+} NmeaSvMeta;
+
+using namespace loc_core;
+
+namespace loc_core {
+ class SystemStatus;
+}
+
+class GnssAdapter : public LocAdapterBase {
+ /* ==== ULP ============================================================================ */
+ UlpProxyBase* mUlpProxy;
+
+ /* ==== CLIENT ========================================================================= */
+ typedef std::map<LocationAPI*, LocationCallbacks> ClientDataMap;
+ ClientDataMap mClientData;
+
+ /* ==== TRACKING ======================================================================= */
+ LocationSessionMap mTrackingSessions;
+ LocPosMode mUlpPositionMode;
+ GnssSvUsedInPosition mGnssSvIdUsedInPosition;
+ bool mGnssSvIdUsedInPosAvail;
+
+ /* ==== CONTROL ======================================================================== */
+ LocationControlCallbacks mControlCallbacks;
+ uint32_t mPowerVoteId;
+ uint32_t mNmeaMask;
+
+ /* ==== NI ============================================================================= */
+ NiData mNiData;
+
+ /* ==== AGPS ========================================================*/
+ // This must be initialized via initAgps()
+ AgpsManager mAgpsManager;
+ AgpsCbInfo mAgpsCbInfo;
+
+ /* === SystemStatus ===================================================================== */
+ SystemStatus* mSystemStatus;
+ std::string mServerUrl;
+ XtraSystemStatusObserver mXtraObserver;
+
+ /*==== CONVERSION ===================================================================*/
+ static void convertOptions(LocPosMode& out, const LocationOptions& options);
+ static void convertLocation(Location& out, const LocGpsLocation& locGpsLocation,
+ const GpsLocationExtended& locationExtended,
+ const LocPosTechMask techMask);
+ static void convertLocationInfo(GnssLocationInfoNotification& out,
+ const GpsLocationExtended& locationExtended);
+
+public:
+
+ GnssAdapter();
+ virtual inline ~GnssAdapter() { delete mUlpProxy; }
+
+ /* ==== SSR ============================================================================ */
+ /* ======== EVENTS ====(Called from QMI Thread)========================================= */
+ virtual void handleEngineUpEvent();
+ /* ======== UTILITIES ================================================================== */
+ void restartSessions();
+
+ /* ==== ULP ============================================================================ */
+ /* ======== COMMANDS ====(Called from ULP Thread)==================================== */
+ virtual void setUlpProxyCommand(UlpProxyBase* ulp);
+ /* ======== UTILITIES ================================================================== */
+ void setUlpProxy(UlpProxyBase* ulp);
+ inline UlpProxyBase* getUlpProxy() { return mUlpProxy; }
+
+ /* ==== CLIENT ========================================================================= */
+ /* ======== COMMANDS ====(Called from Client Thread)==================================== */
+ void addClientCommand(LocationAPI* client, const LocationCallbacks& callbacks);
+ void removeClientCommand(LocationAPI* client);
+ void requestCapabilitiesCommand(LocationAPI* client);
+ /* ======== UTILITIES ================================================================== */
+ void saveClient(LocationAPI* client, const LocationCallbacks& callbacks);
+ void eraseClient(LocationAPI* client);
+ void updateClientsEventMask();
+ void stopClientSessions(LocationAPI* client);
+ LocationCallbacks getClientCallbacks(LocationAPI* client);
+ LocationCapabilitiesMask getCapabilities();
+ void broadcastCapabilities(LocationCapabilitiesMask);
+
+ /* ==== TRACKING ======================================================================= */
+ /* ======== COMMANDS ====(Called from Client Thread)==================================== */
+ uint32_t startTrackingCommand(LocationAPI* client, LocationOptions& options);
+ void updateTrackingOptionsCommand(LocationAPI* client, uint32_t id, LocationOptions& options);
+ void stopTrackingCommand(LocationAPI* client, uint32_t id);
+ /* ======================(Called from ULP Thread)======================================= */
+ virtual void setPositionModeCommand(LocPosMode& locPosMode);
+ virtual void startTrackingCommand();
+ virtual void stopTrackingCommand();
+ virtual void getZppCommand();
+ /* ======== RESPONSES ================================================================== */
+ void reportResponse(LocationAPI* client, LocationError err, uint32_t sessionId);
+ /* ======== UTILITIES ================================================================== */
+ bool hasTrackingCallback(LocationAPI* client);
+ bool hasMeasurementsCallback(LocationAPI* client);
+ bool isTrackingSession(LocationAPI* client, uint32_t sessionId);
+ void saveTrackingSession(LocationAPI* client, uint32_t sessionId,
+ const LocationOptions& options);
+ void eraseTrackingSession(LocationAPI* client, uint32_t sessionId);
+ bool setUlpPositionMode(const LocPosMode& mode);
+ LocPosMode& getUlpPositionMode() { return mUlpPositionMode; }
+ LocationError startTrackingMultiplex(const LocationOptions& options);
+ LocationError startTracking(const LocationOptions& options);
+ LocationError stopTrackingMultiplex(LocationAPI* client, uint32_t id);
+ LocationError stopTracking();
+ LocationError updateTrackingMultiplex(LocationAPI* client, uint32_t id,
+ const LocationOptions& options);
+
+ /* ==== NI ============================================================================= */
+ /* ======== COMMANDS ====(Called from Client Thread)==================================== */
+ void gnssNiResponseCommand(LocationAPI* client, uint32_t id, GnssNiResponse response);
+ /* ======================(Called from NI Thread)======================================== */
+ void gnssNiResponseCommand(GnssNiResponse response, void* rawRequest);
+ /* ======== UTILITIES ================================================================== */
+ bool hasNiNotifyCallback(LocationAPI* client);
+ NiData& getNiData() { return mNiData; }
+
+ /* ==== CONTROL ======================================================================== */
+ /* ======== COMMANDS ====(Called from Client Thread)==================================== */
+ uint32_t enableCommand(LocationTechnologyType techType);
+ void disableCommand(uint32_t id);
+ void setControlCallbacksCommand(LocationControlCallbacks& controlCallbacks);
+ void readConfigCommand();
+ void setConfigCommand();
+ uint32_t* gnssUpdateConfigCommand(GnssConfig config);
+ uint32_t gnssDeleteAidingDataCommand(GnssAidingData& data);
+
+ void initDefaultAgpsCommand();
+ void initAgpsCommand(const AgpsCbInfo& cbInfo);
+ void dataConnOpenCommand(AGpsExtType agpsType,
+ const char* apnName, int apnLen, AGpsBearerType bearerType);
+ void dataConnClosedCommand(AGpsExtType agpsType);
+ void dataConnFailedCommand(AGpsExtType agpsType);
+
+ /* ======== RESPONSES ================================================================== */
+ void reportResponse(LocationError err, uint32_t sessionId);
+ void reportResponse(size_t count, LocationError* errs, uint32_t* ids);
+ /* ======== UTILITIES ================================================================== */
+ LocationControlCallbacks& getControlCallbacks() { return mControlCallbacks; }
+ void setControlCallbacks(const LocationControlCallbacks& controlCallbacks)
+ { mControlCallbacks = controlCallbacks; }
+ void setPowerVoteId(uint32_t id) { mPowerVoteId = id; }
+ uint32_t getPowerVoteId() { return mPowerVoteId; }
+ bool resolveInAddress(const char* hostAddress, struct in_addr* inAddress);
+ virtual bool isInSession() { return !mTrackingSessions.empty(); }
+ void initDefaultAgps();
+
+ /* ==== REPORTS ======================================================================== */
+ /* ======== EVENTS ====(Called from QMI/ULP Thread)===================================== */
+ virtual void reportPositionEvent(const UlpLocation& ulpLocation,
+ const GpsLocationExtended& locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask techMask,
+ bool fromUlp=false);
+ virtual void reportSvEvent(const GnssSvNotification& svNotify, bool fromUlp=false);
+ virtual void reportNmeaEvent(const char* nmea, size_t length, bool fromUlp=false);
+ virtual bool requestNiNotifyEvent(const GnssNiNotification& notify, const void* data);
+ virtual void reportGnssMeasurementDataEvent(const GnssMeasurementsNotification& measurements,
+ int msInWeek);
+ virtual void reportSvMeasurementEvent(GnssSvMeasurementSet &svMeasurementSet);
+ virtual void reportSvPolynomialEvent(GnssSvPolynomial &svPolynomial);
+
+ virtual bool requestATL(int connHandle, LocAGpsType agps_type);
+ virtual bool releaseATL(int connHandle);
+ virtual bool requestSuplES(int connHandle);
+ virtual bool reportDataCallOpened();
+ virtual bool reportDataCallClosed();
+
+ /* ======== UTILITIES ================================================================= */
+ void reportPosition(const UlpLocation &ulpLocation,
+ const GpsLocationExtended &locationExtended,
+ enum loc_sess_status status,
+ LocPosTechMask techMask);
+ void reportSv(GnssSvNotification& svNotify);
+ void reportNmea(const char* nmea, size_t length);
+ bool requestNiNotify(const GnssNiNotification& notify, const void* data);
+ void reportGnssMeasurementData(const GnssMeasurementsNotification& measurements);
+
+ /*======== GNSSDEBUG ================================================================*/
+ bool getDebugReport(GnssDebugReport& report);
+ /* get AGC information from system status and fill it */
+ void getAgcInformation(GnssMeasurementsNotification& measurements, int msInWeek);
+
+ /*==== SYSTEM STATUS ================================================================*/
+ inline SystemStatus* getSystemStatus(void) { return mSystemStatus; }
+ std::string& getServerUrl(void) { return mServerUrl; }
+ void setServerUrl(const char* server) { mServerUrl.assign(server); }
+
+ /*==== CONVERSION ===================================================================*/
+ static uint32_t convertGpsLock(const GnssConfigGpsLock gpsLock);
+ static GnssConfigGpsLock convertGpsLock(const uint32_t gpsLock);
+ static uint32_t convertSuplVersion(const GnssConfigSuplVersion suplVersion);
+ static GnssConfigSuplVersion convertSuplVersion(const uint32_t suplVersion);
+ static uint32_t convertLppProfile(const GnssConfigLppProfile lppProfile);
+ static GnssConfigLppProfile convertLppProfile(const uint32_t lppProfile);
+ static uint32_t convertEP4ES(const GnssConfigEmergencyPdnForEmergencySupl);
+ static uint32_t convertSuplEs(const GnssConfigSuplEmergencyServices suplEmergencyServices);
+ static uint32_t convertLppeCp(const GnssConfigLppeControlPlaneMask lppeControlPlaneMask);
+ static GnssConfigLppeControlPlaneMask convertLppeCp(const uint32_t lppeControlPlaneMask);
+ static uint32_t convertLppeUp(const GnssConfigLppeUserPlaneMask lppeUserPlaneMask);
+ static GnssConfigLppeUserPlaneMask convertLppeUp(const uint32_t lppeUserPlaneMask);
+ static uint32_t convertAGloProt(const GnssConfigAGlonassPositionProtocolMask);
+ static uint32_t convertSuplMode(const GnssConfigSuplModeMask suplModeMask);
+ static void convertSatelliteInfo(std::vector<GnssDebugSatelliteInfo>& out,
+ const GnssSvType& in_constellation,
+ const SystemStatusReports& in);
+
+ void injectLocationCommand(double latitude, double longitude, float accuracy);
+ void injectTimeCommand(int64_t time, int64_t timeReference, int32_t uncertainty);
+
+};
+
+#endif //GNSS_ADAPTER_H
diff --git a/gps/gnss/Makefile.am b/gps/gnss/Makefile.am
new file mode 100644
index 0000000..3afdcd7
--- /dev/null
+++ b/gps/gnss/Makefile.am
@@ -0,0 +1,99 @@
+AM_CFLAGS = \
+ $(LOCPLA_CFLAGS) \
+ $(LOCHAL_CFLAGS) \
+ -I./ \
+ -I../utils \
+ -I../core \
+ -I../location \
+ -std=c++11
+
+libgnss_la_SOURCES = \
+ location_gnss.cpp \
+ GnssAdapter.cpp \
+ Agps.cpp
+
+if USE_GLIB
+libgnss_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) @GLIB_CFLAGS@
+libgnss_la_LDFLAGS = -lstdc++ -lpthread @GLIB_LIBS@ -shared -avoid-version
+libgnss_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
+else
+libgnss_la_CFLAGS = $(AM_CFLAGS)
+libgnss_la_LDFLAGS = -lpthread -shared -version-info 1:0:0
+libgnss_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS)
+endif
+
+libgnss_la_LIBADD = -lstdc++ $(LOCPLA_LIBS) $(LOCHAL_LIBS)
+
+
+#Create and Install libraries
+#lib_LTLIBRARIES = libgnss.la
+
+#library_includedir = $(pkgincludedir)
+#pkgconfigdir = $(libdir)/pkgconfig
+#pkgconfig_DATA = location-api.pc
+#EXTRA_DIST = $(pkgconfig_DATA)
+
+
+libloc_ds_api_CFLAGS = \
+ $(QMIF_CFLAGS) \
+ $(QMI_CFLAGS) \
+ $(DATA_CFLAGS) \
+ $(GPSUTILS_CFLAGS) \
+ -I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api
+
+libloc_ds_api_la_SOURCES = \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.c
+
+if USE_GLIB
+libloc_ds_api_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) @GLIB_CFLAGS@
+libloc_ds_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic
+libloc_ds_api_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_ds_api_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
+else
+libloc_ds_api_la_CFLAGS = $(AM_CFLAGS) $(libloc_ds_api_CFLAGS)
+libloc_ds_api_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -Wl,--export-dynamic -shared -version-info 1:0:0
+libloc_ds_api_la_LDFLAGS += -Wl,--export-dynamic
+libloc_ds_api_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_ds_api_CFLAGS)
+endif
+
+libloc_ds_api_la_LIBADD = -lstdc++ $(QMIF_LIBS) -lqmiservices -ldsi_netctrl $(GPSUTILS_LIBS) $(LOCPLA_LIBS)
+
+libloc_api_v02_CFLAGS = \
+ $(QMIF_CFLAGS) \
+ $(GPSUTILS_CFLAGS) \
+ -I$(WORKSPACE)/qcom-opensource/location/loc_api/ds_api \
+ -I$(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02
+
+libloc_api_v02_la_SOURCES = \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.cpp \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.c \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.c \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.c \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.c
+
+if USE_GLIB
+libloc_api_v02_la_CFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) @GLIB_CFLAGS@
+libloc_api_v02_la_LDFLAGS = -lstdc++ -g -Wl,-z,defs -lpthread @GLIB_LIBS@ -shared -version-info 1:0:0
+libloc_api_v02_la_CPPFLAGS = -DUSE_GLIB $(AM_CFLAGS) $(libloc_api_v02_CFLAGS) $(AM_CPPFLAGS) @GLIB_CFLAGS@
+else
+libloc_api_v02_la_CFLAGS = $(AM_CFLAGS) $(libloc_api_v02_CFLAGS)
+libloc_api_v02_la_LDFLAGS = -lstdc++ -Wl,-z,defs -lpthread -shared -version-info 1:0:0
+libloc_api_v02_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(libloc_api_v02_CFLAGS)
+endif
+
+libloc_api_v02_la_CXXFLAGS = -std=c++0x
+libloc_api_v02_la_LIBADD = -lstdc++ -lqmi_cci -lqmi_common_so $(QMIF_LIBS) $(GPSUTILS_LIBS) $(LOCPLA_LIBS) ../core/libloc_core.la libloc_ds_api.la
+
+library_include_HEADERS = \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/ds_api/ds_client.h \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/location_service_v02.h \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_log.h \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_v02_client.h \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_api_sync_req.h \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/LocApiV02.h \
+ $(WORKSPACE)/qcom-opensource/location/loc_api/loc_api_v02/loc_util_log.h
+
+library_includedir = $(pkgincludedir)
+
+#Create and Install libraries
+lib_LTLIBRARIES = libgnss.la libloc_ds_api.la libloc_api_v02.la
diff --git a/gps/gnss/XtraSystemStatusObserver.cpp b/gps/gnss/XtraSystemStatusObserver.cpp
new file mode 100644
index 0000000..2855c0d
--- /dev/null
+++ b/gps/gnss/XtraSystemStatusObserver.cpp
@@ -0,0 +1,237 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#define LOG_TAG "LocSvc_XtraSystemStatusObs"
+
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <errno.h>
+#include <ctype.h>
+#include <cutils/properties.h>
+#include <math.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <string>
+#include <loc_log.h>
+#include <loc_nmea.h>
+#include <SystemStatus.h>
+#include <vector>
+#include <sstream>
+#include <XtraSystemStatusObserver.h>
+#include <LocAdapterBase.h>
+#include <DataItemId.h>
+#include <DataItemsFactoryProxy.h>
+#include <DataItemConcreteTypesBase.h>
+
+using namespace loc_core;
+
+#define XTRA_HAL_SOCKET_NAME "/data/vendor/location/xtra/socket_hal_xtra"
+
+bool XtraSystemStatusObserver::updateLockStatus(uint32_t lock) {
+ stringstream ss;
+ ss << "gpslock";
+ ss << " " << lock;
+ ss << "\n"; // append seperator
+ return ( sendEvent(ss) );
+}
+
+bool XtraSystemStatusObserver::updateConnectionStatus(bool connected, uint32_t type) {
+ stringstream ss;
+ ss << "connection";
+ ss << " " << (connected ? "1" : "0");
+ ss << " " << (int)type;
+ ss << "\n"; // append seperator
+ return ( sendEvent(ss) );
+}
+bool XtraSystemStatusObserver::updateTac(const string& tac) {
+ stringstream ss;
+ ss << "tac";
+ ss << " " << tac.c_str();
+ ss << "\n"; // append seperator
+ return ( sendEvent(ss) );
+}
+
+bool XtraSystemStatusObserver::updateMccMnc(const string& mccmnc) {
+ stringstream ss;
+ ss << "mncmcc";
+ ss << " " << mccmnc.c_str();
+ ss << "\n"; // append seperator
+ return ( sendEvent(ss) );
+}
+
+bool XtraSystemStatusObserver::sendEvent(const stringstream& event) {
+ int socketFd = createSocket();
+ if (socketFd < 0) {
+ LOC_LOGe("XTRA unreachable. sending failed.");
+ return false;
+ }
+
+ const string& data = event.str();
+ int remain = data.length();
+ ssize_t sent = 0;
+ while (remain > 0 &&
+ (sent = ::send(socketFd, data.c_str() + (data.length() - remain),
+ remain, MSG_NOSIGNAL)) > 0) {
+ remain -= sent;
+ }
+
+ if (sent < 0) {
+ LOC_LOGe("sending error. reason:%s", strerror(errno));
+ }
+
+ closeSocket(socketFd);
+
+ return (remain == 0);
+}
+
+
+int XtraSystemStatusObserver::createSocket() {
+ int socketFd = -1;
+
+ if ((socketFd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
+ LOC_LOGe("create socket error. reason:%s", strerror(errno));
+
+ } else {
+ const char* socketPath = XTRA_HAL_SOCKET_NAME ;
+ struct sockaddr_un addr = { .sun_family = AF_UNIX };
+ snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socketPath);
+
+ if (::connect(socketFd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
+ LOC_LOGe("cannot connect to XTRA. reason:%s", strerror(errno));
+ if (::close(socketFd)) {
+ LOC_LOGe("close socket error. reason:%s", strerror(errno));
+ }
+ socketFd = -1;
+ }
+ }
+
+ return socketFd;
+}
+
+void XtraSystemStatusObserver::closeSocket(const int socketFd) {
+ if (socketFd >= 0) {
+ if(::close(socketFd)) {
+ LOC_LOGe("close socket error. reason:%s", strerror(errno));
+ }
+ }
+}
+
+void XtraSystemStatusObserver::subscribe(bool yes)
+{
+ // Subscription data list
+ list<DataItemId> subItemIdList;
+ subItemIdList.push_back(NETWORKINFO_DATA_ITEM_ID);
+ subItemIdList.push_back(MCCMNC_DATA_ITEM_ID);
+
+ if (yes) {
+ mSystemStatusObsrvr->subscribe(subItemIdList, this);
+
+ list<DataItemId> reqItemIdList;
+ reqItemIdList.push_back(TAC_DATA_ITEM_ID);
+
+ mSystemStatusObsrvr->requestData(reqItemIdList, this);
+
+ } else {
+ mSystemStatusObsrvr->unsubscribe(subItemIdList, this);
+ }
+}
+
+// IDataItemObserver overrides
+void XtraSystemStatusObserver::getName(string& name)
+{
+ name = "XtraSystemStatusObserver";
+}
+
+void XtraSystemStatusObserver::notify(const list<IDataItemCore*>& dlist)
+{
+ struct handleOsObserverUpdateMsg : public LocMsg {
+ XtraSystemStatusObserver* mXtraSysStatObj;
+ list <IDataItemCore*> mDataItemList;
+
+ inline handleOsObserverUpdateMsg(XtraSystemStatusObserver* xtraSysStatObs,
+ const list<IDataItemCore*>& dataItemList) :
+ mXtraSysStatObj(xtraSysStatObs) {
+ for (auto eachItem : dataItemList) {
+ IDataItemCore* dataitem = DataItemsFactoryProxy::createNewDataItem(
+ eachItem->getId());
+ if (NULL == dataitem) {
+ break;
+ }
+ // Copy the contents of the data item
+ dataitem->copy(eachItem);
+
+ mDataItemList.push_back(dataitem);
+ }
+ }
+
+ inline ~handleOsObserverUpdateMsg() {
+ for (auto each : mDataItemList) {
+ delete each;
+ }
+ }
+
+ inline void proc() const {
+ for (auto each : mDataItemList) {
+ switch (each->getId())
+ {
+ case NETWORKINFO_DATA_ITEM_ID:
+ {
+ NetworkInfoDataItemBase* networkInfo =
+ static_cast<NetworkInfoDataItemBase*>(each);
+ mXtraSysStatObj->updateConnectionStatus(networkInfo->mConnected,
+ networkInfo->mType);
+ }
+ break;
+
+ case TAC_DATA_ITEM_ID:
+ {
+ TacDataItemBase* tac =
+ static_cast<TacDataItemBase*>(each);
+ mXtraSysStatObj->updateTac(tac->mValue);
+ }
+ break;
+
+ case MCCMNC_DATA_ITEM_ID:
+ {
+ MccmncDataItemBase* mccmnc =
+ static_cast<MccmncDataItemBase*>(each);
+ mXtraSysStatObj->updateMccMnc(mccmnc->mValue);
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+ };
+ mMsgTask->sendMsg(new (nothrow) handleOsObserverUpdateMsg(this, dlist));
+}
+
+
diff --git a/gps/gnss/XtraSystemStatusObserver.h b/gps/gnss/XtraSystemStatusObserver.h
new file mode 100644
index 0000000..42f49b5
--- /dev/null
+++ b/gps/gnss/XtraSystemStatusObserver.h
@@ -0,0 +1,71 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#ifndef XTRA_SYSTEM_STATUS_OBS_H
+#define XTRA_SYSTEM_STATUS_OBS_H
+
+#include <cinttypes>
+#include <MsgTask.h>
+
+using namespace std;
+using loc_core::IOsObserver;
+using loc_core::IDataItemObserver;
+using loc_core::IDataItemCore;
+
+
+class XtraSystemStatusObserver : public IDataItemObserver {
+public :
+ // constructor & destructor
+ inline XtraSystemStatusObserver(IOsObserver* sysStatObs, const MsgTask* msgTask):
+ mSystemStatusObsrvr(sysStatObs), mMsgTask(msgTask) {
+ subscribe(true);
+ }
+ inline XtraSystemStatusObserver() {};
+ inline virtual ~XtraSystemStatusObserver() { subscribe(false); }
+
+ // IDataItemObserver overrides
+ inline virtual void getName(string& name);
+ virtual void notify(const list<IDataItemCore*>& dlist);
+
+ bool updateLockStatus(uint32_t lock);
+ bool updateConnectionStatus(bool connected, uint32_t type);
+ bool updateTac(const string& tac);
+ bool updateMccMnc(const string& mccmnc);
+ inline const MsgTask* getMsgTask() { return mMsgTask; }
+ void subscribe(bool yes);
+
+private:
+ int createSocket();
+ void closeSocket(const int32_t socketFd);
+ bool sendEvent(const stringstream& event);
+ IOsObserver* mSystemStatusObsrvr;
+ const MsgTask* mMsgTask;
+
+};
+
+#endif
diff --git a/gps/gnss/location_gnss.cpp b/gps/gnss/location_gnss.cpp
new file mode 100644
index 0000000..b5623e1
--- /dev/null
+++ b/gps/gnss/location_gnss.cpp
@@ -0,0 +1,258 @@
+/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ * * Neither the name of The Linux Foundation, nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "GnssAdapter.h"
+#include "location_interface.h"
+
+static GnssAdapter* gGnssAdapter = NULL;
+
+static void initialize();
+static void deinitialize();
+
+static void addClient(LocationAPI* client, const LocationCallbacks& callbacks);
+static void removeClient(LocationAPI* client);
+static void requestCapabilities(LocationAPI* client);
+
+static uint32_t startTracking(LocationAPI* client, LocationOptions& options);
+static void updateTrackingOptions(LocationAPI* client, uint32_t id, LocationOptions& options);
+static void stopTracking(LocationAPI* client, uint32_t id);
+
+static void gnssNiResponse(LocationAPI* client, uint32_t id, GnssNiResponse response);
+static uint32_t gnssDeleteAidingData(GnssAidingData& data);
+
+static void setControlCallbacks(LocationControlCallbacks& controlCallbacks);
+static uint32_t enable(LocationTechnologyType techType);
+static void disable(uint32_t id);
+static uint32_t* gnssUpdateConfig(GnssConfig config);
+
+static void injectLocation(double latitude, double longitude, float accuracy);
+static void injectTime(int64_t time, int64_t timeReference, int32_t uncertainty);
+
+static void agpsInit(const AgpsCbInfo& cbInfo);
+static void agpsDataConnOpen(AGpsExtType agpsType, const char* apnName, int apnLen, int ipType);
+static void agpsDataConnClosed(AGpsExtType agpsType);
+static void agpsDataConnFailed(AGpsExtType agpsType);
+static void getDebugReport(GnssDebugReport& report);
+static void updateConnectionStatus(bool connected, uint8_t type);
+
+static const GnssInterface gGnssInterface = {
+ sizeof(GnssInterface),
+ initialize,
+ deinitialize,
+ addClient,
+ removeClient,
+ requestCapabilities,
+ startTracking,
+ updateTrackingOptions,
+ stopTracking,
+ gnssNiResponse,
+ setControlCallbacks,
+ enable,
+ disable,
+ gnssUpdateConfig,
+ gnssDeleteAidingData,
+ injectLocation,
+ injectTime,
+ agpsInit,
+ agpsDataConnOpen,
+ agpsDataConnClosed,
+ agpsDataConnFailed,
+ getDebugReport,
+ updateConnectionStatus,
+};
+
+#ifndef DEBUG_X86
+extern "C" const GnssInterface* getGnssInterface()
+#else
+const GnssInterface* getGnssInterface()
+#endif // DEBUG_X86
+{
+ return &gGnssInterface;
+}
+
+static void initialize()
+{
+ if (NULL == gGnssAdapter) {
+ gGnssAdapter = new GnssAdapter();
+ }
+}
+
+static void deinitialize()
+{
+ if (NULL != gGnssAdapter) {
+ delete gGnssAdapter;
+ gGnssAdapter = NULL;
+ }
+}
+
+static void addClient(LocationAPI* client, const LocationCallbacks& callbacks)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->addClientCommand(client, callbacks);
+ }
+}
+
+static void removeClient(LocationAPI* client)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->removeClientCommand(client);
+ }
+}
+
+static void requestCapabilities(LocationAPI* client)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->requestCapabilitiesCommand(client);
+ }
+}
+
+static uint32_t startTracking(LocationAPI* client, LocationOptions& options)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->startTrackingCommand(client, options);
+ } else {
+ return 0;
+ }
+}
+
+static void updateTrackingOptions(LocationAPI* client, uint32_t id, LocationOptions& options)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->updateTrackingOptionsCommand(client, id, options);
+ }
+}
+
+static void stopTracking(LocationAPI* client, uint32_t id)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->stopTrackingCommand(client, id);
+ }
+}
+
+static void gnssNiResponse(LocationAPI* client, uint32_t id, GnssNiResponse response)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->gnssNiResponseCommand(client, id, response);
+ }
+}
+
+static void setControlCallbacks(LocationControlCallbacks& controlCallbacks)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->setControlCallbacksCommand(controlCallbacks);
+ }
+}
+
+static uint32_t enable(LocationTechnologyType techType)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->enableCommand(techType);
+ } else {
+ return 0;
+ }
+}
+
+static void disable(uint32_t id)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->disableCommand(id);
+ }
+}
+
+static uint32_t* gnssUpdateConfig(GnssConfig config)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->gnssUpdateConfigCommand(config);
+ } else {
+ return NULL;
+ }
+}
+
+static uint32_t gnssDeleteAidingData(GnssAidingData& data)
+{
+ if (NULL != gGnssAdapter) {
+ return gGnssAdapter->gnssDeleteAidingDataCommand(data);
+ } else {
+ return 0;
+ }
+}
+
+static void injectLocation(double latitude, double longitude, float accuracy)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->injectLocationCommand(latitude, longitude, accuracy);
+ }
+}
+
+static void injectTime(int64_t time, int64_t timeReference, int32_t uncertainty)
+{
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->injectTimeCommand(time, timeReference, uncertainty);
+ }
+}
+
+static void agpsInit(const AgpsCbInfo& cbInfo) {
+
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->initAgpsCommand(cbInfo);
+ }
+}
+static void agpsDataConnOpen(
+ AGpsExtType agpsType, const char* apnName, int apnLen, int ipType) {
+
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->dataConnOpenCommand(
+ agpsType, apnName, apnLen, (AGpsBearerType)ipType);
+ }
+}
+static void agpsDataConnClosed(AGpsExtType agpsType) {
+
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->dataConnClosedCommand(agpsType);
+ }
+}
+static void agpsDataConnFailed(AGpsExtType agpsType) {
+
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->dataConnFailedCommand(agpsType);
+ }
+}
+
+static void getDebugReport(GnssDebugReport& report) {
+
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->getDebugReport(report);
+ }
+}
+
+static void updateConnectionStatus(bool connected, uint8_t type) {
+ if (NULL != gGnssAdapter) {
+ gGnssAdapter->getSystemStatus()->eventConnectionStatus(connected, type);
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 00:09:01 +0000