diff --git a/current.txt b/current.txt index f49727c41c..1dd1c5d7d6 100644 --- a/current.txt +++ b/current.txt @@ -464,7 +464,9 @@ f27baaa587bc3dd9b740cb6928ab812b9b7d105b5187663938aee578105f3c39 android.hardwar 7f460e795f5d1ed5e378935f98c6db4d39497de988aef1b4c2a4a07a6c400392 android.hardware.gnss@2.0::IAGnss 2e5ad983734069e84a760004b32da0d09e4170c05380abe27e6eb80e4aa70d5a android.hardware.gnss@2.0::IAGnssCallback 1f4ac068a88a72360280d94a7f6fd7c63813c1eea4891a0eb01394d3e7e775f2 android.hardware.gnss@2.0::IAGnssRil -63216fcb23eaf4d6f12ea0e99b8bfdb8e4e57c02f215d433cd30943d850f61a7 android.hardware.gnss@2.0::IGnss +4deafcdcffa2d002119e7f58810b767a84666e76475aae68e757ec2845d9756d android.hardware.gnss@2.0::IGnss +db6bdf6dfc5edf6c85d2944976db899227abb51079c893874353c322342c50b6 android.hardware.gnss@2.0::IGnssBatching +1f89392f1ebb693d8fa6f50324b1635fc79fab246d31900e63998e1b0e17511c android.hardware.gnss@2.0::IGnssBatchingCallback b11a5e4a1602d3f408716b6fe2c578a79f060d571aad8e828f9a4426d161fbcf android.hardware.gnss@2.0::IGnssCallback ecc966c68bddbd95c8dae782b84204cf01c75734675e8769963f3b5106ec128b android.hardware.gnss@2.0::IGnssConfiguration b670bae2ab8517336290532e364502b4db9120340d75474ccc8442b1b15d6ab7 android.hardware.gnss@2.0::IGnssDebug diff --git a/gnss/2.0/Android.bp b/gnss/2.0/Android.bp index 30dc55de57..6cfd3462f2 100644 --- a/gnss/2.0/Android.bp +++ b/gnss/2.0/Android.bp @@ -12,6 +12,8 @@ hidl_interface { "IAGnssCallback.hal", "IAGnssRil.hal", "IGnss.hal", + "IGnssBatching.hal", + "IGnssBatchingCallback.hal", "IGnssCallback.hal", "IGnssConfiguration.hal", "IGnssDebug.hal", diff --git a/gnss/2.0/IGnss.hal b/gnss/2.0/IGnss.hal index ba757d73d6..f19f8d0566 100644 --- a/gnss/2.0/IGnss.hal +++ b/gnss/2.0/IGnss.hal @@ -27,6 +27,7 @@ import IGnssDebug; import IGnssMeasurement; import IAGnss; import IAGnssRil; +import IGnssBatching; /** * Represents the standard GNSS (Global Navigation Satellite System) interface. @@ -104,6 +105,13 @@ interface IGnss extends @1.1::IGnss { */ getExtensionVisibilityControl() generates (IGnssVisibilityControl visibilityControlIface); + /** + * This method returns the IGnssBatching interface. + * + * @return batchingIface Handle to the IGnssBatching interface. + */ + getExtensionGnssBatching_2_0() generates (IGnssBatching batchingIface); + /** * Injects current location from the best available location provider. * diff --git a/gnss/2.0/IGnssBatching.hal b/gnss/2.0/IGnssBatching.hal new file mode 100644 index 0000000000..961fa69548 --- /dev/null +++ b/gnss/2.0/IGnssBatching.hal @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2019 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. + */ + +package android.hardware.gnss@2.0; + +import @1.0::IGnssBatching; +import IGnssBatchingCallback; + +/** + * Extended interface for GNSS Batching support. + * + * If this interface is supported, this batching request must be able to run in + * parallel with, or without, non-batched location requested by the + * IGnss start() & stop() - i.e. both requests must be handled independently, + * and not interfere with each other. + * + * For example, if a 1Hz continuous output is underway on the IGnssCallback, + * due to an IGnss start() operation, + * and then a IGnssBatching start() is called for a location every 10 + * seconds, the newly added batching request must not disrupt the 1Hz + * continuous location output on the IGnssCallback. + * + * As with GNSS Location outputs, source of location must be GNSS satellite + * measurements, optionally using interial and baro sensors to improve + * relative motion filtering. No additional absolute positioning information, + * such as WiFi derived location, may be mixed with the GNSS information. + */ +interface IGnssBatching extends @1.0::IGnssBatching { + /** + * Opens the interface and provides the callback routines + * to the implementation of this interface. + * + * @param callback Callback interface for IGnssBatching. + * + * @return success Returns true on success. + */ + init_2_0(IGnssBatchingCallback callback) generates (bool success); +}; \ No newline at end of file diff --git a/gnss/2.0/IGnssBatchingCallback.hal b/gnss/2.0/IGnssBatchingCallback.hal new file mode 100644 index 0000000000..4f8b4ecbba --- /dev/null +++ b/gnss/2.0/IGnssBatchingCallback.hal @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2019 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. + */ + +package android.hardware.gnss@2.0; + +/** The callback interface to report measurements from the HAL. */ +interface IGnssBatchingCallback { + /** + * Called when a batch of locations is output, by various means, including + * a flush request, as well as the buffer becoming full (if appropriate option + * is set.) + * + * All locations returned by this callback must be cleared from the hardware + * buffer, such the sequential calls of this callback do not return any + * redundant locations. (Same lat/lon, at a new time, is acceptable.) + * + * The GnssLocation struct in gnss@2.0 is extended to include elapsed realtime + * information. + * + * @param locations GNSS Location information from HAL. + */ + gnssLocationBatchCb(vec locations); +}; diff --git a/gnss/2.0/default/Android.bp b/gnss/2.0/default/Android.bp index 64187e24d9..0fcd76495c 100644 --- a/gnss/2.0/default/Android.bp +++ b/gnss/2.0/default/Android.bp @@ -25,6 +25,7 @@ cc_binary { "AGnss.cpp", "AGnssRil.cpp", "Gnss.cpp", + "GnssBatching.cpp", "GnssMeasurement.cpp", "GnssMeasurementCorrections.cpp", "GnssVisibilityControl.cpp", diff --git a/gnss/2.0/default/Gnss.cpp b/gnss/2.0/default/Gnss.cpp index bb89b8b423..75c2385169 100644 --- a/gnss/2.0/default/Gnss.cpp +++ b/gnss/2.0/default/Gnss.cpp @@ -23,6 +23,7 @@ #include "AGnss.h" #include "AGnssRil.h" +#include "GnssBatching.h" #include "GnssConfiguration.h" #include "GnssMeasurement.h" #include "GnssMeasurementCorrections.h" @@ -265,6 +266,10 @@ Return> Gnss::getExtensionV return new GnssVisibilityControl(); } +Return> Gnss::getExtensionGnssBatching_2_0() { + return new GnssBatching(); +} + Return Gnss::setCallback_2_0(const sp& callback) { ALOGD("Gnss::setCallback_2_0"); if (callback == nullptr) { diff --git a/gnss/2.0/default/Gnss.h b/gnss/2.0/default/Gnss.h index a500128670..72f77976e5 100644 --- a/gnss/2.0/default/Gnss.h +++ b/gnss/2.0/default/Gnss.h @@ -92,6 +92,7 @@ struct Gnss : public IGnss { getExtensionMeasurementCorrections() override; Return> getExtensionVisibilityControl() override; + Return> getExtensionGnssBatching_2_0() override; Return injectBestLocation_2_0(const V2_0::GnssLocation& location) override; private: diff --git a/gnss/2.0/default/GnssBatching.cpp b/gnss/2.0/default/GnssBatching.cpp new file mode 100644 index 0000000000..d56cdfb33f --- /dev/null +++ b/gnss/2.0/default/GnssBatching.cpp @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2019 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 "GnssBatching" + +#include "GnssBatching.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V2_0 { +namespace implementation { + +sp GnssBatching::sCallback = nullptr; + +// Methods from ::android::hardware::gnss::V1_0::IGnssBatching follow. +Return GnssBatching::init(const sp&) { + // TODO implement + return bool{}; +} + +Return GnssBatching::getBatchSize() { + // TODO implement + return uint16_t{}; +} + +Return GnssBatching::start(const V1_0::IGnssBatching::Options&) { + // TODO implement + return bool{}; +} + +Return GnssBatching::flush() { + // TODO implement + return Void(); +} + +Return GnssBatching::stop() { + // TODO implement + return bool{}; +} + +Return GnssBatching::cleanup() { + // TODO implement + return Void(); +} + +// Methods from V2_0::IGnssBatching follow. +Return GnssBatching::init_2_0(const sp& callback) { + sCallback = callback; + return true; +} + +} // namespace implementation +} // namespace V2_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gnss/2.0/default/GnssBatching.h b/gnss/2.0/default/GnssBatching.h new file mode 100644 index 0000000000..62ac580897 --- /dev/null +++ b/gnss/2.0/default/GnssBatching.h @@ -0,0 +1,57 @@ +/* + * Copyright (C) 2019 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. + */ + +#pragma once + +#include +#include +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V2_0 { +namespace implementation { + +using ::android::sp; +using ::android::hardware::hidl_array; +using ::android::hardware::hidl_memory; +using ::android::hardware::hidl_string; +using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; + +struct GnssBatching : public IGnssBatching { + // Methods from ::android::hardware::gnss::V1_0::IGnssBatching follow. + Return init(const sp& callback) override; + Return getBatchSize() override; + Return start(const V1_0::IGnssBatching::Options& options) override; + Return flush() override; + Return stop() override; + Return cleanup() override; + + // Methods from V2_0::IGnssBatching follow. + Return init_2_0(const sp& callback) override; + + private: + static sp sCallback; +}; + +} // namespace implementation +} // namespace V2_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gnss/2.0/default/GnssConfiguration.cpp b/gnss/2.0/default/GnssConfiguration.cpp index 4389dd28f3..6bf1712aff 100644 --- a/gnss/2.0/default/GnssConfiguration.cpp +++ b/gnss/2.0/default/GnssConfiguration.cpp @@ -33,13 +33,11 @@ Return GnssConfiguration::setSuplEs(bool enable) { } Return GnssConfiguration::setSuplVersion(uint32_t) { - // TODO implement - return bool{}; + return true; } Return GnssConfiguration::setSuplMode(hidl_bitfield) { - // TODO implement - return bool{}; + return true; } Return GnssConfiguration::setGpsLock(hidl_bitfield gpsLock) { @@ -49,18 +47,15 @@ Return GnssConfiguration::setGpsLock(hidl_bitfield gpsLock) { } Return GnssConfiguration::setLppProfile(hidl_bitfield) { - // TODO implement - return bool{}; + return true; } Return GnssConfiguration::setGlonassPositioningProtocol(hidl_bitfield) { - // TODO implement - return bool{}; + return true; } Return GnssConfiguration::setEmergencySuplPdn(bool) { - // TODO implement - return bool{}; + return true; } // Methods from ::android::hardware::gnss::V1_1::IGnssConfiguration follow. diff --git a/gnss/2.0/vts/functional/gnss_hal_test.cpp b/gnss/2.0/vts/functional/gnss_hal_test.cpp index b8c343753f..da6092bb4b 100644 --- a/gnss/2.0/vts/functional/gnss_hal_test.cpp +++ b/gnss/2.0/vts/functional/gnss_hal_test.cpp @@ -26,6 +26,7 @@ using ::android::hardware::gnss::common::Utils; GnssHalTest::GnssHalTest() : info_called_count_(0), capabilities_called_count_(0), + measurement_corrections_capabilities_called_count_(0), location_called_count_(0), name_called_count_(0), notify_count_(0) {} @@ -43,6 +44,7 @@ void GnssHalTest::TearDown() { // Reset counters info_called_count_ = 0; capabilities_called_count_ = 0; + measurement_corrections_capabilities_called_count_ = 0; location_called_count_ = 0; name_called_count_ = 0; measurement_called_count_ = 0; diff --git a/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp b/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp index 230c9799f1..0682f84d5f 100644 --- a/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp +++ b/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp @@ -32,6 +32,8 @@ using IAGnssRil_2_0 = android::hardware::gnss::V2_0::IAGnssRil; using IAGnss_2_0 = android::hardware::gnss::V2_0::IAGnss; using IAGnss_1_0 = android::hardware::gnss::V1_0::IAGnss; using IAGnssCallback_2_0 = android::hardware::gnss::V2_0::IAGnssCallback; +using IGnssBatching_V1_0 = android::hardware::gnss::V1_0::IGnssBatching; +using IGnssBatching_V2_0 = android::hardware::gnss::V2_0::IGnssBatching; using android::hardware::gnss::common::Utils; using android::hardware::gnss::measurement_corrections::V1_0::IMeasurementCorrections; @@ -326,6 +328,10 @@ TEST_F(GnssHalTest, TestGnssMeasurementCorrections) { return; } + sp iMeasurementCorrectionsCallback = + new GnssMeasurementCorrectionsCallback(*this); + iMeasurementCorrections->setCallback(iMeasurementCorrectionsCallback); + const int kMeasurementCorrectionsCapabilitiesTimeoutSeconds = 5; waitForMeasurementCorrectionsCapabilities(kMeasurementCorrectionsCapabilitiesTimeoutSeconds); ASSERT_TRUE(measurement_corrections_capabilities_called_count_ > 0); @@ -395,3 +401,20 @@ TEST_F(GnssHalTest, TestInjectBestLocation_2_0) { gnss_hal_->injectBestLocation_2_0(last_location_); StopAndClearLocations(); } + +/* + * TestGnssBatchingExtension: + * Gets the GnssBatchingExtension and verifies that it supports either the @1.0::IGnssBatching + * or @2.0::IGnssBatching extension. + */ +TEST_F(GnssHalTest, TestGnssBatchingExtension) { + auto gnssBatching_V2_0 = gnss_hal_->getExtensionGnssBatching_2_0(); + ASSERT_TRUE(gnssBatching_V2_0.isOk()); + + auto gnssBatching_V1_0 = gnss_hal_->getExtensionGnssBatching(); + ASSERT_TRUE(gnssBatching_V1_0.isOk()); + + sp iGnssBatching_V1_0 = gnssBatching_V1_0; + sp iGnssBatching_V2_0 = gnssBatching_V2_0; + ASSERT_TRUE(iGnssBatching_V1_0 != nullptr || iGnssBatching_V2_0 != nullptr); +}