MiPad4/android_device_xiaomi_sdm660-common
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
android_device_xiaomi_sdm66.../loc_api/libloc_api_50001/LocEngAdapter.cpp
Hans Chang 33552b272d AU_LINUX_ANDROID_LA.AF.1.1.05.00.02.164.175 based on quic/aosp/LA.AF.1.1 
-----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1.4.11 (GNU/Linux)
 
 iEYEABECAAYFAlTQKUkACgkQoUgPZYCpAfGAUgCgyH0kEyUtVhZ09+T3w4VfnZqK
 Id8An3JkWK9QhlXZ9Q2zT8T7LR5/T2ls
 =8mx/
 -----END PGP SIGNATURE-----

Merge tag 'AU_LINUX_ANDROID_LA.AF.1.1.05.00.02.164.175' into 111

AU_LINUX_ANDROID_LA.AF.1.1.05.00.02.164.175 based on quic/aosp/LA.AF.1.1

* tag 'AU_LINUX_ANDROID_LA.AF.1.1.05.00.02.164.175':
  GNSS measurement
  Added new events and masks for GDT AP
  gps.conf parameters are in sap.conf table
  Enable "auto" target for APQ8960 Automotive ADP platform
  support reinjecting supl url for sim hot swap
  Remove Redundant Log
  Report 2D speed rather than 3D speed.

Conflicts:
	core/gps_extended_c.h

Change-Id: Ibe1207ac07a2931003f5fa34ae68d8c1e6512eeb
2015-02-08 15:50:40 -08:00

443 lines
13 KiB
C++
Raw Blame History

