gps/android/2.0/GnssConfiguration.cpp - SHIFTPHONES/android_device_shift_otter - Gitiles

 /*
  * Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
  * Not a Contribution
  */
 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "LocSvc_GnssConfigurationInterface"

 #include <log_util.h>
 #include "Gnss.h"
 #include "GnssConfiguration.h"
 #include "ContextBase.h"
 #include <android/hardware/gnss/1.0/types.h>

 namespace android {
 namespace hardware {
 namespace gnss {
 namespace V2_0 {
 namespace implementation {

 using ::android::hardware::gnss::V1_0::GnssConstellationType;
 using namespace loc_core;

 GnssConfiguration::GnssConfiguration(Gnss* gnss) : mGnss(gnss) {
 }

 // Methods from ::android::hardware::gps::V1_0::IGnssConfiguration follow.
 Return<bool> GnssConfiguration::setSuplEs(bool enabled)  {
     // deprecated function. Must return false to pass VTS
     return false;
 }

 Return<bool> GnssConfiguration::setSuplVersion(uint32_t version)  {
     if (mGnss == nullptr) {
         LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
         return false;
     }

     GnssConfig config;
     memset(&config, 0, sizeof(GnssConfig));
     config.size = sizeof(GnssConfig);
     config.flags = GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT;
     switch (version) {
         case 0x00020004:
             config.suplVersion = GNSS_CONFIG_SUPL_VERSION_2_0_4;
             break;
         case 0x00020002:
             config.suplVersion = GNSS_CONFIG_SUPL_VERSION_2_0_2;
             break;
         case 0x00020000:
             config.suplVersion = GNSS_CONFIG_SUPL_VERSION_2_0_0;
             break;
         case 0x00010000:
             config.suplVersion = GNSS_CONFIG_SUPL_VERSION_1_0_0;
             break;
         default:
             LOC_LOGE("%s]: invalid version: 0x%x.", __FUNCTION__, version);
             return false;
     }

     return mGnss->updateConfiguration(config);
 }

 Return<bool> GnssConfiguration::setSuplMode(uint8_t mode)  {
     if (mGnss == nullptr) {
         LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
         return false;
     }

     GnssConfig config;
     memset(&config, 0, sizeof(GnssConfig));
     config.size = sizeof(GnssConfig);
     config.flags = GNSS_CONFIG_FLAGS_SUPL_MODE_BIT;
     switch (mode) {
         case 0:
             config.suplModeMask = 0; // STANDALONE ONLY
             break;
         case 1:
             config.suplModeMask = GNSS_CONFIG_SUPL_MODE_MSB_BIT;
             break;
         case 2:
             config.suplModeMask = GNSS_CONFIG_SUPL_MODE_MSA_BIT;
             break;
         case 3:
             config.suplModeMask = GNSS_CONFIG_SUPL_MODE_MSB_BIT | GNSS_CONFIG_SUPL_MODE_MSA_BIT;
             break;
         default:
             LOC_LOGE("%s]: invalid mode: %d.", __FUNCTION__, mode);
             return false;
     }

     return mGnss->updateConfiguration(config);
 }

 Return<bool> GnssConfiguration::setLppProfile(uint8_t lppProfileMask) {
     if (mGnss == nullptr) {
         LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
         return false;
     }

     GnssConfig config = {};
     config.size = sizeof(GnssConfig);
     config.flags = GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT;
     config.lppProfileMask = GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE; //default

     if (lppProfileMask & (1<<0)) {
         config.lppProfileMask |= GNSS_CONFIG_LPP_PROFILE_USER_PLANE_BIT;
     }
     if (lppProfileMask & (1<<1)) {
         config.lppProfileMask |= GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE_BIT;
     }
     if (lppProfileMask & (1<<2)) {
         config.lppProfileMask |= GNSS_CONFIG_LPP_PROFILE_USER_PLANE_OVER_NR5G_SA_BIT;
     }
     if (lppProfileMask & (1<<3)) {
         config.lppProfileMask |= GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE_OVER_NR5G_SA_BIT;
     }

     return mGnss->updateConfiguration(config);
 }

 Return<bool> GnssConfiguration::setGlonassPositioningProtocol(uint8_t protocol) {
     if (mGnss == nullptr) {
         LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
         return false;
     }

     GnssConfig config;
     memset(&config, 0, sizeof(GnssConfig));
     config.size = sizeof(GnssConfig);

     config.flags = GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT;
     if (protocol & (1<<0)) {
         config.aGlonassPositionProtocolMask |= GNSS_CONFIG_RRC_CONTROL_PLANE_BIT;
     }
     if (protocol & (1<<1)) {
         config.aGlonassPositionProtocolMask |= GNSS_CONFIG_RRLP_USER_PLANE_BIT;
     }
     if (protocol & (1<<2)) {
         config.aGlonassPositionProtocolMask |= GNSS_CONFIG_LLP_USER_PLANE_BIT;
     }
     if (protocol & (1<<3)) {
         config.aGlonassPositionProtocolMask |= GNSS_CONFIG_LLP_CONTROL_PLANE_BIT;
     }

     return mGnss->updateConfiguration(config);
 }

 Return<bool> GnssConfiguration::setGpsLock(uint8_t lock) {

     if (mGnss == nullptr) {
         LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
         return false;
     }

     GnssConfig config = {};
     config.size = sizeof(GnssConfig);
     config.flags = GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT;
     switch (lock) {
     case 0:
         config.gpsLock = GNSS_CONFIG_GPS_LOCK_NONE;
         break;
     case 1:
         config.gpsLock = GNSS_CONFIG_GPS_LOCK_MO;
         break;
     case 2:
         config.gpsLock = GNSS_CONFIG_GPS_LOCK_NI;
         break;
     case 3:
         config.gpsLock = GNSS_CONFIG_GPS_LOCK_MO_AND_NI;
         break;
     default:
         LOC_LOGE("%s]: invalid lock: %d.", __FUNCTION__, lock);
         return false;
     }

     mGnss->updateConfiguration(config);
     // Must return false to pass VTS
     return false;
 }

 Return<bool> GnssConfiguration::setEmergencySuplPdn(bool enabled) {
     if (mGnss == nullptr) {
         LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
         return false;
     }

     GnssConfig config;
     memset(&config, 0, sizeof(GnssConfig));
     config.size = sizeof(GnssConfig);
     config.flags = GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT;
     config.emergencyPdnForEmergencySupl = (enabled ?
             GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES :
             GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO);

     return mGnss->updateConfiguration(config);
 }

 // Methods from ::android::hardware::gnss::V1_1::IGnssConfiguration follow.
 Return<bool> GnssConfiguration::setBlacklist(
             const hidl_vec<GnssConfiguration::BlacklistedSource>& blacklist) {

     ENTRY_LOG_CALLFLOW();
     if (nullptr == mGnss) {
         LOC_LOGe("mGnss is null");
         return false;
     }

     // blValid is true if blacklist is empty, i.e. clearing the BL;
     // if blacklist is not empty, blValid is initialied to false, and later
     // updated in the for loop to become true only if there is at least
     // one {constellation, svid} in the list that is valid.
     bool blValid = (0 == blacklist.size());
     GnssConfig config;
     memset(&config, 0, sizeof(GnssConfig));
     config.size = sizeof(GnssConfig);
     config.flags = GNSS_CONFIG_FLAGS_BLACKLISTED_SV_IDS_BIT;
     config.blacklistedSvIds.clear();

     GnssSvIdSource source = {};
     for (int idx = 0; idx < (int)blacklist.size(); idx++) {
         // Set blValid true if any one source is valid
         blValid = setBlacklistedSource(source, blacklist[idx]) || blValid;
         config.blacklistedSvIds.push_back(source);
     }

     // Update configuration only if blValid is true
     // i.e. only if atleast one source is valid for blacklisting
     return (blValid && mGnss->updateConfiguration(config));
 }

 bool GnssConfiguration::setBlacklistedSource(
         GnssSvIdSource& copyToSource,
         const GnssConfiguration::BlacklistedSource& copyFromSource) {

     bool retVal = true;
     uint16_t svIdOffset = 0;
     copyToSource.size = sizeof(GnssSvIdSource);
     copyToSource.svId = copyFromSource.svid;

     switch(copyFromSource.constellation) {
     case GnssConstellationType::GPS:
         copyToSource.constellation = GNSS_SV_TYPE_GPS;
         LOC_LOGe("GPS SVs can't be blacklisted.");
         retVal = false;
         break;
     case GnssConstellationType::SBAS:
         copyToSource.constellation = GNSS_SV_TYPE_SBAS;
         LOC_LOGe("SBAS SVs can't be blacklisted.");
         retVal = false;
         break;
     case GnssConstellationType::GLONASS:
         copyToSource.constellation = GNSS_SV_TYPE_GLONASS;
         svIdOffset = GNSS_SV_CONFIG_GLO_INITIAL_SV_ID - 1;
         break;
     case GnssConstellationType::QZSS:
         copyToSource.constellation = GNSS_SV_TYPE_QZSS;
         svIdOffset = 0;
         break;
     case GnssConstellationType::BEIDOU:
         copyToSource.constellation = GNSS_SV_TYPE_BEIDOU;
         svIdOffset = GNSS_SV_CONFIG_BDS_INITIAL_SV_ID - 1;
         break;
     case GnssConstellationType::GALILEO:
         copyToSource.constellation = GNSS_SV_TYPE_GALILEO;
         svIdOffset = GNSS_SV_CONFIG_GAL_INITIAL_SV_ID - 1;
         break;
     default:
         copyToSource.constellation = GNSS_SV_TYPE_UNKNOWN;
         LOC_LOGe("Invalid constellation %hhu", copyFromSource.constellation);
         retVal = false;
         break;
     }

     if (copyToSource.svId > 0 && svIdOffset > 0) {
         copyToSource.svId += svIdOffset;
     }

     return retVal;
 }

 // Methods from ::android::hardware::gnss::V2_0::IGnssConfiguration follow.
 Return<bool> GnssConfiguration::setEsExtensionSec(uint32_t emergencyExtensionSeconds) {
     ENTRY_LOG_CALLFLOW();
     if (mGnss == nullptr) {
         LOC_LOGe("mGnss is nullptr");
         return false;
     }

     GnssConfig config;
     memset(&config, 0, sizeof(GnssConfig));
     config.size = sizeof(GnssConfig);
     config.flags = GNSS_CONFIG_FLAGS_EMERGENCY_EXTENSION_SECONDS_BIT;
     config.emergencyExtensionSeconds = emergencyExtensionSeconds;

     return mGnss->updateConfiguration(config);
 }

 }  // namespace implementation
 }  // namespace V2_0
 }  // namespace gnss
 }  // namespace hardware
 }  // namespace android
	/*
	* Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
	* Not a Contribution
	*/
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "LocSvc_GnssConfigurationInterface"

	#include <log_util.h>
	#include "Gnss.h"
	#include "GnssConfiguration.h"
	#include "ContextBase.h"
	#include <android/hardware/gnss/1.0/types.h>

	namespace android {
	namespace hardware {
	namespace gnss {
	namespace V2_0 {
	namespace implementation {

	using ::android::hardware::gnss::V1_0::GnssConstellationType;
	using namespace loc_core;

	GnssConfiguration::GnssConfiguration(Gnss* gnss) : mGnss(gnss) {
	}

	// Methods from ::android::hardware::gps::V1_0::IGnssConfiguration follow.
	Return<bool> GnssConfiguration::setSuplEs(bool enabled) {
	// deprecated function. Must return false to pass VTS
	return false;
	}

	Return<bool> GnssConfiguration::setSuplVersion(uint32_t version) {
	if (mGnss == nullptr) {
	LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
	return false;
	}

	GnssConfig config;
	memset(&config, 0, sizeof(GnssConfig));
	config.size = sizeof(GnssConfig);
	config.flags = GNSS_CONFIG_FLAGS_SUPL_VERSION_VALID_BIT;
	switch (version) {
	case 0x00020004:
	config.suplVersion = GNSS_CONFIG_SUPL_VERSION_2_0_4;
	break;
	case 0x00020002:
	config.suplVersion = GNSS_CONFIG_SUPL_VERSION_2_0_2;
	break;
	case 0x00020000:
	config.suplVersion = GNSS_CONFIG_SUPL_VERSION_2_0_0;
	break;
	case 0x00010000:
	config.suplVersion = GNSS_CONFIG_SUPL_VERSION_1_0_0;
	break;
	default:
	LOC_LOGE("%s]: invalid version: 0x%x.", __FUNCTION__, version);
	return false;
	}

	return mGnss->updateConfiguration(config);
	}

	Return<bool> GnssConfiguration::setSuplMode(uint8_t mode) {
	if (mGnss == nullptr) {
	LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
	return false;
	}

	GnssConfig config;
	memset(&config, 0, sizeof(GnssConfig));
	config.size = sizeof(GnssConfig);
	config.flags = GNSS_CONFIG_FLAGS_SUPL_MODE_BIT;
	switch (mode) {
	case 0:
	config.suplModeMask = 0; // STANDALONE ONLY
	break;
	case 1:
	config.suplModeMask = GNSS_CONFIG_SUPL_MODE_MSB_BIT;
	break;
	case 2:
	config.suplModeMask = GNSS_CONFIG_SUPL_MODE_MSA_BIT;
	break;
	case 3:
	config.suplModeMask = GNSS_CONFIG_SUPL_MODE_MSB_BIT \| GNSS_CONFIG_SUPL_MODE_MSA_BIT;
	break;
	default:
	LOC_LOGE("%s]: invalid mode: %d.", __FUNCTION__, mode);
	return false;
	}

	return mGnss->updateConfiguration(config);
	}

	Return<bool> GnssConfiguration::setLppProfile(uint8_t lppProfileMask) {
	if (mGnss == nullptr) {
	LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
	return false;
	}

	GnssConfig config = {};
	config.size = sizeof(GnssConfig);
	config.flags = GNSS_CONFIG_FLAGS_LPP_PROFILE_VALID_BIT;
	config.lppProfileMask = GNSS_CONFIG_LPP_PROFILE_RRLP_ON_LTE; //default

	if (lppProfileMask & (1<<0)) {
	config.lppProfileMask \|= GNSS_CONFIG_LPP_PROFILE_USER_PLANE_BIT;
	}
	if (lppProfileMask & (1<<1)) {
	config.lppProfileMask \|= GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE_BIT;
	}
	if (lppProfileMask & (1<<2)) {
	config.lppProfileMask \|= GNSS_CONFIG_LPP_PROFILE_USER_PLANE_OVER_NR5G_SA_BIT;
	}
	if (lppProfileMask & (1<<3)) {
	config.lppProfileMask \|= GNSS_CONFIG_LPP_PROFILE_CONTROL_PLANE_OVER_NR5G_SA_BIT;
	}

	return mGnss->updateConfiguration(config);
	}

	Return<bool> GnssConfiguration::setGlonassPositioningProtocol(uint8_t protocol) {
	if (mGnss == nullptr) {
	LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
	return false;
	}

	GnssConfig config;
	memset(&config, 0, sizeof(GnssConfig));
	config.size = sizeof(GnssConfig);

	config.flags = GNSS_CONFIG_FLAGS_AGLONASS_POSITION_PROTOCOL_VALID_BIT;
	if (protocol & (1<<0)) {
	config.aGlonassPositionProtocolMask \|= GNSS_CONFIG_RRC_CONTROL_PLANE_BIT;
	}
	if (protocol & (1<<1)) {
	config.aGlonassPositionProtocolMask \|= GNSS_CONFIG_RRLP_USER_PLANE_BIT;
	}
	if (protocol & (1<<2)) {
	config.aGlonassPositionProtocolMask \|= GNSS_CONFIG_LLP_USER_PLANE_BIT;
	}
	if (protocol & (1<<3)) {
	config.aGlonassPositionProtocolMask \|= GNSS_CONFIG_LLP_CONTROL_PLANE_BIT;
	}

	return mGnss->updateConfiguration(config);
	}

	Return<bool> GnssConfiguration::setGpsLock(uint8_t lock) {

	if (mGnss == nullptr) {
	LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
	return false;
	}

	GnssConfig config = {};
	config.size = sizeof(GnssConfig);
	config.flags = GNSS_CONFIG_FLAGS_GPS_LOCK_VALID_BIT;
	switch (lock) {
	case 0:
	config.gpsLock = GNSS_CONFIG_GPS_LOCK_NONE;
	break;
	case 1:
	config.gpsLock = GNSS_CONFIG_GPS_LOCK_MO;
	break;
	case 2:
	config.gpsLock = GNSS_CONFIG_GPS_LOCK_NI;
	break;
	case 3:
	config.gpsLock = GNSS_CONFIG_GPS_LOCK_MO_AND_NI;
	break;
	default:
	LOC_LOGE("%s]: invalid lock: %d.", __FUNCTION__, lock);
	return false;
	}

	mGnss->updateConfiguration(config);
	// Must return false to pass VTS
	return false;
	}

	Return<bool> GnssConfiguration::setEmergencySuplPdn(bool enabled) {
	if (mGnss == nullptr) {
	LOC_LOGE("%s]: mGnss is nullptr", __FUNCTION__);
	return false;
	}

	GnssConfig config;
	memset(&config, 0, sizeof(GnssConfig));
	config.size = sizeof(GnssConfig);
	config.flags = GNSS_CONFIG_FLAGS_EM_PDN_FOR_EM_SUPL_VALID_BIT;
	config.emergencyPdnForEmergencySupl = (enabled ?
	GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_YES :
	GNSS_CONFIG_EMERGENCY_PDN_FOR_EMERGENCY_SUPL_NO);

	return mGnss->updateConfiguration(config);
	}

	// Methods from ::android::hardware::gnss::V1_1::IGnssConfiguration follow.
	Return<bool> GnssConfiguration::setBlacklist(
	const hidl_vec<GnssConfiguration::BlacklistedSource>& blacklist) {

	ENTRY_LOG_CALLFLOW();
	if (nullptr == mGnss) {
	LOC_LOGe("mGnss is null");
	return false;
	}

	// blValid is true if blacklist is empty, i.e. clearing the BL;
	// if blacklist is not empty, blValid is initialied to false, and later
	// updated in the for loop to become true only if there is at least
	// one {constellation, svid} in the list that is valid.
	bool blValid = (0 == blacklist.size());
	GnssConfig config;
	memset(&config, 0, sizeof(GnssConfig));
	config.size = sizeof(GnssConfig);
	config.flags = GNSS_CONFIG_FLAGS_BLACKLISTED_SV_IDS_BIT;
	config.blacklistedSvIds.clear();

	GnssSvIdSource source = {};
	for (int idx = 0; idx < (int)blacklist.size(); idx++) {
	// Set blValid true if any one source is valid
	blValid = setBlacklistedSource(source, blacklist[idx]) \|\| blValid;
	config.blacklistedSvIds.push_back(source);
	}

	// Update configuration only if blValid is true
	// i.e. only if atleast one source is valid for blacklisting
	return (blValid && mGnss->updateConfiguration(config));
	}

	bool GnssConfiguration::setBlacklistedSource(
	GnssSvIdSource& copyToSource,
	const GnssConfiguration::BlacklistedSource& copyFromSource) {

	bool retVal = true;
	uint16_t svIdOffset = 0;
	copyToSource.size = sizeof(GnssSvIdSource);
	copyToSource.svId = copyFromSource.svid;

	switch(copyFromSource.constellation) {
	case GnssConstellationType::GPS:
	copyToSource.constellation = GNSS_SV_TYPE_GPS;
	LOC_LOGe("GPS SVs can't be blacklisted.");
	retVal = false;
	break;
	case GnssConstellationType::SBAS:
	copyToSource.constellation = GNSS_SV_TYPE_SBAS;
	LOC_LOGe("SBAS SVs can't be blacklisted.");
	retVal = false;
	break;
	case GnssConstellationType::GLONASS:
	copyToSource.constellation = GNSS_SV_TYPE_GLONASS;
	svIdOffset = GNSS_SV_CONFIG_GLO_INITIAL_SV_ID - 1;
	break;
	case GnssConstellationType::QZSS:
	copyToSource.constellation = GNSS_SV_TYPE_QZSS;
	svIdOffset = 0;
	break;
	case GnssConstellationType::BEIDOU:
	copyToSource.constellation = GNSS_SV_TYPE_BEIDOU;
	svIdOffset = GNSS_SV_CONFIG_BDS_INITIAL_SV_ID - 1;
	break;
	case GnssConstellationType::GALILEO:
	copyToSource.constellation = GNSS_SV_TYPE_GALILEO;
	svIdOffset = GNSS_SV_CONFIG_GAL_INITIAL_SV_ID - 1;
	break;
	default:
	copyToSource.constellation = GNSS_SV_TYPE_UNKNOWN;
	LOC_LOGe("Invalid constellation %hhu", copyFromSource.constellation);
	retVal = false;
	break;
	}

	if (copyToSource.svId > 0 && svIdOffset > 0) {
	copyToSource.svId += svIdOffset;
	}

	return retVal;
	}

	// Methods from ::android::hardware::gnss::V2_0::IGnssConfiguration follow.
	Return<bool> GnssConfiguration::setEsExtensionSec(uint32_t emergencyExtensionSeconds) {
	ENTRY_LOG_CALLFLOW();
	if (mGnss == nullptr) {
	LOC_LOGe("mGnss is nullptr");
	return false;
	}

	GnssConfig config;
	memset(&config, 0, sizeof(GnssConfig));
	config.size = sizeof(GnssConfig);
	config.flags = GNSS_CONFIG_FLAGS_EMERGENCY_EXTENSION_SECONDS_BIT;
	config.emergencyExtensionSeconds = emergencyExtensionSeconds;

	return mGnss->updateConfiguration(config);
	}

	} // namespace implementation
	} // namespace V2_0
	} // namespace gnss
	} // namespace hardware
	} // namespace android