/* Copyright (c) 2011, The Linux Foundation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. * * Neither the name of The Linux Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #define LOG_NDEBUG 0 #define LOG_TAG "LocSvc_adapter" #include #include #include #include #include #include #include #ifndef USE_GLIB #include #endif /* USE_GLIB */ #include "LocApiV02Adapter.h" #include "loc_api_v02_client.h" #include "loc_api_v02_log.h" #include "loc_api_sync_req.h" #include "LocApiAdapter.h" #include "loc_util_log.h" #include "platform_lib_includes.h" /* Default session id ; TBD needs incrementing for each */ #define LOC_API_V02_DEF_SESSION_ID (1) /* Default minimium interval in ms */ #define LOC_API_V02_DEF_MIN_INTERVAL (1000) /* Default horizontal accuracy in meters*/ #define LOC_API_V02_DEF_HORZ_ACCURACY (50) /* Default timeout in ms; TBD: needs implementing */ #define LOC_API_V02_DEF_TIMEOUT (120000) /* UMTS CP Address key*/ #define LOC_NI_NOTIF_KEY_ADDRESS "Address" /* GPS SV Id offset */ #define GPS_SV_ID_OFFSET (1) /* GLONASS SV Id offset */ #define GLONASS_SV_ID_OFFSET (65) /* SV ID range */ #define SV_ID_RANGE (32) /* static event callbacks that call the LocApiV02Adapter callbacks*/ /* global event callback, call the eventCb function in loc api adapter v02 instance */ static void globalEventCb(locClientHandleType clientHandle, uint32_t eventId, const locClientEventIndUnionType eventPayload, void* pClientCookie) { MODEM_LOG_CALLFLOW(%s, loc_get_v02_event_name(eventId)); LocApiV02Adapter *locApiV02AdapterInstance = (LocApiV02Adapter *)pClientCookie; LOC_LOGV ("%s:%d] client = %p, event id = %d, client cookie ptr = %p\n", __func__, __LINE__, clientHandle, eventId, pClientCookie); // return if null is passed if( NULL == locApiV02AdapterInstance) { LOC_LOGE ("%s:%d] NULL object passed : client = %p, event id = %d\n", __func__, __LINE__, clientHandle, eventId); return; } locApiV02AdapterInstance->eventCb(clientHandle, eventId, eventPayload); } /* global response callback, it calls the sync request process indication function to unblock the request that is waiting on this response indication*/ static void globalRespCb(locClientHandleType clientHandle, uint32_t respId, const locClientRespIndUnionType respPayload, void* pClientCookie) { MODEM_LOG_CALLFLOW(%s, loc_get_v02_event_name(respId)); LocApiV02Adapter *locApiV02AdapterInstance = (LocApiV02Adapter *)pClientCookie; LOC_LOGV ("%s:%d] client = %p, resp id = %d, client cookie ptr = %p\n", __func__, __LINE__, clientHandle, respId, pClientCookie); if( NULL == locApiV02AdapterInstance) { LOC_LOGE ("%s:%d] NULL object passed : client = %p, resp id = %d\n", __func__, __LINE__, clientHandle, respId); return; } // process the sync call // use pDeleteAssistDataInd as a dummy pointer loc_sync_process_ind(clientHandle, respId, (void *)respPayload.pDeleteAssistDataInd); } /* global error callback, it will call the handle service down function in the loc api adapter instance. */ static void globalErrorCb (locClientHandleType clientHandle, locClientErrorEnumType errorId, void *pClientCookie) { LocApiV02Adapter *locApiV02AdapterInstance = (LocApiV02Adapter *)pClientCookie; LOC_LOGV ("%s:%d] client = %p, error id = %d\n, client cookie ptr = %p\n", __func__, __LINE__, clientHandle, errorId, pClientCookie); if( NULL == locApiV02AdapterInstance) { LOC_LOGE ("%s:%d] NULL object passed : client = %p, error id = %d\n", __func__, __LINE__, clientHandle, errorId); return; } locApiV02AdapterInstance->errorCb(clientHandle, errorId); } /* global structure containing the callbacks */ locClientCallbacksType globalCallbacks = { sizeof(locClientCallbacksType), globalEventCb, globalRespCb, globalErrorCb }; /* Constructor for LocApiV02Adapter */ LocApiV02Adapter :: LocApiV02Adapter(LocEng &locEng): LocApiAdapter(locEng), clientHandle( LOC_CLIENT_INVALID_HANDLE_VALUE), eventMask(convertMask(locEng.eventMask)) { // initialize loc_sync_req interface loc_sync_req_init(); } /* Destructor for LocApiV02Adapter */ LocApiV02Adapter :: ~LocApiV02Adapter() { deInitLocClient(); } /* close Loc API V02 client */ int LocApiV02Adapter :: deInitLocClient() { return ( eLOC_CLIENT_SUCCESS == locClientClose(&clientHandle)) ? 0 : -1 ; } /* Initialize a loc api v02 client */ enum loc_api_adapter_err LocApiV02Adapter :: reinit() { locClientStatusEnumType status; /* If the client is already open close it first */ if(LOC_CLIENT_INVALID_HANDLE_VALUE != clientHandle) { status = locClientClose(&clientHandle); if( eLOC_CLIENT_SUCCESS != status) { LOC_LOGE ("%s:%d]: locClientClose failed, status = %d\n", __func__, __LINE__, status); return (LOC_API_ADAPTER_ERR_FAILURE); } } LOC_LOGV ("%s:%d]: reference to this = %p passed in \n", __func__, __LINE__, this); /* initialize the loc api v02 interface, note that the locClientOpen() function will block if the service is unavailable for a fixed time out */ status = locClientOpen( eventMask, &globalCallbacks, &clientHandle, (void *)this); if (eLOC_CLIENT_SUCCESS != status || clientHandle == LOC_CLIENT_INVALID_HANDLE_VALUE ) { LOC_LOGE ("%s:%d]: locClientOpen failed, status = %s\n", __func__, __LINE__, loc_get_v02_client_status_name(status)); return (LOC_API_ADAPTER_ERR_FAILURE); } // return SUCCESS return (LOC_API_ADAPTER_ERR_SUCCESS); } /* start positioning session */ enum loc_api_adapter_err LocApiV02Adapter :: startFix() { locClientStatusEnumType status; locClientReqUnionType req_union; qmiLocStartReqMsgT_v02 start_msg; qmiLocSetOperationModeReqMsgT_v02 set_mode_msg; qmiLocSetOperationModeIndMsgT_v02 set_mode_ind; // clear all fields, validity masks memset (&start_msg, 0, sizeof(start_msg)); memset (&set_mode_msg, 0, sizeof(set_mode_msg)); memset (&set_mode_ind, 0, sizeof(set_mode_ind)); LOC_LOGV("%s:%d]: start \n", __func__, __LINE__); fixCriteria.logv(); // fill in the start request switch(fixCriteria.mode) { case LOC_POSITION_MODE_MS_BASED: set_mode_msg.operationMode = eQMI_LOC_OPER_MODE_MSB_V02; break; case LOC_POSITION_MODE_MS_ASSISTED: set_mode_msg.operationMode = eQMI_LOC_OPER_MODE_MSA_V02; break; case LOC_POSITION_MODE_RESERVED_4: set_mode_msg.operationMode = eQMI_LOC_OPER_MODE_CELL_ID_V02; break; default: set_mode_msg.operationMode = eQMI_LOC_OPER_MODE_STANDALONE_V02; break; } req_union.pSetOperationModeReq = &set_mode_msg; // send the mode first, before the start message. status = loc_sync_send_req(clientHandle, QMI_LOC_SET_OPERATION_MODE_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_SET_OPERATION_MODE_IND_V02, &set_mode_ind); // NULL? if (status != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != set_mode_ind.status) { LOC_LOGE ("%s:%d]: set opertion mode failed status = %s, " "ind..status = %s\n", __func__, __LINE__, loc_get_v02_client_status_name(status), loc_get_v02_qmi_status_name(set_mode_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; // error } start_msg.minInterval_valid = 1; start_msg.minInterval = fixCriteria.min_interval; if (fixCriteria.preferred_accuracy > 0) { start_msg.horizontalAccuracyLevel_valid = 1; if (fixCriteria.preferred_accuracy <= 100) { // fix needs high accuracy start_msg.horizontalAccuracyLevel = eQMI_LOC_ACCURACY_HIGH_V02; } else if (fixCriteria.preferred_accuracy <= 1000) { //fix needs med accuracy start_msg.horizontalAccuracyLevel = eQMI_LOC_ACCURACY_MED_V02; } else { //fix needs low accuracy start_msg.horizontalAccuracyLevel = eQMI_LOC_ACCURACY_LOW_V02; } } start_msg.fixRecurrence_valid = 1; if(GPS_POSITION_RECURRENCE_SINGLE == fixCriteria.recurrence) { start_msg.fixRecurrence = eQMI_LOC_RECURRENCE_SINGLE_V02; } else { start_msg.fixRecurrence = eQMI_LOC_RECURRENCE_PERIODIC_V02; } //dummy session id // TBD: store session ID, check for session id in pos reports. start_msg.sessionId = LOC_API_V02_DEF_SESSION_ID; if (fixCriteria.credentials[0] != 0) { int size1 = sizeof(start_msg.applicationId.applicationName); int size2 = sizeof(fixCriteria.credentials); int len = ((size1 < size2) ? size1 : size2) - 1; memcpy(start_msg.applicationId.applicationName, fixCriteria.credentials, len); size1 = sizeof(start_msg.applicationId.applicationProvider); size2 = sizeof(fixCriteria.provider); len = ((size1 < size2) ? size1 : size2) - 1; memcpy(start_msg.applicationId.applicationProvider, fixCriteria.provider, len); start_msg.applicationId_valid = 1; } req_union.pStartReq = &start_msg; status = locClientSendReq (clientHandle, QMI_LOC_START_REQ_V02, req_union ); if( eLOC_CLIENT_SUCCESS == status) { return LOC_API_ADAPTER_ERR_SUCCESS; } return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } /* stop a positioning session */ enum loc_api_adapter_err LocApiV02Adapter :: stopFix() { locClientStatusEnumType status; locClientReqUnionType req_union; qmiLocStopReqMsgT_v02 stop_msg; LOC_LOGD(" %s:%d]: stop called \n", __func__, __LINE__); memset(&stop_msg, 0, sizeof(stop_msg)); // dummy session id stop_msg.sessionId = LOC_API_V02_DEF_SESSION_ID; req_union.pStopReq = &stop_msg; status = locClientSendReq(clientHandle, QMI_LOC_STOP_REQ_V02, req_union); if( eLOC_CLIENT_SUCCESS == status) { return LOC_API_ADAPTER_ERR_SUCCESS; } LOC_LOGE("%s:%d]: error = %s\n",__func__, __LINE__, loc_get_v02_client_status_name(status)); return (LOC_API_ADAPTER_ERR_GENERAL_FAILURE); } /* set the positioning fix criteria */ enum loc_api_adapter_err LocApiV02Adapter :: setPositionMode( const LocPosMode *posMode) { LOC_LOGV ("%s:%d]: posMode %p",__func__, __LINE__, posMode); if (NULL != posMode && !fixCriteria.equals(*posMode)) { //making a copy of the fix criteria fixCriteria = *posMode; LOC_LOGD ("%s:%d]: new fix criteria", __func__, __LINE__); if(true == navigating) { //fix is in progress, send a restart LOC_LOGD ("%s:%d]: fix is in progress restarting the fix with new " "criteria\n", __func__, __LINE__); return( startFix()); } } return LOC_API_ADAPTER_ERR_SUCCESS; } /* inject time into the position engine */ enum loc_api_adapter_err LocApiV02Adapter :: setTime(GpsUtcTime time, int64_t timeReference, int uncertainty) { locClientReqUnionType req_union; locClientStatusEnumType status; qmiLocInjectUtcTimeReqMsgT_v02 inject_time_msg; qmiLocInjectUtcTimeIndMsgT_v02 inject_time_ind; memset(&inject_time_msg, 0, sizeof(inject_time_msg)); inject_time_ind.status = eQMI_LOC_GENERAL_FAILURE_V02; inject_time_msg.timeUtc = time; inject_time_msg.timeUtc += (int64_t)(ELAPSED_MILLIS_SINCE_BOOT_PLATFORM_LIB_ABSTRACTION - timeReference); inject_time_msg.timeUnc = uncertainty; req_union.pInjectUtcTimeReq = &inject_time_msg; LOC_LOGV ("%s:%d]: uncertainty = %d\n", __func__, __LINE__, uncertainty); status = loc_sync_send_req(clientHandle, QMI_LOC_INJECT_UTC_TIME_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_INJECT_UTC_TIME_IND_V02, &inject_time_ind); if (status != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != inject_time_ind.status) { LOC_LOGE ("%s:%d] status = %s, ind..status = %s\n", __func__, __LINE__, loc_get_v02_client_status_name(status), loc_get_v02_qmi_status_name(inject_time_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* inject position into the position engine */ enum loc_api_adapter_err LocApiV02Adapter :: injectPosition(double latitude, double longitude, float accuracy) { locClientReqUnionType req_union; locClientStatusEnumType status; qmiLocInjectPositionReqMsgT_v02 inject_pos_msg; qmiLocInjectPositionIndMsgT_v02 inject_pos_ind; memset(&inject_pos_msg, 0, sizeof(inject_pos_msg)); inject_pos_msg.latitude_valid = 1; inject_pos_msg.latitude = latitude; inject_pos_msg.longitude_valid = 1; inject_pos_msg.longitude = longitude; inject_pos_msg.horUncCircular_valid = 1; inject_pos_msg.horUncCircular = accuracy; //meters assumed inject_pos_msg.horConfidence_valid = 1; inject_pos_msg.horConfidence = 63; // 63% (1 std dev assumed) /* Log */ LOC_LOGD("%s:%d]: Lat=%lf, Lon=%lf, Acc=%.2lf\n", __func__, __LINE__, inject_pos_msg.latitude, inject_pos_msg.longitude, inject_pos_msg.horUncCircular); req_union.pInjectPositionReq = &inject_pos_msg; status = loc_sync_send_req(clientHandle, QMI_LOC_INJECT_POSITION_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_INJECT_POSITION_IND_V02, &inject_pos_ind); if (status != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != inject_pos_ind.status) { LOC_LOGE ("%s:%d]: error! status = %s, inject_pos_ind.status = %s\n", __func__, __LINE__, loc_get_v02_client_status_name(status), loc_get_v02_qmi_status_name(inject_pos_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* delete assistance date */ enum loc_api_adapter_err LocApiV02Adapter :: deleteAidingData(GpsAidingData f) { locClientReqUnionType req_union; locClientStatusEnumType status; qmiLocDeleteAssistDataReqMsgT_v02 delete_req; qmiLocDeleteAssistDataIndMsgT_v02 delete_resp; memset(&delete_req, 0, sizeof(delete_req)); memset(&delete_resp, 0, sizeof(delete_resp)); if( f == GPS_DELETE_ALL ) { delete_req.deleteAllFlag = true; } else { /* to keep track of svInfoList for GPS and GLO*/ uint32_t curr_sv_len = 0; uint32_t curr_sv_idx = 0; uint32_t sv_id = 0; if((f & GPS_DELETE_EPHEMERIS ) || ( f & GPS_DELETE_ALMANAC )) { /* do delete for all GPS SV's */ curr_sv_len += SV_ID_RANGE; sv_id = GPS_SV_ID_OFFSET; delete_req.deleteSvInfoList_valid = 1; delete_req.deleteSvInfoList_len = curr_sv_len; LOC_LOGV("%s:%d]: Delete GPS SV info for index %d to %d" "and sv id %d to %d \n", __func__, __LINE__, curr_sv_idx, curr_sv_len - 1, sv_id, sv_id+SV_ID_RANGE); for( uint32_t i = curr_sv_idx; i< curr_sv_len ; i++, sv_id++ ) { delete_req.deleteSvInfoList[i].gnssSvId = sv_id; delete_req.deleteSvInfoList[i].system = eQMI_LOC_SV_SYSTEM_GPS_V02; if(f & GPS_DELETE_EPHEMERIS ) { // set ephemeris mask for all GPS SV's delete_req.deleteSvInfoList[i].deleteSvInfoMask |= QMI_LOC_MASK_DELETE_EPHEMERIS_V02; } if( f & GPS_DELETE_ALMANAC ) { delete_req.deleteSvInfoList[i].deleteSvInfoMask |= QMI_LOC_MASK_DELETE_ALMANAC_V02; } } // increment the current index curr_sv_idx += SV_ID_RANGE; } if( f & GPS_DELETE_TIME_GPS ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_GPS_TIME_V02; } if(f & GPS_DELETE_POSITION ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_POSITION_V02; } if(f & GPS_DELETE_TIME ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_TIME_V02; } if(f & GPS_DELETE_IONO ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_IONO_V02; } if(f & GPS_DELETE_UTC ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_UTC_V02; } if(f & GPS_DELETE_HEALTH ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_HEALTH_V02; } if(f & GPS_DELETE_SVDIR ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_GPS_SVDIR_V02; } if(f & GPS_DELETE_SADATA ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_SADATA_V02; } if(f & GPS_DELETE_RTI ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_RTI_V02; } if(f & GPS_DELETE_CELLDB_INFO ) { delete_req.deleteCellDbDataMask_valid = 1; delete_req.deleteCellDbDataMask = ( QMI_LOC_MASK_DELETE_CELLDB_POS_V02 | QMI_LOC_MASK_DELETE_CELLDB_LATEST_GPS_POS_V02 | QMI_LOC_MASK_DELETE_CELLDB_OTA_POS_V02 | QMI_LOC_MASK_DELETE_CELLDB_EXT_REF_POS_V02 | QMI_LOC_MASK_DELETE_CELLDB_TIMETAG_V02 | QMI_LOC_MASK_DELETE_CELLDB_CELLID_V02 | QMI_LOC_MASK_DELETE_CELLDB_CACHED_CELLID_V02 | QMI_LOC_MASK_DELETE_CELLDB_LAST_SRV_CELL_V02 | QMI_LOC_MASK_DELETE_CELLDB_CUR_SRV_CELL_V02 | QMI_LOC_MASK_DELETE_CELLDB_NEIGHBOR_INFO_V02) ; } if(f & GPS_DELETE_ALMANAC_CORR ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_GPS_ALM_CORR_V02; } if(f & GPS_DELETE_FREQ_BIAS_EST ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_FREQ_BIAS_EST_V02; } if ( (f & GPS_DELETE_EPHEMERIS_GLO ) || (f & GPS_DELETE_ALMANAC_GLO )) { /* do delete for all GLONASS SV's (65 - 96) */ curr_sv_len += SV_ID_RANGE; sv_id = GLONASS_SV_ID_OFFSET; delete_req.deleteSvInfoList_valid = 1; delete_req.deleteSvInfoList_len = curr_sv_len; LOC_LOGV("%s:%d]: Delete GLO SV info for index %d to %d" "and sv id %d to %d \n", __func__, __LINE__, curr_sv_idx, curr_sv_len - 1, sv_id, sv_id+SV_ID_RANGE); for( uint32_t i = curr_sv_idx; i< curr_sv_len ; i++, sv_id++ ) { delete_req.deleteSvInfoList[i].gnssSvId = sv_id; delete_req.deleteSvInfoList[i].system = eQMI_LOC_SV_SYSTEM_GLONASS_V02; if(f & GPS_DELETE_EPHEMERIS ) { // set ephemeris mask for all GPS SV's delete_req.deleteSvInfoList[i].deleteSvInfoMask |= QMI_LOC_MASK_DELETE_EPHEMERIS_V02; } if( f & GPS_DELETE_ALMANAC ) { delete_req.deleteSvInfoList[i].deleteSvInfoMask |= QMI_LOC_MASK_DELETE_ALMANAC_V02; } } curr_sv_idx += SV_ID_RANGE; } if(f & GPS_DELETE_SVDIR_GLO ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_GLO_SVDIR_V02; } if(f & GPS_DELETE_SVSTEER_GLO ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_GLO_SVSTEER_V02; } if(f & GPS_DELETE_ALMANAC_CORR_GLO ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_GLO_ALM_CORR_V02; } if(f & GPS_DELETE_TIME_GLO ) { delete_req.deleteGnssDataMask_valid = 1; delete_req.deleteGnssDataMask |= QMI_LOC_MASK_DELETE_GLO_TIME_V02; } } req_union.pDeleteAssistDataReq = &delete_req; status = loc_sync_send_req(clientHandle, QMI_LOC_DELETE_ASSIST_DATA_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_DELETE_ASSIST_DATA_IND_V02, &delete_resp); if (status != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != delete_resp.status) { LOC_LOGE ("%s:%d]: error! status = %s, delete_resp.status = %s\n", __func__, __LINE__, loc_get_v02_client_status_name(status), loc_get_v02_qmi_status_name(delete_resp.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* send NI user repsonse to the engine */ enum loc_api_adapter_err LocApiV02Adapter :: informNiResponse(GpsUserResponseType userResponse, const void* passThroughData) { locClientReqUnionType req_union; locClientStatusEnumType status; qmiLocNiUserRespReqMsgT_v02 ni_resp; qmiLocNiUserRespIndMsgT_v02 ni_resp_ind; qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *request_pass_back = (qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *)passThroughData; memset(&ni_resp,0, sizeof(ni_resp)); memset(&ni_resp_ind,0, sizeof(ni_resp_ind)); switch (userResponse) { case GPS_NI_RESPONSE_ACCEPT: ni_resp.userResp = eQMI_LOC_NI_LCS_NOTIFY_VERIFY_ACCEPT_V02; break; case GPS_NI_RESPONSE_DENY: ni_resp.userResp = eQMI_LOC_NI_LCS_NOTIFY_VERIFY_DENY_V02; break; case GPS_NI_RESPONSE_NORESP: ni_resp.userResp = eQMI_LOC_NI_LCS_NOTIFY_VERIFY_NORESP_V02; break; default: return LOC_API_ADAPTER_ERR_INVALID_PARAMETER; } LOC_LOGV(" %s:%d]: NI response: %d\n", __func__, __LINE__, ni_resp.userResp); ni_resp.notificationType = request_pass_back->notificationType; // copy SUPL payload from request if(request_pass_back->NiSuplInd_valid == 1) { ni_resp.NiSuplPayload_valid = 1; memcpy(&(ni_resp.NiSuplPayload), &(request_pass_back->NiSuplInd), sizeof(qmiLocNiSuplNotifyVerifyStructT_v02)); } // should this be an "else if"?? we don't need to decide // copy UMTS-CP payload from request if( request_pass_back->NiUmtsCpInd_valid == 1 ) { ni_resp.NiUmtsCpPayload_valid = 1; memcpy(&(ni_resp.NiUmtsCpPayload), &(request_pass_back->NiUmtsCpInd), sizeof(qmiLocNiUmtsCpNotifyVerifyStructT_v02)); } //copy Vx payload from the request if( request_pass_back->NiVxInd_valid == 1) { ni_resp.NiVxPayload_valid = 1; memcpy(&(ni_resp.NiVxPayload), &(request_pass_back->NiVxInd), sizeof(qmiLocNiVxNotifyVerifyStructT_v02)); } // copy Vx service interaction payload from the request if(request_pass_back->NiVxServiceInteractionInd_valid == 1) { ni_resp.NiVxServiceInteractionPayload_valid = 1; memcpy(&(ni_resp.NiVxServiceInteractionPayload), &(request_pass_back->NiVxServiceInteractionInd), sizeof(qmiLocNiVxServiceInteractionStructT_v02)); } req_union.pNiUserRespReq = &ni_resp; status = loc_sync_send_req ( clientHandle, QMI_LOC_NI_USER_RESPONSE_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_NI_USER_RESPONSE_IND_V02, &ni_resp_ind); if (status != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != ni_resp_ind.status) { LOC_LOGE ("%s:%d]: error! status = %s, ni_resp_ind.status = %s\n", __func__, __LINE__, loc_get_v02_client_status_name(status), loc_get_v02_qmi_status_name(ni_resp_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* Set UMTs SLP server URL */ enum loc_api_adapter_err LocApiV02Adapter :: setServer( const char* url, int len) { locClientReqUnionType req_union; locClientStatusEnumType status; qmiLocSetServerReqMsgT_v02 set_server_req; qmiLocSetServerIndMsgT_v02 set_server_ind; if(len <=0 || len > sizeof(set_server_req.urlAddr)) { LOC_LOGE("%s:%d]: len = %d greater than max allowed url length\n", __func__, __LINE__, len); return LOC_API_ADAPTER_ERR_INVALID_PARAMETER; } memset(&set_server_req, 0, sizeof(set_server_req)); LOC_LOGD("%s:%d]:, url = %s, len = %d\n", __func__, __LINE__, url, len); set_server_req.serverType = eQMI_LOC_SERVER_TYPE_UMTS_SLP_V02; set_server_req.urlAddr_valid = 1; strlcpy(set_server_req.urlAddr, url, sizeof(set_server_req.urlAddr)); req_union.pSetServerReq = &set_server_req; status = loc_sync_send_req(clientHandle, QMI_LOC_SET_SERVER_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_SET_SERVER_IND_V02, &set_server_ind); if (status != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != set_server_ind.status) { LOC_LOGE ("%s:%d]: error status = %s, set_server_ind.status = %s\n", __func__,__LINE__, loc_get_v02_client_status_name(status), loc_get_v02_qmi_status_name(set_server_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } enum loc_api_adapter_err LocApiV02Adapter :: setServer(unsigned int ip, int port, LocServerType type) { locClientReqUnionType req_union; locClientStatusEnumType status; qmiLocSetServerReqMsgT_v02 set_server_req; qmiLocSetServerIndMsgT_v02 set_server_ind; qmiLocServerTypeEnumT_v02 set_server_cmd; switch (type) { case LOC_AGPS_MPC_SERVER: set_server_cmd = eQMI_LOC_SERVER_TYPE_CDMA_MPC_V02; break; case LOC_AGPS_CUSTOM_PDE_SERVER: set_server_cmd = eQMI_LOC_SERVER_TYPE_CUSTOM_PDE_V02; break; default: set_server_cmd = eQMI_LOC_SERVER_TYPE_CDMA_PDE_V02; break; } memset(&set_server_req, 0, sizeof(set_server_req)); LOC_LOGD("%s:%d]:, ip = %u, port = %d\n", __func__, __LINE__, ip, port); set_server_req.serverType = set_server_cmd; set_server_req.ipv4Addr_valid = 1; set_server_req.ipv4Addr.addr = ip; set_server_req.ipv4Addr.port = port; req_union.pSetServerReq = &set_server_req; status = loc_sync_send_req(clientHandle, QMI_LOC_SET_SERVER_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_SET_SERVER_IND_V02, &set_server_ind); if (status != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != set_server_ind.status) { LOC_LOGE ("%s:%d]: error status = %s, set_server_ind.status = %s\n", __func__,__LINE__, loc_get_v02_client_status_name(status), loc_get_v02_qmi_status_name(set_server_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* Inject XTRA data, this module breaks down the XTRA file into "chunks" and injects them one at a time */ enum loc_api_adapter_err LocApiV02Adapter :: setXtraData( char* data, int length) { locClientStatusEnumType status = eLOC_CLIENT_SUCCESS; int total_parts; uint8_t part; uint16_t len_injected; locClientReqUnionType req_union; qmiLocInjectPredictedOrbitsDataReqMsgT_v02 inject_xtra; qmiLocInjectPredictedOrbitsDataIndMsgT_v02 inject_xtra_ind; req_union.pInjectPredictedOrbitsDataReq = &inject_xtra; LOC_LOGD("%s:%d]: xtra size = %d\n", __func__, __LINE__, length); inject_xtra.formatType_valid = 1; inject_xtra.formatType = eQMI_LOC_PREDICTED_ORBITS_XTRA_V02; inject_xtra.totalSize = length; total_parts = ((length - 1) / QMI_LOC_MAX_PREDICTED_ORBITS_PART_LEN_V02) + 1; inject_xtra.totalParts = total_parts; len_injected = 0; // O bytes injected // XTRA injection starts with part 1 for (part = 1; part <= total_parts; part++) { inject_xtra.partNum = part; if (QMI_LOC_MAX_PREDICTED_ORBITS_PART_LEN_V02 > (length - len_injected)) { inject_xtra.partData_len = length - len_injected; } else { inject_xtra.partData_len = QMI_LOC_MAX_PREDICTED_ORBITS_PART_LEN_V02; } // copy data into the message memcpy(inject_xtra.partData, data+len_injected, inject_xtra.partData_len); LOC_LOGD("[%s:%d] part %d/%d, len = %d, total injected = %d\n", __func__, __LINE__, inject_xtra.partNum, total_parts, inject_xtra.partData_len, len_injected); status = loc_sync_send_req( clientHandle, QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_INJECT_PREDICTED_ORBITS_DATA_IND_V02, &inject_xtra_ind); if (status != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != inject_xtra_ind.status || inject_xtra.partNum != inject_xtra_ind.partNum) { LOC_LOGE ("%s:%d]: failed status = %s, inject_pos_ind.status = %s," " part num = %d, ind.partNum = %d\n", __func__, __LINE__, loc_get_v02_client_status_name(status), loc_get_v02_qmi_status_name(inject_xtra_ind.status), inject_xtra.partNum, inject_xtra_ind.partNum); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; break; } len_injected += inject_xtra.partData_len; LOC_LOGD("%s:%d]: XTRA injected length: %d\n", __func__, __LINE__, len_injected); } return LOC_API_ADAPTER_ERR_SUCCESS; } enum loc_api_adapter_err LocApiV02Adapter :: atlOpenStatus( int handle, int is_succ, char* apn, AGpsBearerType bear, AGpsType agpsType) { locClientStatusEnumType result = eLOC_CLIENT_SUCCESS; locClientReqUnionType req_union; qmiLocInformLocationServerConnStatusReqMsgT_v02 conn_status_req; qmiLocInformLocationServerConnStatusIndMsgT_v02 conn_status_ind; LOC_LOGD("%s:%d]: ATL open handle = %d, is_succ = %d, " "APN = [%s], bearer = %d \n", __func__, __LINE__, handle, is_succ, apn, bear); memset(&conn_status_req, 0, sizeof(conn_status_req)); memset(&conn_status_ind, 0, sizeof(conn_status_ind)); // Fill in data conn_status_req.connHandle = handle; conn_status_req.requestType = eQMI_LOC_SERVER_REQUEST_OPEN_V02; if(is_succ) { conn_status_req.statusType = eQMI_LOC_SERVER_REQ_STATUS_SUCCESS_V02; strlcpy(conn_status_req.apnProfile.apnName, apn, sizeof(conn_status_req.apnProfile.apnName) ); switch(bear) { case AGPS_APN_BEARER_IPV4: conn_status_req.apnProfile.pdnType = eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV4_V02; break; case AGPS_APN_BEARER_IPV6: conn_status_req.apnProfile.pdnType = eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV6_V02; break; case AGPS_APN_BEARER_IPV4V6: conn_status_req.apnProfile.pdnType = eQMI_LOC_APN_PROFILE_PDN_TYPE_IPV4V6_V02; break; default: LOC_LOGE("%s:%d]:invalid bearer type\n",__func__,__LINE__); return LOC_API_ADAPTER_ERR_INVALID_HANDLE; } conn_status_req.apnProfile_valid = 1; } else { conn_status_req.statusType = eQMI_LOC_SERVER_REQ_STATUS_FAILURE_V02; } req_union.pInformLocationServerConnStatusReq = &conn_status_req; result = loc_sync_send_req(clientHandle, QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02, &conn_status_ind); if(result != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != conn_status_ind.status) { LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ", __func__, __LINE__, loc_get_v02_client_status_name(result), loc_get_v02_qmi_status_name(conn_status_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* close atl connection */ enum loc_api_adapter_err LocApiV02Adapter :: atlCloseStatus( int handle, int is_succ) { locClientStatusEnumType result = eLOC_CLIENT_SUCCESS; locClientReqUnionType req_union; qmiLocInformLocationServerConnStatusReqMsgT_v02 conn_status_req; qmiLocInformLocationServerConnStatusIndMsgT_v02 conn_status_ind; LOC_LOGD("%s:%d]: ATL close handle = %d, is_succ = %d\n", __func__, __LINE__, handle, is_succ); memset(&conn_status_req, 0, sizeof(conn_status_req)); memset(&conn_status_ind, 0, sizeof(conn_status_ind)); // Fill in data conn_status_req.connHandle = handle; conn_status_req.requestType = eQMI_LOC_SERVER_REQUEST_CLOSE_V02; if(is_succ) { conn_status_req.statusType = eQMI_LOC_SERVER_REQ_STATUS_SUCCESS_V02; } else { conn_status_req.statusType = eQMI_LOC_SERVER_REQ_STATUS_FAILURE_V02; } req_union.pInformLocationServerConnStatusReq = &conn_status_req; result = loc_sync_send_req(clientHandle, QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_INFORM_LOCATION_SERVER_CONN_STATUS_IND_V02, &conn_status_ind); if(result != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != conn_status_ind.status) { LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ", __func__, __LINE__, loc_get_v02_client_status_name(result), loc_get_v02_qmi_status_name(conn_status_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* set the SUPL version */ enum loc_api_adapter_err LocApiV02Adapter :: setSUPLVersion(uint32_t version) { locClientStatusEnumType result = eLOC_CLIENT_SUCCESS; locClientReqUnionType req_union; qmiLocSetProtocolConfigParametersReqMsgT_v02 supl_config_req; qmiLocSetProtocolConfigParametersIndMsgT_v02 supl_config_ind; LOC_LOGD("%s:%d]: supl version = %d\n", __func__, __LINE__, version); memset(&supl_config_req, 0, sizeof(supl_config_req)); memset(&supl_config_ind, 0, sizeof(supl_config_ind)); supl_config_req.suplVersion_valid = 1; // SUPL version from MSByte to LSByte: // (reserved)(major version)(minor version)(serviceIndicator) supl_config_req.suplVersion = (version == 0x00020000)? eQMI_LOC_SUPL_VERSION_2_0_V02 : eQMI_LOC_SUPL_VERSION_1_0_V02; req_union.pSetProtocolConfigParametersReq = &supl_config_req; result = loc_sync_send_req(clientHandle, QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02, &supl_config_ind); if(result != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != supl_config_ind.status) { LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ", __func__, __LINE__, loc_get_v02_client_status_name(result), loc_get_v02_qmi_status_name(supl_config_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* set the configuration for LTE positioning profile (LPP) */ enum loc_api_adapter_err LocApiV02Adapter :: setLPPConfig(uint32_t profile) { locClientStatusEnumType result = eLOC_CLIENT_SUCCESS; locClientReqUnionType req_union; qmiLocSetProtocolConfigParametersReqMsgT_v02 lpp_config_req; qmiLocSetProtocolConfigParametersIndMsgT_v02 lpp_config_ind; LOC_LOGD("%s:%d]: lpp profile = %d\n", __func__, __LINE__, profile); memset(&lpp_config_req, 0, sizeof(lpp_config_req)); memset(&lpp_config_ind, 0, sizeof(lpp_config_ind)); lpp_config_req.lppConfig_valid = 1; // Default RRLP or User or Control plane configuration switch(profile) { /* RRLP */ case 0: lpp_config_req.lppConfig = profile; break; /* User plane */ case 1: lpp_config_req.lppConfig = QMI_LOC_LPP_CONFIG_ENABLE_USER_PLANE_V02; break; case 2: lpp_config_req.lppConfig = QMI_LOC_LPP_CONFIG_ENABLE_CONTROL_PLANE_V02; break; default: LOC_LOGE("%s:%d]: Invalid LPP Profile Config Setting Provided in gps.conf = %d!", __FUNCTION__, __LINE__, profile); return LOC_API_ADAPTER_ERR_INVALID_PARAMETER; break; } req_union.pSetProtocolConfigParametersReq = &lpp_config_req; result = loc_sync_send_req(clientHandle, QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_SET_PROTOCOL_CONFIG_PARAMETERS_IND_V02, &lpp_config_ind); if(result != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != lpp_config_ind.status) { LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ", __func__, __LINE__, loc_get_v02_client_status_name(result), loc_get_v02_qmi_status_name(lpp_config_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* set the Sensor Configuration */ enum loc_api_adapter_err LocApiV02Adapter :: setSensorControlConfig(int sensorsDisabled) { locClientStatusEnumType result = eLOC_CLIENT_SUCCESS; locClientReqUnionType req_union; qmiLocSetSensorControlConfigReqMsgT_v02 sensor_config_req; qmiLocSetSensorControlConfigIndMsgT_v02 sensor_config_ind; LOC_LOGD("%s:%d]: sensors disabled = %d\n", __func__, __LINE__, sensorsDisabled); memset(&sensor_config_req, 0, sizeof(sensor_config_req)); memset(&sensor_config_ind, 0, sizeof(sensor_config_ind)); sensor_config_req.sensorsUsage_valid = 1; sensor_config_req.sensorsUsage = (sensorsDisabled == 1) ? eQMI_LOC_SENSOR_CONFIG_SENSOR_USE_DISABLE_V02 : eQMI_LOC_SENSOR_CONFIG_SENSOR_USE_ENABLE_V02; req_union.pSetSensorControlConfigReq = &sensor_config_req; result = loc_sync_send_req(clientHandle, QMI_LOC_SET_SENSOR_CONTROL_CONFIG_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_SET_SENSOR_CONTROL_CONFIG_IND_V02, &sensor_config_ind); if(result != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != sensor_config_ind.status) { LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ", __func__, __LINE__, loc_get_v02_client_status_name(result), loc_get_v02_qmi_status_name(sensor_config_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* set the Sensor Properties */ enum loc_api_adapter_err LocApiV02Adapter :: setSensorProperties(bool gyroBiasVarianceRandomWalk_valid, float gyroBiasVarianceRandomWalk, bool accelBiasVarianceRandomWalk_valid, float accelBiasVarianceRandomWalk, bool angleBiasVarianceRandomWalk_valid, float angleBiasVarianceRandomWalk, bool rateBiasVarianceRandomWalk_valid, float rateBiasVarianceRandomWalk, bool velocityBiasVarianceRandomWalk_valid, float velocityBiasVarianceRandomWalk) { locClientStatusEnumType result = eLOC_CLIENT_SUCCESS; locClientReqUnionType req_union; qmiLocSetSensorPropertiesReqMsgT_v02 sensor_prop_req; qmiLocSetSensorPropertiesIndMsgT_v02 sensor_prop_ind; LOC_LOGI("%s:%d]: sensors prop: gyroBiasRandomWalk = %f, accelRandomWalk = %f, " "angleRandomWalk = %f, rateRandomWalk = %f, velocityRandomWalk = %f\n", __func__, __LINE__, gyroBiasVarianceRandomWalk, accelBiasVarianceRandomWalk, angleBiasVarianceRandomWalk, rateBiasVarianceRandomWalk, velocityBiasVarianceRandomWalk); memset(&sensor_prop_req, 0, sizeof(sensor_prop_req)); memset(&sensor_prop_ind, 0, sizeof(sensor_prop_ind)); /* Set the validity bit and value for each sensor property */ sensor_prop_req.gyroBiasVarianceRandomWalk_valid = gyroBiasVarianceRandomWalk_valid; sensor_prop_req.gyroBiasVarianceRandomWalk = gyroBiasVarianceRandomWalk; sensor_prop_req.accelerationRandomWalkSpectralDensity_valid = accelBiasVarianceRandomWalk_valid; sensor_prop_req.accelerationRandomWalkSpectralDensity = accelBiasVarianceRandomWalk; sensor_prop_req.angleRandomWalkSpectralDensity_valid = angleBiasVarianceRandomWalk_valid; sensor_prop_req.angleRandomWalkSpectralDensity = angleBiasVarianceRandomWalk; sensor_prop_req.rateRandomWalkSpectralDensity_valid = rateBiasVarianceRandomWalk_valid; sensor_prop_req.rateRandomWalkSpectralDensity = rateBiasVarianceRandomWalk; sensor_prop_req.velocityRandomWalkSpectralDensity_valid = velocityBiasVarianceRandomWalk_valid; sensor_prop_req.velocityRandomWalkSpectralDensity = velocityBiasVarianceRandomWalk; req_union.pSetSensorPropertiesReq = &sensor_prop_req; result = loc_sync_send_req(clientHandle, QMI_LOC_SET_SENSOR_PROPERTIES_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_SET_SENSOR_PROPERTIES_IND_V02, &sensor_prop_ind); if(result != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != sensor_prop_ind.status) { LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ", __func__, __LINE__, loc_get_v02_client_status_name(result), loc_get_v02_qmi_status_name(sensor_prop_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* set the Sensor Performance Config */ enum loc_api_adapter_err LocApiV02Adapter :: setSensorPerfControlConfig(int controlMode, int accelSamplesPerBatch, int accelBatchesPerSec, int gyroSamplesPerBatch, int gyroBatchesPerSec, int accelSamplesPerBatchHigh, int accelBatchesPerSecHigh, int gyroSamplesPerBatchHigh, int gyroBatchesPerSecHigh, int algorithmConfig) { locClientStatusEnumType result = eLOC_CLIENT_SUCCESS; locClientReqUnionType req_union; qmiLocSetSensorPerformanceControlConfigReqMsgT_v02 sensor_perf_config_req; qmiLocSetSensorPerformanceControlConfigIndMsgT_v02 sensor_perf_config_ind; LOC_LOGD("%s:%d]: Sensor Perf Control Config (performanceControlMode)(%u) " "accel(#smp,#batches) (%u,%u) gyro(#smp,#batches) (%u,%u) " "accel_high(#smp,#batches) (%u,%u) gyro_high(#smp,#batches) (%u,%u) " "algorithmConfig(%u)\n", __FUNCTION__, __LINE__, controlMode, accelSamplesPerBatch, accelBatchesPerSec, gyroSamplesPerBatch, gyroBatchesPerSec, accelSamplesPerBatchHigh, accelBatchesPerSecHigh, gyroSamplesPerBatchHigh, gyroBatchesPerSecHigh, algorithmConfig ); memset(&sensor_perf_config_req, 0, sizeof(sensor_perf_config_req)); memset(&sensor_perf_config_ind, 0, sizeof(sensor_perf_config_ind)); sensor_perf_config_req.performanceControlMode_valid = 1; sensor_perf_config_req.performanceControlMode = (qmiLocSensorPerformanceControlModeEnumT_v02)controlMode; sensor_perf_config_req.accelSamplingSpec_valid = 1; sensor_perf_config_req.accelSamplingSpec.batchesPerSecond = accelBatchesPerSec; sensor_perf_config_req.accelSamplingSpec.samplesPerBatch = accelSamplesPerBatch; sensor_perf_config_req.gyroSamplingSpec_valid = 1; sensor_perf_config_req.gyroSamplingSpec.batchesPerSecond = gyroBatchesPerSec; sensor_perf_config_req.gyroSamplingSpec.samplesPerBatch = gyroSamplesPerBatch; sensor_perf_config_req.accelSamplingSpecHigh_valid = 1; sensor_perf_config_req.accelSamplingSpecHigh.batchesPerSecond = accelBatchesPerSecHigh; sensor_perf_config_req.accelSamplingSpecHigh.samplesPerBatch = accelSamplesPerBatchHigh; sensor_perf_config_req.gyroSamplingSpecHigh_valid = 1; sensor_perf_config_req.gyroSamplingSpecHigh.batchesPerSecond = gyroBatchesPerSecHigh; sensor_perf_config_req.gyroSamplingSpecHigh.samplesPerBatch = gyroSamplesPerBatchHigh; sensor_perf_config_req.algorithmConfig_valid = 1; sensor_perf_config_req.algorithmConfig = algorithmConfig; req_union.pSetSensorPerformanceControlConfigReq = &sensor_perf_config_req; result = loc_sync_send_req(clientHandle, QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_SET_SENSOR_PERFORMANCE_CONTROL_CONFIGURATION_IND_V02, &sensor_perf_config_ind); if(result != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != sensor_perf_config_ind.status) { LOC_LOGE ("%s:%d]: Error status = %s, ind..status = %s ", __func__, __LINE__, loc_get_v02_client_status_name(result), loc_get_v02_qmi_status_name(sensor_perf_config_ind.status)); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* set the External Power Config */ enum loc_api_adapter_err LocApiV02Adapter :: setExtPowerConfig(int isBatteryCharging) { locClientStatusEnumType result = eLOC_CLIENT_SUCCESS; locClientReqUnionType req_union; qmiLocSetExternalPowerConfigReqMsgT_v02 ext_pwr_req; qmiLocGetExternalPowerConfigIndMsgT_v02 ext_pwr_ind; LOC_LOGI("%s:%d]: Ext Pwr Config (isBatteryCharging)(%u)", __FUNCTION__, __LINE__, isBatteryCharging ); memset(&ext_pwr_req, 0, sizeof(ext_pwr_req)); memset(&ext_pwr_ind, 0, sizeof(ext_pwr_ind)); switch(isBatteryCharging) { /* Charging */ case 1: ext_pwr_req.externalPowerState = eQMI_LOC_EXTERNAL_POWER_CONNECTED_V02; break; /* Not charging */ case 0: ext_pwr_req.externalPowerState = eQMI_LOC_EXTERNAL_POWER_NOT_CONNECTED_V02; break; default: LOC_LOGE("%s:%d]: Invalid ext power state = %d!", __FUNCTION__, __LINE__, isBatteryCharging); return LOC_API_ADAPTER_ERR_INVALID_PARAMETER; break; } req_union.pSetExternalPowerConfigReq = &ext_pwr_req; result = loc_sync_send_req(clientHandle, QMI_LOC_SET_EXTERNAL_POWER_CONFIG_REQ_V02, req_union, LOC_ENGINE_SYNC_REQUEST_TIMEOUT, QMI_LOC_SET_EXTERNAL_POWER_CONFIG_IND_V02, &ext_pwr_ind); if(result != eLOC_CLIENT_SUCCESS || eQMI_LOC_SUCCESS_V02 != ext_pwr_ind.status) { LOC_LOGE ("%s:%d]: Error status = %d, ind..status = %d ", __func__, __LINE__, result, ext_pwr_ind.status); return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; } return LOC_API_ADAPTER_ERR_SUCCESS; } /* Convert event mask from loc eng to loc_api_v02 format */ locClientEventMaskType LocApiV02Adapter :: convertMask( LOC_API_ADAPTER_EVENT_MASK_T mask) { locClientEventMaskType eventMask = 0; LOC_LOGD("%s:%d]: adapter mask = %u\n", __func__, __LINE__, mask); if(mask & LOC_API_ADAPTER_BIT_PARSED_POSITION_REPORT) eventMask |= QMI_LOC_EVENT_MASK_POSITION_REPORT_V02; if(mask & LOC_API_ADAPTER_BIT_SATELLITE_REPORT) eventMask |= QMI_LOC_EVENT_MASK_GNSS_SV_INFO_V02; /* treat NMEA_1Hz and NMEA_POSITION_REPORT the same*/ if( (mask & LOC_API_ADAPTER_BIT_NMEA_POSITION_REPORT) || (mask & LOC_API_ADAPTER_BIT_NMEA_1HZ_REPORT) ) eventMask |= QMI_LOC_EVENT_MASK_NMEA_V02; if(mask & LOC_API_ADAPTER_BIT_NI_NOTIFY_VERIFY_REQUEST) eventMask |= QMI_LOC_EVENT_MASK_NI_NOTIFY_VERIFY_REQ_V02; if(mask & LOC_API_ADAPTER_BIT_ASSISTANCE_DATA_REQUEST) { // TBD: This needs to be decoupled in the HAL eventMask |= QMI_LOC_EVENT_MASK_INJECT_PREDICTED_ORBITS_REQ_V02; eventMask |= QMI_LOC_EVENT_MASK_INJECT_TIME_REQ_V02; eventMask |= QMI_LOC_EVENT_MASK_INJECT_POSITION_REQ_V02; } if(mask & LOC_API_ADAPTER_BIT_STATUS_REPORT) { eventMask |= (QMI_LOC_EVENT_MASK_ENGINE_STATE_V02 | QMI_LOC_EVENT_MASK_FIX_SESSION_STATE_V02); } if(mask & LOC_API_ADAPTER_BIT_LOCATION_SERVER_REQUEST) eventMask |= QMI_LOC_EVENT_MASK_LOCATION_SERVER_CONNECTION_REQ_V02; return eventMask; } /* Convert error from loc_api_v02 to loc eng format*/ enum loc_api_adapter_err LocApiV02Adapter :: convertErr( locClientStatusEnumType status) { switch( status) { case LOC_API_ADAPTER_ERR_SUCCESS: return LOC_API_ADAPTER_ERR_SUCCESS; case eLOC_CLIENT_FAILURE_GENERAL: return LOC_API_ADAPTER_ERR_GENERAL_FAILURE; case eLOC_CLIENT_FAILURE_UNSUPPORTED: return LOC_API_ADAPTER_ERR_UNSUPPORTED; case eLOC_CLIENT_FAILURE_INVALID_PARAMETER: return LOC_API_ADAPTER_ERR_INVALID_PARAMETER; case eLOC_CLIENT_FAILURE_ENGINE_BUSY: return LOC_API_ADAPTER_ERR_ENGINE_BUSY; case eLOC_CLIENT_FAILURE_PHONE_OFFLINE: return LOC_API_ADAPTER_ERR_PHONE_OFFLINE; case eLOC_CLIENT_FAILURE_TIMEOUT: return LOC_API_ADAPTER_ERR_TIMEOUT; case eLOC_CLIENT_FAILURE_INVALID_HANDLE: return LOC_API_ADAPTER_ERR_INVALID_HANDLE; case eLOC_CLIENT_FAILURE_SERVICE_NOT_PRESENT: return LOC_API_ADAPTER_ERR_SERVICE_NOT_PRESENT; default: return LOC_API_ADAPTER_ERR_FAILURE; } } /* convert position report to loc eng format and send the converted position to loc eng */ void LocApiV02Adapter :: reportPosition ( const qmiLocEventPositionReportIndMsgT_v02 *location_report_ptr) { GpsLocation location; LocPosTechMask tech_Mask = LOC_POS_TECH_MASK_DEFAULT; LOC_LOGD("Reporting postion from V2 Adapter\n"); memset(&location, 0, sizeof (GpsLocation)); location.size = sizeof(location); // Process the position from final and intermediate reports if( (location_report_ptr->sessionStatus == eQMI_LOC_SESS_STATUS_SUCCESS_V02) || (location_report_ptr->sessionStatus == eQMI_LOC_SESS_STATUS_IN_PROGRESS_V02) ) { // Latitude & Longitude if( (location_report_ptr->latitude_valid == 1 ) && (location_report_ptr->longitude_valid == 1) && (location_report_ptr->latitude != 0 || location_report_ptr->longitude!= 0)) { location.flags |= GPS_LOCATION_HAS_LAT_LONG; location.latitude = location_report_ptr->latitude; location.longitude = location_report_ptr->longitude; // Time stamp (UTC) if(location_report_ptr->timestampUtc_valid == 1) { location.timestamp = location_report_ptr->timestampUtc; } // Altitude if(location_report_ptr->altitudeWrtEllipsoid_valid == 1 ) { location.flags |= GPS_LOCATION_HAS_ALTITUDE; location.altitude = location_report_ptr->altitudeWrtEllipsoid; } // Speed if((location_report_ptr->speedHorizontal_valid == 1) && (location_report_ptr->speedVertical_valid ==1 ) ) { location.flags |= GPS_LOCATION_HAS_SPEED; location.speed = sqrt( (location_report_ptr->speedHorizontal * location_report_ptr->speedHorizontal) + (location_report_ptr->speedVertical * location_report_ptr->speedVertical) ); } // Heading if(location_report_ptr->heading_valid == 1) { location.flags |= GPS_LOCATION_HAS_BEARING; location.bearing = location_report_ptr->heading; } // Uncertainty (circular) if( (location_report_ptr->horUncCircular_valid ) ) { location.flags |= GPS_LOCATION_HAS_ACCURACY; location.accuracy = location_report_ptr->horUncCircular; } // Technology Mask tech_Mask |= location_report_ptr->technologyMask; //Mark the location source as from GNSS location.flags |= LOCATION_HAS_SOURCE_INFO; location.position_source = ULP_LOCATION_IS_FROM_GNSS; LocApiAdapter::reportPosition( location, locEngHandle.extPosInfo((void*)location_report_ptr), (location_report_ptr->sessionStatus == eQMI_LOC_SESS_STATUS_IN_PROGRESS_V02 ? LOC_SESS_INTERMEDIATE : LOC_SESS_SUCCESS), tech_Mask); } } else { LocApiAdapter::reportPosition(location, NULL, LOC_SESS_FAILURE); LOC_LOGD("%s:%d]: Ignoring position report with sess status = %d, " "fix id = %u\n", __func__, __LINE__, location_report_ptr->sessionStatus, location_report_ptr->fixId ); } } /* convert satellite report to loc eng format and send the converted report to loc eng */ void LocApiV02Adapter :: reportSv ( const qmiLocEventGnssSvInfoIndMsgT_v02 *gnss_report_ptr) { GpsSvStatus SvStatus; int num_svs_max, i; const qmiLocSvInfoStructT_v02 *sv_info_ptr; LOC_LOGV ("%s:%d]: num of sv = %d\n", __func__, __LINE__, gnss_report_ptr->svList_len); num_svs_max = 0; memset (&SvStatus, 0, sizeof (GpsSvStatus)); if(gnss_report_ptr->svList_valid == 1) { num_svs_max = gnss_report_ptr->svList_len; if(num_svs_max > GPS_MAX_SVS) { num_svs_max = GPS_MAX_SVS; } SvStatus.num_svs = 0; for(i = 0; i < num_svs_max; i++) { sv_info_ptr = &(gnss_report_ptr->svList[i]); if((sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_SYSTEM_V02) && (sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_GNSS_SVID_V02) && (sv_info_ptr->gnssSvId != 0 )) { if(sv_info_ptr->system == eQMI_LOC_SV_SYSTEM_GPS_V02) { SvStatus.sv_list[SvStatus.num_svs].size = sizeof(GpsSvStatus); SvStatus.sv_list[SvStatus.num_svs].prn = (int)sv_info_ptr->gnssSvId; // We only have the data field to report gps eph and alm mask if(sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_SVINFO_MASK_V02) { if(sv_info_ptr->svInfoMask & QMI_LOC_SVINFO_MASK_HAS_EPHEMERIS_V02) { SvStatus.ephemeris_mask |= (1 << (sv_info_ptr->gnssSvId-1)); } if(sv_info_ptr->svInfoMask & QMI_LOC_SVINFO_MASK_HAS_ALMANAC_V02) { SvStatus.almanac_mask |= (1 << (sv_info_ptr->gnssSvId-1)); } } if((sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_PROCESS_STATUS_V02) && (sv_info_ptr->svStatus == eQMI_LOC_SV_STATUS_TRACK_V02)) { SvStatus.used_in_fix_mask |= (1 << (sv_info_ptr->gnssSvId-1)); } } // SBAS: GPS RPN: 120-151, // In exteneded measurement report, we follow nmea standard, // which is from 33-64. else if(sv_info_ptr->system == eQMI_LOC_SV_SYSTEM_SBAS_V02) { SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->gnssSvId + 33 - 120; } // Gloness: Slot id: 1-32 // In extended measurement report, we follow nmea standard, // which is 65-96 else if(sv_info_ptr->system == eQMI_LOC_SV_SYSTEM_GLONASS_V02) { SvStatus.sv_list[SvStatus.num_svs].prn = sv_info_ptr->gnssSvId + (65-1); } // Unsupported SV system else { continue; } } if(sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_SNR_V02 ) { SvStatus.sv_list[SvStatus.num_svs].snr = sv_info_ptr->snr; } if(sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_ELEVATION_V02) { SvStatus.sv_list[SvStatus.num_svs].elevation = sv_info_ptr->elevation; } if(sv_info_ptr->validMask & QMI_LOC_SV_INFO_MASK_VALID_AZIMUTH_V02) { SvStatus.sv_list[SvStatus.num_svs].azimuth = sv_info_ptr->azimuth; } SvStatus.num_svs++; } } if (SvStatus.num_svs >= 0) { LOC_LOGV ("%s:%d]: firing SV callback\n", __func__, __LINE__); LocApiAdapter::reportSv(SvStatus, locEngHandle.extSvInfo((void*)gnss_report_ptr)); } } /* convert engine state report to loc eng format and send the converted report to loc eng */ void LocApiV02Adapter :: reportEngineState ( const qmiLocEventEngineStateIndMsgT_v02 *engine_state_ptr) { GpsStatusValue status; LOC_LOGV("%s:%d]: state = %d\n", __func__, __LINE__, engine_state_ptr->engineState); status = GPS_STATUS_NONE; if (engine_state_ptr->engineState == eQMI_LOC_ENGINE_STATE_ON_V02) { status = GPS_STATUS_ENGINE_ON; } else if (engine_state_ptr->engineState == eQMI_LOC_ENGINE_STATE_OFF_V02) { status = GPS_STATUS_ENGINE_OFF; } LocApiAdapter::reportStatus(status); } /* convert fix session state report to loc eng format and send the converted report to loc eng */ void LocApiV02Adapter :: reportFixSessionState ( const qmiLocEventFixSessionStateIndMsgT_v02 *fix_session_state_ptr) { GpsStatusValue status; LOC_LOGD("%s:%d]: state = %d\n", __func__, __LINE__, fix_session_state_ptr->sessionState); status = GPS_STATUS_NONE; if (fix_session_state_ptr->sessionState == eQMI_LOC_FIX_SESSION_STARTED_V02) { status = GPS_STATUS_SESSION_BEGIN; } else if (fix_session_state_ptr->sessionState == eQMI_LOC_FIX_SESSION_FINISHED_V02) { status = GPS_STATUS_SESSION_END; } LocApiAdapter::reportStatus(status); } /* convert NMEA report to loc eng format and send the converted report to loc eng */ void LocApiV02Adapter :: reportNmea ( const qmiLocEventNmeaIndMsgT_v02 *nmea_report_ptr) { LocApiAdapter::reportNmea(nmea_report_ptr->nmea, strlen(nmea_report_ptr->nmea)); LOC_LOGD("%s:%d]: $%c%c%c\n", __func__, __LINE__, nmea_report_ptr->nmea[3], nmea_report_ptr->nmea[4], nmea_report_ptr->nmea[5]); } /* convert and report an ATL request to loc engine */ void LocApiV02Adapter :: reportAtlRequest( const qmiLocEventLocationServerConnectionReqIndMsgT_v02 * server_request_ptr) { uint32_t connHandle = server_request_ptr->connHandle; // service ATL open request; copy the WWAN type if(server_request_ptr->requestType == eQMI_LOC_SERVER_REQUEST_OPEN_V02 ) { AGpsType agpsType = AGPS_TYPE_WWAN_ANY; switch(server_request_ptr->wwanType) { case eQMI_LOC_WWAN_TYPE_INTERNET_V02: agpsType = AGPS_TYPE_WWAN_ANY; break; case eQMI_LOC_WWAN_TYPE_AGNSS_V02: agpsType = AGPS_TYPE_SUPL; break; default: agpsType = AGPS_TYPE_WWAN_ANY; break; } LocApiAdapter::requestATL(connHandle, agpsType); } // service the ATL close request else if (server_request_ptr->requestType == eQMI_LOC_SERVER_REQUEST_CLOSE_V02) { LocApiAdapter::releaseATL(connHandle); } } /* conver the NI report to loc eng format and send t loc engine */ void LocApiV02Adapter :: reportNiRequest( const qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *ni_req_ptr) { GpsNiNotification notif; /* initialize the notification*/ memset(notif.extras, 0, sizeof notif.extras); memset(notif.text, 0, sizeof notif.text); memset(notif.requestor_id, 0, sizeof notif.requestor_id); /* NI timeout gets overwritten in LocApiAdapter, initializing to 0 here */ notif.timeout = 0; notif.text_encoding = GPS_ENC_NONE ; notif.requestor_id_encoding = GPS_ENC_UNKNOWN; notif.notify_flags = 0; notif.default_response = GPS_NI_RESPONSE_NORESP; /*Handle Vx request */ if(ni_req_ptr->NiVxInd_valid == 1) { const qmiLocNiVxNotifyVerifyStructT_v02 *vx_req = &(ni_req_ptr->NiVxInd); notif.ni_type = GPS_NI_TYPE_VOICE; // Requestor ID, the requestor id recieved is NULL terminated hexcode(notif.requestor_id, sizeof notif.requestor_id, (char *)vx_req->requestorId, vx_req->requestorId_len ); } /* Handle UMTS CP request*/ else if(ni_req_ptr->NiUmtsCpInd_valid == 1) { const qmiLocNiUmtsCpNotifyVerifyStructT_v02 *umts_cp_req = &ni_req_ptr->NiUmtsCpInd; notif.ni_type = GPS_NI_TYPE_UMTS_CTRL_PLANE; /* notificationText should always be a NULL terminated string */ hexcode(notif.text, sizeof notif.text, (char *)umts_cp_req->notificationText, umts_cp_req->notificationText_len); /* Store requestor ID */ hexcode(notif.requestor_id, sizeof(notif.requestor_id), (char *)umts_cp_req->requestorId.codedString, umts_cp_req->requestorId.codedString_len); /* convert encodings */ notif.text_encoding = convertNiEncoding(umts_cp_req->dataCodingScheme); notif.requestor_id_encoding = convertNiEncoding(umts_cp_req->requestorId.dataCodingScheme); /* LCS address (using extras field) */ if ( umts_cp_req->clientAddress_len != 0) { char lcs_addr[32]; // Decoded LCS address for UMTS CP NI // Copy LCS Address into notif.extras in the format: Address = 012345 strlcat(notif.extras, LOC_NI_NOTIF_KEY_ADDRESS, sizeof (notif.extras)); strlcat(notif.extras, " = ", sizeof notif.extras); int addr_len = 0; const char *address_source = NULL; address_source = (char *)umts_cp_req->clientAddress; // client Address is always NULL terminated addr_len = decodeAddress(lcs_addr, sizeof(lcs_addr), address_source, umts_cp_req->clientAddress_len); // The address is ASCII string if (addr_len) { strlcat(notif.extras, lcs_addr, sizeof notif.extras); } } } else if(ni_req_ptr->NiSuplInd_valid == 1) { const qmiLocNiSuplNotifyVerifyStructT_v02 *supl_req = &ni_req_ptr->NiSuplInd; notif.ni_type = GPS_NI_TYPE_UMTS_SUPL; // Client name if (supl_req->valid_flags & QMI_LOC_SUPL_CLIENT_NAME_MASK_V02) { hexcode(notif.text, sizeof(notif.text), (char *)supl_req->clientName.formattedString, supl_req->clientName.formattedString_len); LOC_LOGV("%s:%d]: SUPL NI: client_name: %s \n", __func__, __LINE__, notif.text); } else { LOC_LOGV("%s:%d]: SUPL NI: client_name not present.", __func__, __LINE__); } // Requestor ID if (supl_req->valid_flags & QMI_LOC_SUPL_REQUESTOR_ID_MASK_V02) { hexcode(notif.requestor_id, sizeof notif.requestor_id, (char*)supl_req->requestorId.formattedString, supl_req->requestorId.formattedString_len ); LOC_LOGV("%s:%d]: SUPL NI: requestor_id: %s \n", __func__, __LINE__, notif.requestor_id); } else { LOC_LOGV("%s:%d]: SUPL NI: requestor_id not present.", __func__, __LINE__); } // Encoding type if (supl_req->valid_flags & QMI_LOC_SUPL_DATA_CODING_SCHEME_MASK_V02) { notif.text_encoding = convertNiEncoding(supl_req->dataCodingScheme); notif.requestor_id_encoding = convertNiEncoding(supl_req->dataCodingScheme); } else { notif.text_encoding = notif.requestor_id_encoding = GPS_ENC_UNKNOWN; } } //ni_req_ptr->NiSuplInd_valid == 1 else { LOC_LOGE("%s:%d]: unknown request event \n",__func__, __LINE__); return; } // Set default_response & notify_flags convertNiNotifyVerifyType(¬if, ni_req_ptr->notificationType); qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *ni_req_copy_ptr = (qmiLocEventNiNotifyVerifyReqIndMsgT_v02 *)malloc(sizeof(*ni_req_copy_ptr)); if( NULL != ni_req_copy_ptr) { memcpy(ni_req_copy_ptr, ni_req_ptr, sizeof(*ni_req_copy_ptr)); LocApiAdapter::requestNiNotify(notif, (const void*)ni_req_copy_ptr); } else { LOC_LOGE("%s:%d]: Error copying NI request\n", __func__, __LINE__); } } /* convert Ni Encoding type from QMI_LOC to loc eng format */ GpsNiEncodingType LocApiV02Adapter ::convertNiEncoding( qmiLocNiDataCodingSchemeEnumT_v02 loc_encoding) { GpsNiEncodingType enc = GPS_ENC_UNKNOWN; switch (loc_encoding) { case eQMI_LOC_NI_SUPL_UTF8_V02: enc = GPS_ENC_SUPL_UTF8; break; case eQMI_LOC_NI_SUPL_UCS2_V02: enc = GPS_ENC_SUPL_UCS2; break; case eQMI_LOC_NI_SUPL_GSM_DEFAULT_V02: enc = GPS_ENC_SUPL_GSM_DEFAULT; break; case eQMI_LOC_NI_SS_LANGUAGE_UNSPEC_V02: enc = GPS_ENC_SUPL_GSM_DEFAULT; // SS_LANGUAGE_UNSPEC = GSM break; default: break; } return enc; } /*convert NI notify verify type from QMI LOC to loc eng format*/ bool LocApiV02Adapter :: convertNiNotifyVerifyType ( GpsNiNotification *notif, qmiLocNiNotifyVerifyEnumT_v02 notif_priv) { switch (notif_priv) { case eQMI_LOC_NI_USER_NO_NOTIFY_NO_VERIFY_V02: notif->notify_flags = 0; break; case eQMI_LOC_NI_USER_NOTIFY_ONLY_V02: notif->notify_flags = GPS_NI_NEED_NOTIFY; break; case eQMI_LOC_NI_USER_NOTIFY_VERIFY_ALLOW_NO_RESP_V02: notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY; notif->default_response = GPS_NI_RESPONSE_ACCEPT; break; case eQMI_LOC_NI_USER_NOTIFY_VERIFY_NOT_ALLOW_NO_RESP_V02: notif->notify_flags = GPS_NI_NEED_NOTIFY | GPS_NI_NEED_VERIFY; notif->default_response = GPS_NI_RESPONSE_DENY; break; case eQMI_LOC_NI_USER_NOTIFY_VERIFY_PRIVACY_OVERRIDE_V02: notif->notify_flags = GPS_NI_PRIVACY_OVERRIDE; break; default: return false; } return true; } /* event callback registered with the loc_api v02 interface */ void LocApiV02Adapter :: eventCb(locClientHandleType clientHandle, uint32_t eventId, locClientEventIndUnionType eventPayload) { LOC_LOGD("%s:%d]: event id = %d\n", __func__, __LINE__, eventId); switch(eventId) { //Position Report case QMI_LOC_EVENT_POSITION_REPORT_IND_V02: reportPosition(eventPayload.pPositionReportEvent); break; // Satellite report case QMI_LOC_EVENT_GNSS_SV_INFO_IND_V02: reportSv(eventPayload.pGnssSvInfoReportEvent); break; // Status report case QMI_LOC_EVENT_ENGINE_STATE_IND_V02: reportEngineState(eventPayload.pEngineState); break; case QMI_LOC_EVENT_FIX_SESSION_STATE_IND_V02: reportFixSessionState(eventPayload.pFixSessionState); break; // NMEA case QMI_LOC_EVENT_NMEA_IND_V02: reportNmea(eventPayload.pNmeaReportEvent); break; // XTRA request case QMI_LOC_EVENT_INJECT_PREDICTED_ORBITS_REQ_IND_V02: LOC_LOGD("%s:%d]: XTRA download request\n", __func__, __LINE__); requestXtraData(); break; // time request case QMI_LOC_EVENT_INJECT_TIME_REQ_IND_V02: LOC_LOGD("%s:%d]: Time request\n", __func__, __LINE__); requestTime(); break; //position request case QMI_LOC_EVENT_INJECT_POSITION_REQ_IND_V02: LOC_LOGD("%s:%d]: Position request\n", __func__, __LINE__); //requestPosition(); break; // NI request case QMI_LOC_EVENT_NI_NOTIFY_VERIFY_REQ_IND_V02: reportNiRequest(eventPayload.pNiNotifyVerifyReqEvent); break; // AGPS connection request case QMI_LOC_EVENT_LOCATION_SERVER_CONNECTION_REQ_IND_V02: reportAtlRequest(eventPayload.pLocationServerConnReqEvent); break; } } /* Call the service LocApiAdapter down event*/ void LocApiV02Adapter :: errorCb(locClientHandleType handle, locClientErrorEnumType errorId) { if(errorId == eLOC_CLIENT_ERROR_SERVICE_UNAVAILABLE) { LOC_LOGE("%s:%d]: Service unavailable error\n", __func__, __LINE__); LocApiAdapter::handleEngineDownEvent(); /* immediately send the engine up event so that the loc engine re-initializes the adapter and the loc-api_v02 interface */ LocApiAdapter::handleEngineUpEvent(); } } /* return a Loc API adapter */ LocApiAdapter* getLocApiAdapter(LocEng &locEng) { return(new LocApiV02Adapter(locEng)); }