diff --git a/services/core/jni/Android.bp b/services/core/jni/Android.bp index 30f6fa68396ea..d6a56ba531d0d 100644 --- a/services/core/jni/Android.bp +++ b/services/core/jni/Android.bp @@ -21,6 +21,7 @@ cc_library_static { "BroadcastRadio/TunerCallback.cpp", "BroadcastRadio/convert.cpp", "BroadcastRadio/regions.cpp", + "gnss/GnssConfiguration.cpp", "stats/PowerStatsPuller.cpp", "stats/SubsystemSleepStatePuller.cpp", "com_android_server_adb_AdbDebuggingManager.cpp", diff --git a/services/core/jni/com_android_server_location_GnssLocationProvider.cpp b/services/core/jni/com_android_server_location_GnssLocationProvider.cpp index 31b9ad617fba0..e9d048a699667 100644 --- a/services/core/jni/com_android_server_location_GnssLocationProvider.cpp +++ b/services/core/jni/com_android_server_location_GnssLocationProvider.cpp @@ -14,8 +14,8 @@ * limitations under the License. */ -#define LOG_TAG "GnssLocationProvider" - +// Define LOG_TAG and LOG_NDEBUG before to overwrite the default values. +#define LOG_TAG "GnssLocationProviderJni" #define LOG_NDEBUG 0 #include @@ -39,6 +39,7 @@ #include #include "android_runtime/AndroidRuntime.h" #include "android_runtime/Log.h" +#include "gnss/GnssConfiguration.h" #include "hardware_legacy/power.h" #include "jni.h" #include "utils/Log.h" @@ -59,7 +60,6 @@ static jclass class_gnssMeasurement; static jclass class_location; static jclass class_gnssNavigationMessage; static jclass class_gnssClock; -static jclass class_gnssConfiguration_halInterfaceVersion; static jclass class_gnssAntennaInfoBuilder; static jclass class_phaseCenterOffset; static jclass class_sphericalCorrections; @@ -125,7 +125,6 @@ static jmethodID method_locationCtor; static jmethodID method_gnssNavigationMessageCtor; static jmethodID method_gnssClockCtor; static jmethodID method_gnssMeasurementCtor; -static jmethodID method_halInterfaceVersionCtor; static jmethodID method_gnssAntennaInfoBuilderCtor; static jmethodID method_phaseCenterOffsetCtor; static jmethodID method_sphericalCorrectionsCtor; @@ -149,6 +148,7 @@ using android::status_t; using android::String16; using android::wp; using android::binder::Status; +using android::gnss::GnssConfigurationInterface; using android::hardware::Return; using android::hardware::Void; @@ -192,10 +192,6 @@ using IGnss_V3_0 = android::hardware::gnss::V3_0::IGnss; using IGnssCallback_V1_0 = android::hardware::gnss::V1_0::IGnssCallback; using IGnssCallback_V2_0 = android::hardware::gnss::V2_0::IGnssCallback; using IGnssCallback_V2_1 = android::hardware::gnss::V2_1::IGnssCallback; -using IGnssConfiguration_V1_0 = android::hardware::gnss::V1_0::IGnssConfiguration; -using IGnssConfiguration_V1_1 = android::hardware::gnss::V1_1::IGnssConfiguration; -using IGnssConfiguration_V2_0 = android::hardware::gnss::V2_0::IGnssConfiguration; -using IGnssConfiguration_V2_1 = android::hardware::gnss::V2_1::IGnssConfiguration; using IGnssDebug_V1_0 = android::hardware::gnss::V1_0::IGnssDebug; using IGnssDebug_V2_0 = android::hardware::gnss::V2_0::IGnssDebug; using IGnssAntennaInfo = android::hardware::gnss::V2_1::IGnssAntennaInfo; @@ -269,11 +265,6 @@ sp gnssBatchingIface = nullptr; sp gnssBatchingIface_V2_0 = nullptr; sp gnssDebugIface = nullptr; sp gnssDebugIface_V2_0 = nullptr; -sp gnssConfigurationAidlIface = nullptr; -sp gnssConfigurationIface = nullptr; -sp gnssConfigurationIface_V1_1 = nullptr; -sp gnssConfigurationIface_V2_0 = nullptr; -sp gnssConfigurationIface_V2_1 = nullptr; sp gnssNiIface = nullptr; sp gnssMeasurementIface = nullptr; sp gnssMeasurementIface_V1_1 = nullptr; @@ -285,6 +276,8 @@ sp gnssCorrectionsIface_V1_1 = nullptr; sp gnssVisibilityControlIface = nullptr; sp gnssAntennaInfoIface = nullptr; +std::unique_ptr gnssConfigurationIface = nullptr; + #define WAKE_LOCK_NAME "GPS" namespace android { @@ -467,12 +460,6 @@ static jboolean checkAidlStatus(const Status& status, const char* errorMessage) return JNI_TRUE; } -static jobject createHalInterfaceVersionJavaObject(JNIEnv* env, jint major, jint minor) { - jobject version = env->NewObject(class_gnssConfiguration_halInterfaceVersion, - method_halInterfaceVersionCtor, major, minor); - return version; -} - struct ScopedJniString { ScopedJniString(JNIEnv* env, jstring javaString) : mEnv(env), mJavaString(javaString) { mNativeString = mEnv->GetStringUTFChars(mJavaString, nullptr); @@ -2159,13 +2146,6 @@ static void android_location_GnssNative_class_init_once(JNIEnv* env, jclass claz class_gnssClock = (jclass) env->NewGlobalRef(gnssClockClass); method_gnssClockCtor = env->GetMethodID(class_gnssClock, "", "()V"); - jclass gnssConfiguration_halInterfaceVersionClass = env->FindClass( - "com/android/server/location/gnss/GnssConfiguration$HalInterfaceVersion"); - class_gnssConfiguration_halInterfaceVersion = - (jclass) env->NewGlobalRef(gnssConfiguration_halInterfaceVersionClass); - method_halInterfaceVersionCtor = - env->GetMethodID(class_gnssConfiguration_halInterfaceVersion, "", "(II)V"); - jclass arrayListClass = env->FindClass("java/util/ArrayList"); class_arrayList = (jclass)env->NewGlobalRef(arrayListClass); method_arrayListCtor = env->GetMethodID(class_arrayList, "", "()V"); @@ -2173,6 +2153,8 @@ static void android_location_GnssNative_class_init_once(JNIEnv* env, jclass claz jclass doubleArrayClass = env->FindClass("[D"); class_doubleArray = (jclass)env->NewGlobalRef(doubleArrayClass); + + gnss::GnssConfiguration_class_init_once(env); } /* Initialization needed at system boot and whenever GNSS service dies. */ @@ -2373,44 +2355,38 @@ static void android_location_GnssNative_init_once(JNIEnv* env, jobject obj, if (gnssHalAidl != nullptr) { sp gnssConfigurationAidl; auto status = gnssHalAidl->getExtensionGnssConfiguration(&gnssConfigurationAidl); - if (status.isOk()) { - gnssConfigurationAidlIface = gnssConfigurationAidl; - } else { - ALOGD("Unable to get a handle to GnssConfiguration AIDL interface."); + if (checkAidlStatus(status, + "Unable to get a handle to GnssConfiguration AIDL interface.")) { + gnssConfigurationIface = + std::make_unique(gnssConfigurationAidl); } } else if (gnssHal_V2_1 != nullptr) { auto gnssConfiguration = gnssHal_V2_1->getExtensionGnssConfiguration_2_1(); - if (!gnssConfiguration.isOk()) { - ALOGD("Unable to get a handle to GnssConfiguration_V2_1"); - } else { - gnssConfigurationIface_V2_1 = gnssConfiguration; - gnssConfigurationIface_V2_0 = gnssConfigurationIface_V2_1; - gnssConfigurationIface_V1_1 = gnssConfigurationIface_V2_1; - gnssConfigurationIface = gnssConfigurationIface_V2_1; + if (checkHidlReturn(gnssConfiguration, + "Unable to get a handle to GnssConfiguration_V2_1")) { + gnssConfigurationIface = + std::make_unique(gnssConfiguration); } } else if (gnssHal_V2_0 != nullptr) { auto gnssConfiguration = gnssHal_V2_0->getExtensionGnssConfiguration_2_0(); - if (!gnssConfiguration.isOk()) { - ALOGD("Unable to get a handle to GnssConfiguration_V2_0"); - } else { - gnssConfigurationIface_V2_0 = gnssConfiguration; - gnssConfigurationIface_V1_1 = gnssConfigurationIface_V2_0; - gnssConfigurationIface = gnssConfigurationIface_V2_0; + if (checkHidlReturn(gnssConfiguration, + "Unable to get a handle to GnssConfiguration_V2_0")) { + gnssConfigurationIface = + std::make_unique(gnssConfiguration); } } else if (gnssHal_V1_1 != nullptr) { auto gnssConfiguration = gnssHal_V1_1->getExtensionGnssConfiguration_1_1(); - if (!gnssConfiguration.isOk()) { - ALOGD("Unable to get a handle to GnssConfiguration_V1_1"); - } else { - gnssConfigurationIface_V1_1 = gnssConfiguration; - gnssConfigurationIface = gnssConfigurationIface_V1_1; + if (checkHidlReturn(gnssConfiguration, + "Unable to get a handle to GnssConfiguration_V1_1")) { + gnssConfigurationIface = + std::make_unique(gnssConfiguration); } } else { - auto gnssConfiguration_V1_0 = gnssHal->getExtensionGnssConfiguration(); - if (!gnssConfiguration_V1_0.isOk()) { - ALOGD("Unable to get a handle to GnssConfiguration"); - } else { - gnssConfigurationIface = gnssConfiguration_V1_0; + auto gnssConfiguration = gnssHal->getExtensionGnssConfiguration(); + if (checkHidlReturn(gnssConfiguration, + "Unable to get a handle to GnssConfiguration_V1_0")) { + gnssConfigurationIface = + std::make_unique(gnssConfiguration); } } @@ -2466,25 +2442,10 @@ static jboolean android_location_GnssNetworkConnectivityHandler_is_agps_ril_supp static jobject android_location_GnssConfiguration_get_gnss_configuration_version( JNIEnv* env, jclass /* jclazz */) { - jint major, minor; - if (gnssConfigurationIface_V2_1 != nullptr) { - major = 2; - minor = 1; - } - else if (gnssConfigurationIface_V2_0 != nullptr) { - major = 2; - minor = 0; - } else if (gnssConfigurationIface_V1_1 != nullptr) { - major = 1; - minor = 1; - } else if (gnssConfigurationIface != nullptr) { - major = 1; - minor = 0; - } else { + if (gnssConfigurationIface == nullptr) { return nullptr; } - - return createHalInterfaceVersionJavaObject(env, major, minor); + return gnssConfigurationIface->getVersion(env); } /* Initialization needed each time the GPS service is shutdown. */ @@ -3486,203 +3447,89 @@ static jboolean android_location_GnssNavigationMessageProvider_stop_navigation_m static jboolean android_location_GnssConfiguration_set_emergency_supl_pdn(JNIEnv*, jobject, jint emergencySuplPdn) { - if (gnssConfigurationIface == nullptr && gnssConfigurationAidlIface == nullptr) { + if (gnssConfigurationIface == nullptr) { ALOGE("%s: IGnssConfiguration interface not available.", __func__); return JNI_FALSE; } - - if (gnssConfigurationAidlIface != nullptr) { - auto status = gnssConfigurationAidlIface->setEmergencySuplPdn(emergencySuplPdn); - return checkAidlStatus(status, "gnssConfigurationAidlIface setEmergencySuplPdn() failed."); - } - - auto result = gnssConfigurationIface->setEmergencySuplPdn(emergencySuplPdn); - return checkHidlReturn(result, "IGnssConfiguration setEmergencySuplPdn() failed."); + return gnssConfigurationIface->setEmergencySuplPdn(emergencySuplPdn); } static jboolean android_location_GnssConfiguration_set_supl_version(JNIEnv*, jobject, jint version) { - if (gnssConfigurationIface == nullptr && gnssConfigurationAidlIface == nullptr) { + if (gnssConfigurationIface == nullptr) { ALOGE("%s: IGnssConfiguration interface not available.", __func__); return JNI_FALSE; } - - if (gnssConfigurationAidlIface != nullptr) { - auto status = gnssConfigurationAidlIface->setSuplVersion(version); - return checkAidlStatus(status, "gnssConfigurationAidlIface setSuplVersion() failed."); - } - - auto result = gnssConfigurationIface->setSuplVersion(version); - return checkHidlReturn(result, "IGnssConfiguration setSuplVersion() failed."); + return gnssConfigurationIface->setSuplVersion(version); } static jboolean android_location_GnssConfiguration_set_supl_es(JNIEnv*, jobject, jint suplEs) { - if (gnssConfigurationIface_V2_0 != nullptr || gnssConfigurationIface_V2_1 != nullptr || - gnssConfigurationAidlIface != nullptr) { - ALOGI("Config parameter SUPL_ES is deprecated in IGnssConfiguration.hal version 2.0 and higher."); - return JNI_FALSE; - } - if (gnssConfigurationIface == nullptr) { ALOGE("%s: IGnssConfiguration interface not available.", __func__); return JNI_FALSE; } - - auto result = gnssConfigurationIface->setSuplEs(suplEs); - return checkHidlReturn(result, "IGnssConfiguration setSuplEs() failed."); + return gnssConfigurationIface->setSuplEs(suplEs); } static jboolean android_location_GnssConfiguration_set_supl_mode(JNIEnv*, jobject, jint mode) { - if (gnssConfigurationIface == nullptr && gnssConfigurationAidlIface == nullptr) { + if (gnssConfigurationIface == nullptr) { ALOGE("%s: IGnssConfiguration interface not available.", __func__); return JNI_FALSE; } - - if (gnssConfigurationAidlIface != nullptr) { - auto status = gnssConfigurationAidlIface->setSuplMode(mode); - return checkAidlStatus(status, "gnssConfigurationAidlIface setSuplMode() failed."); - } - - auto result = gnssConfigurationIface->setSuplMode(mode); - return checkHidlReturn(result, "IGnssConfiguration setSuplMode() failed."); + return gnssConfigurationIface->setSuplMode(mode); } static jboolean android_location_GnssConfiguration_set_gps_lock(JNIEnv*, jobject, jint gpsLock) { - if (gnssConfigurationIface_V2_0 != nullptr || gnssConfigurationIface_V2_1 != nullptr || - gnssConfigurationAidlIface != nullptr) { - ALOGI("Config parameter GPS_LOCK is deprecated in IGnssConfiguration.hal version 2.0."); - return JNI_FALSE; - } - if (gnssConfigurationIface == nullptr) { ALOGE("%s: IGnssConfiguration interface not available.", __func__); return JNI_FALSE; } - - auto result = gnssConfigurationIface->setGpsLock(gpsLock); - return checkHidlReturn(result, "IGnssConfiguration setGpsLock() failed."); + return gnssConfigurationIface->setGpsLock(gpsLock); } static jboolean android_location_GnssConfiguration_set_lpp_profile(JNIEnv*, jobject, jint lppProfile) { - if (gnssConfigurationIface == nullptr && gnssConfigurationAidlIface == nullptr) { + if (gnssConfigurationIface == nullptr) { ALOGE("%s: IGnssConfiguration interface not available.", __func__); return JNI_FALSE; } - - if (gnssConfigurationAidlIface != nullptr) { - auto status = gnssConfigurationAidlIface->setLppProfile(lppProfile); - return checkAidlStatus(status, "gnssConfigurationAidlIface setLppProfile() failed."); - } - - auto result = gnssConfigurationIface->setLppProfile(lppProfile); - return checkHidlReturn(result, "IGnssConfiguration setLppProfile() failed."); + return gnssConfigurationIface->setLppProfile(lppProfile); } static jboolean android_location_GnssConfiguration_set_gnss_pos_protocol_select(JNIEnv*, jobject, jint gnssPosProtocol) { - if (gnssConfigurationIface == nullptr && gnssConfigurationAidlIface == nullptr) { + if (gnssConfigurationIface == nullptr) { ALOGE("%s: IGnssConfiguration interface not available.", __func__); return JNI_FALSE; } - - if (gnssConfigurationAidlIface != nullptr) { - auto status = gnssConfigurationAidlIface->setGlonassPositioningProtocol(gnssPosProtocol); - return checkAidlStatus(status, - "gnssConfigurationAidlIface setGlonassPositioningProtocol() " - "failed."); - } - - auto result = gnssConfigurationIface->setGlonassPositioningProtocol(gnssPosProtocol); - return checkHidlReturn(result, "IGnssConfiguration setGlonassPositioningProtocol() failed."); + return gnssConfigurationIface->setGlonassPositioningProtocol(gnssPosProtocol); } static jboolean android_location_GnssConfiguration_set_satellite_blacklist( JNIEnv* env, jobject, jintArray constellations, jintArray sv_ids) { - if (gnssConfigurationIface_V1_1 == nullptr && gnssConfigurationIface_V2_1 == nullptr && - gnssConfigurationAidlIface == nullptr) { + if (gnssConfigurationIface == nullptr) { ALOGI("IGnssConfiguration interface does not support satellite blacklist."); return JNI_FALSE; } - - jint *constellation_array = env->GetIntArrayElements(constellations, 0); - if (nullptr == constellation_array) { - ALOGI("GetIntArrayElements returns nullptr."); - return JNI_FALSE; - } - jsize length = env->GetArrayLength(constellations); - - jint *sv_id_array = env->GetIntArrayElements(sv_ids, 0); - if (nullptr == sv_id_array) { - ALOGI("GetIntArrayElements returns nullptr."); - return JNI_FALSE; - } - - if (length != env->GetArrayLength(sv_ids)) { - ALOGI("Lengths of constellations and sv_ids are inconsistent."); - return JNI_FALSE; - } - - if (gnssConfigurationAidlIface != nullptr) { - std::vector sources; - sources.resize(length); - - for (int i = 0; i < length; i++) { - sources[i].constellation = static_cast(constellation_array[i]); - sources[i].svid = sv_id_array[i]; - } - - auto status = gnssConfigurationAidlIface->setBlocklist(sources); - return checkAidlStatus(status, "gnssConfigurationAidlIface setBlocklist() failed."); - } else if (gnssConfigurationIface_V2_1 != nullptr) { - hidl_vec sources; - sources.resize(length); - - for (int i = 0; i < length; i++) { - sources[i].constellation = static_cast(constellation_array[i]); - sources[i].svid = sv_id_array[i]; - } - - auto result = gnssConfigurationIface_V2_1->setBlacklist_2_1(sources); - return checkHidlReturn(result, "IGnssConfiguration_V2_1 setBlacklist_2_1() failed."); - } - - hidl_vec sources; - sources.resize(length); - - for (int i = 0; i < length; i++) { - sources[i].constellation = static_cast(constellation_array[i]); - sources[i].svid = sv_id_array[i]; - } - - auto result = gnssConfigurationIface_V1_1->setBlacklist(sources); - return checkHidlReturn(result, "IGnssConfiguration setBlacklist() failed."); + return gnssConfigurationIface->setBlocklist(env, constellations, sv_ids); } static jboolean android_location_GnssConfiguration_set_es_extension_sec( JNIEnv*, jobject, jint emergencyExtensionSeconds) { - if (gnssConfigurationIface_V2_0 == nullptr && gnssConfigurationAidlIface == nullptr) { - ALOGI("Config parameter ES_EXTENSION_SEC is not supported in IGnssConfiguration.hal" - " versions earlier than 2.0."); + if (gnssConfigurationIface == nullptr) { + ALOGE("%s: IGnssConfiguration interface not available.", __func__); return JNI_FALSE; } - - if (gnssConfigurationAidlIface != nullptr) { - auto status = gnssConfigurationAidlIface->setEsExtensionSec(emergencyExtensionSeconds); - return checkAidlStatus(status, "gnssConfigurationAidlIface setEsExtensionSec() failed."); - } - - auto result = gnssConfigurationIface_V2_0->setEsExtensionSec(emergencyExtensionSeconds); - return checkHidlReturn(result, "IGnssConfiguration setEsExtensionSec() failed."); + return gnssConfigurationIface->setEsExtensionSec(emergencyExtensionSeconds); } static jint android_location_GnssBatchingProvider_get_batch_size(JNIEnv*, jclass) { diff --git a/services/core/jni/gnss/GnssConfiguration.cpp b/services/core/jni/gnss/GnssConfiguration.cpp new file mode 100644 index 0000000000000..8610c75e7e76e --- /dev/null +++ b/services/core/jni/gnss/GnssConfiguration.cpp @@ -0,0 +1,264 @@ +/* + * Copyright (C) 2020 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 before to overwrite the default value. +#define LOG_TAG "GnssConfigurationJni" + +#include "GnssConfiguration.h" + +using android::hardware::gnss::GnssConstellationType; +using GnssConstellationType_V1_0 = android::hardware::gnss::V1_0::GnssConstellationType; +using GnssConstellationType_V2_0 = android::hardware::gnss::V2_0::GnssConstellationType; + +using android::binder::Status; +using android::hardware::hidl_vec; +using android::hardware::Return; + +using android::hardware::gnss::IGnssConfiguration; +using IGnssConfiguration_V1_0 = android::hardware::gnss::V1_0::IGnssConfiguration; +using IGnssConfiguration_V1_1 = android::hardware::gnss::V1_1::IGnssConfiguration; +using IGnssConfiguration_V2_0 = android::hardware::gnss::V2_0::IGnssConfiguration; +using IGnssConfiguration_V2_1 = android::hardware::gnss::V2_1::IGnssConfiguration; + +using android::hardware::gnss::BlocklistedSource; +using BlocklistedSource_V1_1 = IGnssConfiguration_V1_1::BlacklistedSource; +using BlocklistedSource_V2_1 = IGnssConfiguration_V2_1::BlacklistedSource; + +namespace { + +jclass class_gnssConfiguration_halInterfaceVersion; +jmethodID method_halInterfaceVersionCtor; + +jboolean checkAidlStatus(const Status& status, const char* errorMessage) { + if (!status.isOk()) { + ALOGE("%s AIDL transport error: %s", errorMessage, status.toString8().c_str()); + return JNI_FALSE; + } + return JNI_TRUE; +} + +template +inline void logHidlError(Return& result, const char* errorMessage) { + ALOGE("%s HIDL transport error: %s", errorMessage, result.description().c_str()); +} + +template +jboolean checkHidlReturn(Return& result, const char* errorMessage) { + if (!result.isOk()) { + logHidlError(result, errorMessage); + return JNI_FALSE; + } else { + return JNI_TRUE; + } +} + +jobject createHalInterfaceVersionJavaObject(JNIEnv* env, jint major, jint minor) { + return env->NewObject(class_gnssConfiguration_halInterfaceVersion, + method_halInterfaceVersionCtor, major, minor); +} + +} // anonymous namespace + +namespace android::gnss { + +void GnssConfiguration_class_init_once(JNIEnv* env) { + jclass gnssConfiguration_halInterfaceVersionClass = env->FindClass( + "com/android/server/location/gnss/GnssConfiguration$HalInterfaceVersion"); + class_gnssConfiguration_halInterfaceVersion = + (jclass)env->NewGlobalRef(gnssConfiguration_halInterfaceVersionClass); + method_halInterfaceVersionCtor = + env->GetMethodID(class_gnssConfiguration_halInterfaceVersion, "", "(II)V"); +} + +// Implementation of GnssConfiguration (AIDL HAL) + +GnssConfiguration::GnssConfiguration(const sp& iGnssConfiguration) + : mIGnssConfiguration(iGnssConfiguration) {} + +jobject GnssConfiguration::getVersion(JNIEnv* env) { + return createHalInterfaceVersionJavaObject(env, 3, 0); +} + +jboolean GnssConfiguration::setEmergencySuplPdn(jint enable) { + auto status = mIGnssConfiguration->setEmergencySuplPdn(enable); + return checkAidlStatus(status, "IGnssConfiguration setEmergencySuplPdn() failed."); +} + +jboolean GnssConfiguration::setSuplVersion(jint version) { + auto status = mIGnssConfiguration->setSuplVersion(version); + return checkAidlStatus(status, "IGnssConfiguration setSuplVersion() failed."); +} + +jboolean GnssConfiguration::setSuplEs(jint enable) { + ALOGI("Config parameter SUPL_ES is deprecated in IGnssConfiguration AIDL HAL."); + return JNI_FALSE; +} + +jboolean GnssConfiguration::setSuplMode(jint mode) { + auto status = mIGnssConfiguration->setSuplMode(mode); + return checkAidlStatus(status, "IGnssConfiguration setSuplMode() failed."); +} + +jboolean GnssConfiguration::setGpsLock(jint gpsLock) { + ALOGI("Config parameter GPS_LOCK is not supported in IGnssConfiguration AIDL HAL."); + return JNI_FALSE; +} + +jboolean GnssConfiguration::setLppProfile(jint lppProfile) { + auto status = mIGnssConfiguration->setLppProfile(lppProfile); + return checkAidlStatus(status, "IGnssConfiguration setLppProfile() failed."); +} + +jboolean GnssConfiguration::setGlonassPositioningProtocol(jint gnssPosProtocol) { + auto status = mIGnssConfiguration->setGlonassPositioningProtocol(gnssPosProtocol); + return checkAidlStatus(status, "IGnssConfiguration setGlonassPositioningProtocol() failed."); +} + +jboolean GnssConfiguration::setEsExtensionSec(jint emergencyExtensionSeconds) { + auto status = mIGnssConfiguration->setEsExtensionSec(emergencyExtensionSeconds); + return checkAidlStatus(status, "IGnssConfiguration setEsExtensionSec() failed."); +} + +jboolean GnssConfiguration::setBlocklist(JNIEnv* env, jintArray& constellations, + jintArray& sv_ids) { + auto sources = + getBlocklistedSources(env, constellations, + sv_ids); + auto status = mIGnssConfiguration->setBlocklist(sources); + return checkAidlStatus(status, "IGnssConfiguration setBlocklist() failed."); +} + +// Implementation of GnssConfiguration_V1_0 + +GnssConfiguration_V1_0::GnssConfiguration_V1_0( + const sp& iGnssConfiguration) + : mIGnssConfiguration_V1_0(iGnssConfiguration) {} + +jobject GnssConfiguration_V1_0::getVersion(JNIEnv* env) { + return createHalInterfaceVersionJavaObject(env, 1, 0); +} + +jboolean GnssConfiguration_V1_0::setEmergencySuplPdn(jint enable) { + auto result = mIGnssConfiguration_V1_0->setEmergencySuplPdn(enable); + return checkHidlReturn(result, "IGnssConfiguration setEmergencySuplPdn() failed."); +} + +jboolean GnssConfiguration_V1_0::setSuplVersion(jint version) { + auto result = mIGnssConfiguration_V1_0->setSuplVersion(version); + return checkHidlReturn(result, "IGnssConfiguration setSuplVersion() failed."); +} + +jboolean GnssConfiguration_V1_0::setSuplEs(jint enable) { + auto result = mIGnssConfiguration_V1_0->setSuplEs(enable); + return checkHidlReturn(result, "IGnssConfiguration setSuplEs() failed."); +} + +jboolean GnssConfiguration_V1_0::setSuplMode(jint mode) { + auto result = mIGnssConfiguration_V1_0->setSuplMode(mode); + return checkHidlReturn(result, "IGnssConfiguration setSuplMode() failed."); +} + +jboolean GnssConfiguration_V1_0::setGpsLock(jint gpsLock) { + auto result = mIGnssConfiguration_V1_0->setGpsLock(gpsLock); + return checkHidlReturn(result, "IGnssConfiguration setGpsLock() failed."); +} + +jboolean GnssConfiguration_V1_0::setLppProfile(jint lppProfile) { + auto result = mIGnssConfiguration_V1_0->setLppProfile(lppProfile); + return checkHidlReturn(result, "IGnssConfiguration setLppProfile() failed."); +} + +jboolean GnssConfiguration_V1_0::setGlonassPositioningProtocol(jint gnssPosProtocol) { + auto result = mIGnssConfiguration_V1_0->setGlonassPositioningProtocol(gnssPosProtocol); + return checkHidlReturn(result, "IGnssConfiguration setGlonassPositioningProtocol() failed."); +} + +jboolean GnssConfiguration_V1_0::setEsExtensionSec(jint emergencyExtensionSeconds) { + ALOGI("Config parameter ES_EXTENSION_SEC is not supported in IGnssConfiguration.hal" + " versions earlier than 2.0."); + return JNI_FALSE; +} + +jboolean GnssConfiguration_V1_0::setBlocklist(JNIEnv* env, jintArray& constellations, + jintArray& sv_ids) { + ALOGI("IGnssConfiguration interface does not support satellite blocklist."); + return JNI_FALSE; +} + +// Implementation of GnssConfiguration_V1_1 + +GnssConfiguration_V1_1::GnssConfiguration_V1_1( + const sp& iGnssConfiguration) + : GnssConfiguration_V1_0{iGnssConfiguration}, mIGnssConfiguration_V1_1(iGnssConfiguration) {} + +jobject GnssConfiguration_V1_1::getVersion(JNIEnv* env) { + return createHalInterfaceVersionJavaObject(env, 1, 1); +} + +jboolean GnssConfiguration_V1_1::setBlocklist(JNIEnv* env, jintArray& constellations, + jintArray& sv_ids) { + auto sources = getBlocklistedSources(env, constellations, sv_ids); + auto result = mIGnssConfiguration_V1_1->setBlacklist(sources); + return checkHidlReturn(result, "IGnssConfiguration setBlocklist() failed."); +} + +// Implementation of GnssConfiguration_V2_0 + +GnssConfiguration_V2_0::GnssConfiguration_V2_0( + const sp& iGnssConfiguration) + : GnssConfiguration_V1_1{iGnssConfiguration}, mIGnssConfiguration_V2_0(iGnssConfiguration) {} + +jobject GnssConfiguration_V2_0::getVersion(JNIEnv* env) { + return createHalInterfaceVersionJavaObject(env, 2, 0); +} + +jboolean GnssConfiguration_V2_0::setSuplEs(jint enable) { + ALOGI("Config parameter SUPL_ES is deprecated in IGnssConfiguration.hal version 2.0 and " + "higher."); + return JNI_FALSE; +} + +jboolean GnssConfiguration_V2_0::setGpsLock(jint enable) { + ALOGI("Config parameter GPS_LOCK is deprecated in IGnssConfiguration.hal version 2.0 and " + "higher."); + return JNI_FALSE; +} + +jboolean GnssConfiguration_V2_0::setEsExtensionSec(jint emergencyExtensionSeconds) { + auto result = mIGnssConfiguration_V2_0->setEsExtensionSec(emergencyExtensionSeconds); + return checkHidlReturn(result, "IGnssConfiguration setEsExtensionSec() failed."); +} + +// Implementation of GnssConfiguration_V2_1 + +GnssConfiguration_V2_1::GnssConfiguration_V2_1( + const sp& iGnssConfiguration) + : GnssConfiguration_V2_0{iGnssConfiguration}, mIGnssConfiguration_V2_1(iGnssConfiguration) {} + +jobject GnssConfiguration_V2_1::getVersion(JNIEnv* env) { + return createHalInterfaceVersionJavaObject(env, 2, 1); +} + +jboolean GnssConfiguration_V2_1::setBlocklist(JNIEnv* env, jintArray& constellations, + jintArray& sv_ids) { + auto sources = getBlocklistedSources(env, constellations, sv_ids); + auto result = mIGnssConfiguration_V2_1->setBlacklist_2_1(sources); + return checkHidlReturn(result, "IGnssConfiguration setBlocklist() failed."); +} + +} // namespace android::gnss diff --git a/services/core/jni/gnss/GnssConfiguration.h b/services/core/jni/gnss/GnssConfiguration.h new file mode 100644 index 0000000000000..ea0f178b71324 --- /dev/null +++ b/services/core/jni/gnss/GnssConfiguration.h @@ -0,0 +1,168 @@ +/* + * Copyright (C) 2020 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. + */ + +#ifndef _ANDROID_SERVER_GNSS_GNSSCONFIGURATION_H +#define _ANDROID_SERVER_GNSS_GNSSCONFIGURATION_H + +#pragma once + +#ifndef LOG_TAG +#error LOG_TAG must be defined before including this file. +#endif + +#include +#include +#include +#include +#include +#include + +#include "jni.h" + +namespace android::gnss { + +void GnssConfiguration_class_init_once(JNIEnv* env); + +class GnssConfigurationInterface { +public: + virtual ~GnssConfigurationInterface() {} + virtual jobject getVersion(JNIEnv* env) = 0; + virtual jboolean setEmergencySuplPdn(jint enable) = 0; + virtual jboolean setSuplVersion(jint version) = 0; + virtual jboolean setSuplEs(jint enable) = 0; + virtual jboolean setSuplMode(jint mode) = 0; + virtual jboolean setGpsLock(jint gpsLock) = 0; + virtual jboolean setLppProfile(jint lppProfile) = 0; + virtual jboolean setGlonassPositioningProtocol(jint gnssPosProtocol) = 0; + virtual jboolean setEsExtensionSec(jint emergencyExtensionSeconds) = 0; + virtual jboolean setBlocklist(JNIEnv* env, jintArray& constellations, jintArray& sv_ids) = 0; + +protected: + template + hardware::hidl_vec getBlocklistedSources(JNIEnv* env, + jintArray& constellations, + jintArray& sv_ids) { + jint* constellation_array = env->GetIntArrayElements(constellations, 0); + if (nullptr == constellation_array) { + ALOGI("GetIntArrayElements returns nullptr."); + return JNI_FALSE; + } + + jsize length = env->GetArrayLength(constellations); + + jint* sv_id_array = env->GetIntArrayElements(sv_ids, 0); + if (nullptr == sv_id_array) { + ALOGI("GetIntArrayElements returns nullptr."); + return JNI_FALSE; + } + + if (length != env->GetArrayLength(sv_ids)) { + ALOGI("Lengths of constellations and sv_ids are inconsistent."); + return JNI_FALSE; + } + + hardware::hidl_vec sources; + sources.resize(length); + + for (int i = 0; i < length; i++) { + sources[i].constellation = static_cast(constellation_array[i]); + sources[i].svid = sv_id_array[i]; + } + + env->ReleaseIntArrayElements(constellations, constellation_array, 0); + env->ReleaseIntArrayElements(sv_ids, sv_id_array, 0); + + return sources; + } +}; + +class GnssConfiguration : public GnssConfigurationInterface { +public: + GnssConfiguration(const sp& iGnssConfiguration); + jobject getVersion(JNIEnv* env) override; + jboolean setEmergencySuplPdn(jint enable) override; + jboolean setSuplVersion(jint version) override; + jboolean setSuplEs(jint enable) override; + jboolean setSuplMode(jint mode) override; + jboolean setGpsLock(jint gpsLock) override; + jboolean setLppProfile(jint lppProfile) override; + jboolean setGlonassPositioningProtocol(jint gnssPosProtocol) override; + jboolean setEsExtensionSec(jint emergencyExtensionSeconds) override; + jboolean setBlocklist(JNIEnv* env, jintArray& constellations, jintArray& sv_ids) override; + +private: + const sp mIGnssConfiguration; +}; + +class GnssConfiguration_V1_0 : public GnssConfigurationInterface { +public: + GnssConfiguration_V1_0( + const sp& iGnssConfiguration); + jobject getVersion(JNIEnv* env) override; + jboolean setEmergencySuplPdn(jint enable); + jboolean setSuplVersion(jint version) override; + jboolean setSuplEs(jint enable) override; + jboolean setSuplMode(jint mode) override; + jboolean setGpsLock(jint gpsLock) override; + jboolean setLppProfile(jint lppProfile); + jboolean setGlonassPositioningProtocol(jint gnssPosProtocol) override; + jboolean setEsExtensionSec(jint emergencyExtensionSeconds) override; + jboolean setBlocklist(JNIEnv* env, jintArray& constellations, jintArray& sv_ids) override; + +private: + const sp mIGnssConfiguration_V1_0; +}; + +class GnssConfiguration_V1_1 : public GnssConfiguration_V1_0 { +public: + GnssConfiguration_V1_1( + const sp& iGnssConfiguration); + + jobject getVersion(JNIEnv* env) override; + + jboolean setBlocklist(JNIEnv* env, jintArray& constellations, jintArray& sv_ids) override; + +private: + const sp mIGnssConfiguration_V1_1; +}; + +class GnssConfiguration_V2_0 : public GnssConfiguration_V1_1 { +public: + GnssConfiguration_V2_0( + const sp& iGnssConfiguration); + jobject getVersion(JNIEnv* env) override; + jboolean setSuplEs(jint enable) override; + jboolean setGpsLock(jint enable) override; + jboolean setEsExtensionSec(jint emergencyExtensionSeconds) override; + +private: + const sp mIGnssConfiguration_V2_0; +}; + +class GnssConfiguration_V2_1 : public GnssConfiguration_V2_0 { +public: + GnssConfiguration_V2_1( + const sp& iGnssConfiguration); + jobject getVersion(JNIEnv* env) override; + jboolean setBlocklist(JNIEnv* env, jintArray& constellations, jintArray& sv_ids) override; + +private: + const sp mIGnssConfiguration_V2_1; +}; + +} // namespace android::gnss + +#endif // _ANDROID_SERVER_GNSS_GNSSCONFIGURATION_H