/* Copyright (c) 2011-2014, 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_NDDEBUG 0
#define LOG_TAG "LocSvc_EngAdapter"
#include <LocEngAdapter.h>
#include "loc_eng_msg.h"
#include "loc_log.h"
using namespace loc_core;
LocInternalAdapter::LocInternalAdapter(LocEngAdapter* adapter) :
LocAdapterBase(adapter->getMsgTask()),
mLocEngAdapter(adapter)
{
}
void LocInternalAdapter::setPositionModeInt(LocPosMode& posMode) {
sendMsg(new LocEngPositionMode(mLocEngAdapter, posMode));
}
void LocInternalAdapter::startFixInt() {
sendMsg(new LocEngStartFix(mLocEngAdapter));
}
void LocInternalAdapter::stopFixInt() {
sendMsg(new LocEngStopFix(mLocEngAdapter));
}
void LocInternalAdapter::getZppInt() {
sendMsg(new LocEngGetZpp(mLocEngAdapter));
}
void LocInternalAdapter::shutdown() {
sendMsg(new LocEngShutdown(mLocEngAdapter));
}
LocEngAdapter::LocEngAdapter(LOC_API_ADAPTER_EVENT_MASK_T mask,
void* owner, ContextBase* context,
MsgTask::tCreate tCreator) :
LocAdapterBase(mask,
//Get the AFW context if VzW context has not already been intialized in
//loc_ext
context == NULL?
LocDualContext::getLocFgContext(tCreator,
LocDualContext::mLocationHalName)
:context),
mOwner(owner), mInternalAdapter(new LocInternalAdapter(this)),
mUlp(new UlpProxyBase()), mNavigating(false),
mSupportsAgpsRequests(false),
mSupportsPositionInjection(false),
mSupportsTimeInjection(false),
mPowerVote(0)
{
memset(&mFixCriteria, 0, sizeof(mFixCriteria));
mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
LOC_LOGD("LocEngAdapter created");
}
inline
LocEngAdapter::~LocEngAdapter()
{
delete mInternalAdapter;
LOC_LOGV("LocEngAdapter deleted");
}
void LocInternalAdapter::setUlpProxy(UlpProxyBase* ulp) {
struct LocSetUlpProxy : public LocMsg {
LocAdapterBase* mAdapter;
UlpProxyBase* mUlp;
inline LocSetUlpProxy(LocAdapterBase* adapter, UlpProxyBase* ulp) :
LocMsg(), mAdapter(adapter), mUlp(ulp) {
}
virtual void proc() const {
LOC_LOGV("%s] ulp %p adapter %p", __func__,
mUlp, mAdapter);
mAdapter->setUlpProxy(mUlp);
}
};
sendMsg(new LocSetUlpProxy(mLocEngAdapter, ulp));
}
void LocEngAdapter::setUlpProxy(UlpProxyBase* ulp)
{
if (ulp == mUlp) {
//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:%d]: ulp pointer is NULL", __func__, __LINE__);
ulp = new UlpProxyBase();
}
if (LOC_POSITION_MODE_INVALID != mUlp->mPosMode.mode) {
// need to send this mode and start msg to ULP
ulp->sendFixMode(mUlp->mPosMode);
}
if(mUlp->mFixSet) {
ulp->sendStartFix();
}
delete mUlp;
mUlp = ulp;
}
int LocEngAdapter::setGpsLockMsg(LOC_GPS_LOCK_MASK lockMask)
{
struct LocEngAdapterGpsLock : public LocMsg {
LocEngAdapter* mAdapter;
LOC_GPS_LOCK_MASK mLockMask;
inline LocEngAdapterGpsLock(LocEngAdapter* adapter, LOC_GPS_LOCK_MASK lockMask) :
LocMsg(), mAdapter(adapter), mLockMask(lockMask)
{
locallog();
}
inline virtual void proc() const {
mAdapter->setGpsLock(mLockMask);
}
inline void locallog() const {
LOC_LOGV("LocEngAdapterGpsLock - mLockMask: %x", mLockMask);
}
inline virtual void log() const {
locallog();
}
};
sendMsg(new LocEngAdapterGpsLock(this, lockMask));
return 0;
}
void LocEngAdapter::requestPowerVote()
{
if (getPowerVoteRight()) {
/* Power voting without engine lock:
* 101: vote down, 102-104 - vote up
* These codes are used not to confuse with actual engine lock
* functionality, that can't be used in SSR scenario, as it
* conflicts with initialization sequence.
*/
bool powerUp = getPowerVote();
LOC_LOGV("LocEngAdapterVotePower - Vote Power: %d", (int)powerUp);
setGpsLock(powerUp ? 103 : 101);
}
}
void LocInternalAdapter::reportPosition(UlpLocation &location,
GpsLocationExtended &locationExtended,
void* locationExt,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask)
{
sendMsg(new LocEngReportPosition(mLocEngAdapter,
location,
locationExtended,
locationExt,
status,
loc_technology_mask));
}
void LocEngAdapter::reportPosition(UlpLocation &location,
GpsLocationExtended &locationExtended,
void* locationExt,
enum loc_sess_status status,
LocPosTechMask loc_technology_mask)
{
if (! mUlp->reportPosition(location,
locationExtended,
locationExt,
status,
loc_technology_mask )) {
mInternalAdapter->reportPosition(location,
locationExtended,
locationExt,
status,
loc_technology_mask);
}
}
void LocInternalAdapter::reportSv(GpsSvStatus &svStatus,
GpsLocationExtended &locationExtended,
void* svExt){
sendMsg(new LocEngReportSv(mLocEngAdapter, svStatus,
locationExtended, svExt));
}
void LocEngAdapter::reportSv(GpsSvStatus &svStatus,
GpsLocationExtended &locationExtended,
void* svExt)
{
// We want to send SV info to ULP to help it in determining GNSS
// signal strength ULP will forward the SV reports to HAL without
// any modifications
if (! mUlp->reportSv(svStatus, locationExtended, svExt)) {
mInternalAdapter->reportSv(svStatus, locationExtended, svExt);
}
}
void LocEngAdapter::reportSvMeasurement(GnssSvMeasurementSet &svMeasurementSet)
{
// We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary.
if (! mUlp->reportSvMeasurement(svMeasurementSet)) {
//Send to Internal Adapter later if needed by LA
}
}
void LocEngAdapter::reportSvPolynomial(GnssSvPolynomial &svPolynomial)
{
// We send SvMeasurementSet to AmtProxy/ULPProxy to be forwarded as necessary.
if (! mUlp->reportSvPolynomial(svPolynomial)) {
//Send to Internal Adapter later if needed by LA
}
}
void LocEngAdapter::setInSession(bool inSession)
{
mNavigating = inSession;
mLocApi->setInSession(inSession);
if (!mNavigating) {
mFixCriteria.mode = LOC_POSITION_MODE_INVALID;
}
}
void LocInternalAdapter::reportStatus(GpsStatusValue status)
{
sendMsg(new LocEngReportStatus(mLocEngAdapter, status));
}
void LocEngAdapter::reportStatus(GpsStatusValue status)
{
if (!mUlp->reportStatus(status)) {
mInternalAdapter->reportStatus(status);
}
}
inline
void LocEngAdapter::reportNmea(const char* nmea, int length)
{
sendMsg(new LocEngReportNmea(mOwner, nmea, length));
}
inline
bool LocEngAdapter::reportXtraServer(const char* url1,
const char* url2,
const char* url3,
const int maxlength)
{
if (mSupportsAgpsRequests) {
sendMsg(new LocEngReportXtraServer(mOwner, url1,
url2, url3, maxlength));
}
return mSupportsAgpsRequests;
}
inline
bool LocEngAdapter::requestATL(int connHandle, AGpsType agps_type)
{
if (mSupportsAgpsRequests) {
sendMsg(new LocEngRequestATL(mOwner,
connHandle, agps_type));
}
return mSupportsAgpsRequests;
}
inline
bool LocEngAdapter::releaseATL(int connHandle)
{
if (mSupportsAgpsRequests) {
sendMsg(new LocEngReleaseATL(mOwner, connHandle));
}
return mSupportsAgpsRequests;
}
inline
bool LocEngAdapter::requestXtraData()
{
if (mSupportsAgpsRequests) {
sendMsg(new LocEngRequestXtra(mOwner));
}
return mSupportsAgpsRequests;
}
inline
bool LocEngAdapter::requestTime()
{
if (mSupportsAgpsRequests) {
sendMsg(new LocEngRequestTime(mOwner));
}
return mSupportsAgpsRequests;
}
inline
bool LocEngAdapter::requestNiNotify(GpsNiNotification &notif, const void* data)
{
if (mSupportsAgpsRequests) {
notif.size = sizeof(notif);
notif.timeout = LOC_NI_NO_RESPONSE_TIME;
sendMsg(new LocEngRequestNi(mOwner, notif, data));
}
return mSupportsAgpsRequests;
}
inline
bool LocEngAdapter::requestSuplES(int connHandle)
{
if (mSupportsAgpsRequests)
sendMsg(new LocEngRequestSuplEs(mOwner, connHandle));
return mSupportsAgpsRequests;
}
inline
bool LocEngAdapter::reportDataCallOpened()
{
if(mSupportsAgpsRequests)
sendMsg(new LocEngSuplEsOpened(mOwner));
return mSupportsAgpsRequests;
}
inline
bool LocEngAdapter::reportDataCallClosed()
{
if(mSupportsAgpsRequests)
sendMsg(new LocEngSuplEsClosed(mOwner));
return mSupportsAgpsRequests;
}
inline
void LocEngAdapter::handleEngineDownEvent()
{
sendMsg(new LocEngDown(mOwner));
}
inline
void LocEngAdapter::handleEngineUpEvent()
{
sendMsg(new LocEngUp(mOwner));
}
enum loc_api_adapter_err LocEngAdapter::setTime(GpsUtcTime time,
int64_t timeReference,
int uncertainty)
{
loc_api_adapter_err result = LOC_API_ADAPTER_ERR_SUCCESS;
LOC_LOGD("%s:%d]: mSupportsTimeInjection is %d",
__func__, __LINE__, mSupportsTimeInjection);
if (mSupportsTimeInjection) {
LOC_LOGD("%s:%d]: Injecting time", __func__, __LINE__);
result = mLocApi->setTime(time, timeReference, uncertainty);
} else {
mSupportsTimeInjection = true;
}
return result;
}
enum loc_api_adapter_err LocEngAdapter::setXtraVersionCheck(int check)
{
enum loc_api_adapter_err ret;
ENTRY_LOG();
enum xtra_version_check eCheck;
switch (check) {
case 0:
eCheck = DISABLED;
break;
case 1:
eCheck = AUTO;
break;
case 2:
eCheck = XTRA2;
break;
case 3:
eCheck = XTRA3;
break;
default:
eCheck = DISABLED;
}
ret = mLocApi->setXtraVersionCheck(eCheck);
EXIT_LOG(%d, ret);
return ret;
}
void LocEngAdapter::reportGpsMeasurementData(GpsData &gpsMeasurementData)
{
sendMsg(new LocEngReportGpsMeasurement(mOwner,
gpsMeasurementData));
}
/*
Update Registration Mask
*/
void LocEngAdapter::updateRegistrationMask(LOC_API_ADAPTER_EVENT_MASK_T event,
loc_registration_mask_status isEnabled)
{
LOC_LOGD("entering %s", __func__);
int result = LOC_API_ADAPTER_ERR_FAILURE;
result = mLocApi->updateRegistrationMask(event, isEnabled);
if (result == LOC_API_ADAPTER_ERR_SUCCESS) {
LOC_LOGD("%s] update registration mask succeed.", __func__);
} else {
LOC_LOGE("%s] update registration mask failed.", __func__);
}
}
/*
Set Gnss Constellation Config
*/
bool LocEngAdapter::gnssConstellationConfig()
{
LOC_LOGD("entering %s", __func__);
bool result = false;
result = mLocApi->gnssConstellationConfig();
return result;
}
Reference in a new issue View git blame Copy permalink