| /* 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)); |
| } |
| |
| 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::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 ¬if, 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; |
| } |
