diff --git a/compatibility_matrices/compatibility_matrix.current.xml b/compatibility_matrices/compatibility_matrix.current.xml index fd996fb158..ceb53be8a6 100644 --- a/compatibility_matrices/compatibility_matrix.current.xml +++ b/compatibility_matrices/compatibility_matrix.current.xml @@ -186,6 +186,7 @@ android.hardware.gnss 1.0-1 + 2.0 IGnss default diff --git a/gnss/2.0/Android.bp b/gnss/2.0/Android.bp new file mode 100644 index 0000000000..39fe97d635 --- /dev/null +++ b/gnss/2.0/Android.bp @@ -0,0 +1,21 @@ +// This file is autogenerated by hidl-gen -Landroidbp. + +hidl_interface { + name: "android.hardware.gnss@2.0", + root: "android.hardware", + vndk: { + enabled: true, + }, + srcs: [ + "IGnss.hal", + "IGnssMeasurement.hal", + "IGnssMeasurementCallback.hal", + ], + interfaces: [ + "android.hardware.gnss@1.0", + "android.hardware.gnss@1.1", + "android.hidl.base@1.0", + ], + gen_java: true, +} + diff --git a/gnss/2.0/IGnss.hal b/gnss/2.0/IGnss.hal new file mode 100644 index 0000000000..a05f61a380 --- /dev/null +++ b/gnss/2.0/IGnss.hal @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2018 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.1::IGnss; + +import IGnssMeasurement; + +/** Represents the standard GNSS (Global Navigation Satellite System) interface. */ +interface IGnss extends @1.1::IGnss { + /** + * This method returns the IGnssMeasurement interface. + * + * Exactly one of getExtensionGnssMeasurement_1_1() and getExtensionGnssMeasurement_2_0() must + * return a non-null handle, and the other method must return nullptr. + * + * @return gnssMeasurementIface Handle to the IGnssMeasurement interface. + */ + getExtensionGnssMeasurement_2_0() generates (IGnssMeasurement gnssMeasurementIface); +}; \ No newline at end of file diff --git a/gnss/2.0/IGnssMeasurement.hal b/gnss/2.0/IGnssMeasurement.hal new file mode 100644 index 0000000000..108f3d29ed --- /dev/null +++ b/gnss/2.0/IGnssMeasurement.hal @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2018 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::IGnssMeasurement; +import @1.1::IGnssMeasurement; +import IGnssMeasurementCallback; + +/** + * Extended interface for GNSS Measurements support. + */ +interface IGnssMeasurement extends @1.1::IGnssMeasurement { + + /** + * Initializes the interface and registers the callback routines with the HAL. After a + * successful call to 'setCallback_2_0' the HAL must begin to provide updates at an average + * output rate of 1Hz (occasional intra-measurement time offsets in the range from 0-2000msec + * can be tolerated.) + * + * @param callback Handle to GnssMeasurement callback interface. + * @param enableFullTracking If true, GNSS chipset must switch off duty cycling. In such mode + * no clock discontinuities are expected and, when supported, carrier phase should be + * continuous in good signal conditions. All non-blacklisted, healthy constellations, + * satellites and frequency bands that the chipset supports must be reported in this mode. + * The GNSS chipset is allowed to consume more power in this mode. If false, API must behave + * as in HAL V1_0, optimizing power via duty cycling, constellations and frequency limits, + * etc. + * + * @return initRet Returns SUCCESS if successful. Returns ERROR_ALREADY_INIT if a callback has + * already been registered without a corresponding call to 'close'. Returns ERROR_GENERIC + * for any other error. The HAL must not generate any other updates upon returning this + * error code. + */ + setCallback_2_0(IGnssMeasurementCallback callback, bool enableFullTracking) + generates (GnssMeasurementStatus initRet); + +}; diff --git a/gnss/2.0/IGnssMeasurementCallback.hal b/gnss/2.0/IGnssMeasurementCallback.hal new file mode 100644 index 0000000000..226934e876 --- /dev/null +++ b/gnss/2.0/IGnssMeasurementCallback.hal @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2018 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::IGnssMeasurementCallback; +import @1.1::IGnssMeasurementCallback; + +/** The callback interface to report measurements from the HAL. */ +interface IGnssMeasurementCallback extends @1.1::IGnssMeasurementCallback { + /** + * Enumeration of available values for the GNSS Measurement's code type. Similar to the + * Attribute field described in Rinex 3.03, e.g., in Tables 4-10, and Table A2 at the Rinex 3.03 + * Update 1 Document. + */ + enum GnssMeasurementCodeType : uint8_t { + /** GALILEO E1A, GALILEO E6A, IRNSS L5A, IRNSS SA. */ + CODE_TYPE_A = 0, + + /** GALILEO E1B, GALILEO E6B, IRNSS L5B, IRNSS SB. */ + CODE_TYPE_B = 1, + + /** + * GPS L1 C/A, GPS L2 C/A, GLONASS G1 C/A, GLONASS G2 C/A, GALILEO E1C, GALILEO E6C, SBAS + * L1 C/A, QZSS L1 C/A, IRNSS L5C. + */ + CODE_TYPE_C = 2, + + /** + * GPS L5 I, GLONASS G3 I, GALILEO E5a I, GALILEO E5b I, GALILEO E5a+b I, SBAS L5 I, QZSS L5 + * I, BDS B1 I, BDS B2 I, BDS B3 I. + */ + CODE_TYPE_I = 3, + + /** GPS L1C (P), GPS L2C (L), QZSS L1C (P), QZSS L2C (L), LEX(6) L. */ + CODE_TYPE_L = 4, + + /** GPS L1M, GPS L2M. */ + CODE_TYPE_M = 5, + + /** GPS L1P, GPS L2P, GLONASS G1P, GLONASS G2P. */ + CODE_TYPE_P = 6, + + /** + * GPS L5 Q, GLONASS G3 Q, GALILEO E5a Q, GALILEO E5b Q, GALILEO E5a+b Q, SBAS L5 Q, QZSS L5 + * Q, BDS B1 Q, BDS B2 Q, BDS B3 Q. + */ + CODE_TYPE_Q = 7, + + /** GPS L1C (D), GPS L2C (M), QZSS L1C (D), QZSS L2C (M), LEX(6) S. */ + CODE_TYPE_S = 8, + + /** GPS L1 Z-tracking, GPS L2 Z-tracking. */ + CODE_TYPE_W = 9, + + /** + * GPS L1C (D+P), GPS L2C (M+L), GPS L5 (I+Q), GLONASS G3 (I+Q), GALILEO E1 (B+C), GALILEO + * E5a (I+Q), GALILEO E5b (I+Q), GALILEO E5a+b(I+Q), GALILEO E6 (B+C), SBAS L5 (I+Q), QZSS + * L1C (D+P), QZSS L2C (M+L), QZSS L5 (I+Q), LEX(6) (S+L), BDS B1 (I+Q), BDS B2 (I+Q), BDS + * B3 (I+Q), IRNSS L5 (B+C). + */ + CODE_TYPE_X = 10, + + /** GPS L1Y, GPS L2Y. */ + CODE_TYPE_Y = 11, + + /** GALILEO E1 (A+B+C), GALILEO E6 (A+B+C), QZSS L1-SAIF. */ + CODE_TYPE_Z = 12, + + /** GPS L1 codeless, GPS L2 codeless. */ + CODE_TYPE_CODELESS = 13 + }; + + /** + * Extends a GNSS Measurement, adding a GnssMeasurementCodeType. + */ + struct GnssMeasurement { + /** + * GNSS measurement information for a single satellite and frequency, as in the 1.1 + * version of the HAL with further clarification of the value reported in the + * accumulatedDeltaRangeM field, i.e., the alignment of the phase measurement will not be + * adjusted by the receiver so the in-phase and quadrature phase components will have a + * quarter cycle offset as they do when transmitted from the satellites. If the measurement + * is from a combination of the in-phase and quadrature phase components, then the alignment + * of the phase measurement will be aligned to the in-phase component. + */ + @1.1::IGnssMeasurementCallback.GnssMeasurement v1_1; + + /** + * The type of code that is currently being tracked in the GNSS measurement. + * + * For high precision applications the type of code being tracked needs to be considered + * in-order to properly apply code specific corrections to the psuedorange measurements. + */ + GnssMeasurementCodeType codeType; + }; + + /** + * Complete set of GNSS Measurement data, same as 1.1 with additional enum in measurements. + */ + struct GnssData { + /** The full set of satellite measurement observations. */ + vec measurements; + + /** The GNSS clock time reading. */ + GnssClock clock; + }; + + /** + * Callback for the hal to pass a GnssData structure back to the client. + * + * @param data Contains a reading of GNSS measurements. + */ + gnssMeasurementCb_2_0(GnssData data); +}; diff --git a/gnss/2.0/default/Android.bp b/gnss/2.0/default/Android.bp new file mode 100644 index 0000000000..3c5557812b --- /dev/null +++ b/gnss/2.0/default/Android.bp @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2018 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. + */ + +cc_binary { + name: "android.hardware.gnss@2.0-service", + init_rc: ["android.hardware.gnss@2.0-service.rc"], + relative_install_path: "hw", + vendor: true, + srcs: [ + "Gnss.cpp", + "GnssMeasurement.cpp", + "service.cpp" + ], + shared_libs: [ + "libhidlbase", + "libhidltransport", + "libutils", + "liblog", + "android.hardware.gnss@2.0", + "android.hardware.gnss@1.0", + "android.hardware.gnss@1.1", + ], +} diff --git a/gnss/2.0/default/Gnss.cpp b/gnss/2.0/default/Gnss.cpp new file mode 100644 index 0000000000..1170f73afa --- /dev/null +++ b/gnss/2.0/default/Gnss.cpp @@ -0,0 +1,187 @@ +/* + * Copyright (C) 2018 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 "Gnss" + +#include "Gnss.h" +#include + +namespace android { +namespace hardware { +namespace gnss { +namespace V2_0 { +namespace implementation { + +sp Gnss::sGnssCallback = nullptr; + +// Methods from V1_0::IGnss follow. +Return Gnss::setCallback(const sp&) { + // TODO implement + return bool{}; +} + +Return Gnss::start() { + // TODO implement + return bool{}; +} + +Return Gnss::stop() { + // TODO implement + return bool{}; +} + +Return Gnss::cleanup() { + // TODO implement + return Void(); +} + +Return Gnss::injectTime(int64_t, int64_t, int32_t) { + // TODO implement + return bool{}; +} + +Return Gnss::injectLocation(double, double, float) { + // TODO implement + return bool{}; +} + +Return Gnss::deleteAidingData(V1_0::IGnss::GnssAidingData) { + // TODO implement + return Void(); +} + +Return Gnss::setPositionMode(V1_0::IGnss::GnssPositionMode, + V1_0::IGnss::GnssPositionRecurrence, uint32_t, uint32_t, + uint32_t) { + // TODO implement + return bool{}; +} + +Return> Gnss::getExtensionAGnssRil() { + // TODO implement + return sp{}; +} + +Return> Gnss::getExtensionGnssGeofencing() { + // TODO implement + return sp{}; +} + +Return> Gnss::getExtensionAGnss() { + // TODO implement + return sp{}; +} + +Return> Gnss::getExtensionGnssNi() { + // TODO implement + return sp{}; +} + +Return> Gnss::getExtensionGnssMeasurement() { + // TODO implement + return sp{}; +} + +Return> Gnss::getExtensionGnssNavigationMessage() { + // TODO implement + return sp{}; +} + +Return> Gnss::getExtensionXtra() { + // TODO implement + return sp{}; +} + +Return> Gnss::getExtensionGnssConfiguration() { + // TODO implement + return sp{}; +} + +Return> Gnss::getExtensionGnssDebug() { + // TODO implement + return sp{}; +} + +Return> Gnss::getExtensionGnssBatching() { + // TODO implement + return sp{}; +} + +// Methods from V1_1::IGnss follow. +Return Gnss::setCallback_1_1(const sp& callback) { + ALOGD("Gnss::setCallback_1_1"); + if (callback == nullptr) { + ALOGE("%s: Null callback ignored", __func__); + return false; + } + + sGnssCallback = callback; + + uint32_t capabilities = 0x0; + auto ret = sGnssCallback->gnssSetCapabilitesCb(capabilities); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } + + V1_1::IGnssCallback::GnssSystemInfo gnssInfo = {.yearOfHw = 2019}; + + ret = sGnssCallback->gnssSetSystemInfoCb(gnssInfo); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } + + auto gnssName = "Google Mock GNSS Implementation v2.0"; + ret = sGnssCallback->gnssNameCb(gnssName); + if (!ret.isOk()) { + ALOGE("%s: Unable to invoke callback", __func__); + } + + return true; +} + +Return Gnss::setPositionMode_1_1(V1_0::IGnss::GnssPositionMode, + V1_0::IGnss::GnssPositionRecurrence, uint32_t, uint32_t, + uint32_t, bool) { + // TODO implement + return bool{}; +} + +Return> Gnss::getExtensionGnssConfiguration_1_1() { + // TODO implement + return sp{}; +} + +Return> Gnss::getExtensionGnssMeasurement_1_1() { + // TODO implement + return sp{}; +} + +Return Gnss::injectBestLocation(const V1_0::GnssLocation&) { + // TODO implement + return bool{}; +} + +// Methods from V2_0::IGnss follow. +Return> Gnss::getExtensionGnssMeasurement_2_0() { + // TODO implement + return sp{}; +} + +} // namespace implementation +} // namespace V2_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gnss/2.0/default/Gnss.h b/gnss/2.0/default/Gnss.h new file mode 100644 index 0000000000..17e439f6be --- /dev/null +++ b/gnss/2.0/default/Gnss.h @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2018 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_HARDWARE_GNSS_V2_0_GNSS_H +#define ANDROID_HARDWARE_GNSS_V2_0_GNSS_H + +#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 Gnss : public IGnss { + // Methods from V1_0::IGnss follow. + Return setCallback(const sp& callback) override; + Return start() override; + Return stop() override; + Return cleanup() override; + Return injectTime(int64_t timeMs, int64_t timeReferenceMs, + int32_t uncertaintyMs) override; + Return injectLocation(double latitudeDegrees, double longitudeDegrees, + float accuracyMeters) override; + Return deleteAidingData(V1_0::IGnss::GnssAidingData aidingDataFlags) override; + Return setPositionMode(V1_0::IGnss::GnssPositionMode mode, + V1_0::IGnss::GnssPositionRecurrence recurrence, + uint32_t minIntervalMs, uint32_t preferredAccuracyMeters, + uint32_t preferredTimeMs) override; + Return> getExtensionAGnssRil() override; + Return> getExtensionGnssGeofencing() override; + Return> getExtensionAGnss() override; + Return> getExtensionGnssNi() override; + Return> getExtensionGnssMeasurement() override; + Return> getExtensionGnssNavigationMessage() override; + Return> getExtensionXtra() override; + Return> getExtensionGnssConfiguration() override; + Return> getExtensionGnssDebug() override; + Return> getExtensionGnssBatching() override; + + // Methods from V1_1::IGnss follow. + Return setCallback_1_1(const sp& callback) override; + Return setPositionMode_1_1(V1_0::IGnss::GnssPositionMode mode, + V1_0::IGnss::GnssPositionRecurrence recurrence, + uint32_t minIntervalMs, uint32_t preferredAccuracyMeters, + uint32_t preferredTimeMs, bool lowPowerMode) override; + Return> getExtensionGnssConfiguration_1_1() override; + Return> getExtensionGnssMeasurement_1_1() override; + Return injectBestLocation(const V1_0::GnssLocation& location) override; + + // Methods from V2_0::IGnss follow. + Return> getExtensionGnssMeasurement_2_0() override; + + private: + static sp sGnssCallback; +}; + +} // namespace implementation +} // namespace V2_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V2_0_GNSS_H diff --git a/gnss/2.0/default/GnssMeasurement.cpp b/gnss/2.0/default/GnssMeasurement.cpp new file mode 100644 index 0000000000..fbcdc12c5a --- /dev/null +++ b/gnss/2.0/default/GnssMeasurement.cpp @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2018 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. + */ + +#include "GnssMeasurement.h" + +namespace android { +namespace hardware { +namespace gnss { +namespace V2_0 { +namespace implementation { + +// Methods from V1_0::IGnssMeasurement follow. +Return GnssMeasurement::setCallback( + const sp&) { + // TODO implement + return V1_0::IGnssMeasurement::GnssMeasurementStatus{}; +} + +Return GnssMeasurement::close() { + // TODO implement + return Void(); +} + +// Methods from V1_1::IGnssMeasurement follow. +Return GnssMeasurement::setCallback_1_1( + const sp&, bool) { + // TODO implement + return V1_0::IGnssMeasurement::GnssMeasurementStatus{}; +} + +// Methods from V2_0::IGnssMeasurement follow. +Return GnssMeasurement::setCallback_2_0( + const sp&, bool) { + // TODO implement + return V1_0::IGnssMeasurement::GnssMeasurementStatus{}; +} + +// Methods from ::android::hidl::base::V1_0::IBase follow. + +// IGnssMeasurement* HIDL_FETCH_IGnssMeasurement(const char* /* name */) { +// return new GnssMeasurement(); +//} +// +} // namespace implementation +} // namespace V2_0 +} // namespace gnss +} // namespace hardware +} // namespace android diff --git a/gnss/2.0/default/GnssMeasurement.h b/gnss/2.0/default/GnssMeasurement.h new file mode 100644 index 0000000000..8c621bb24a --- /dev/null +++ b/gnss/2.0/default/GnssMeasurement.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2018 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_HARDWARE_GNSS_V2_0_GNSSMEASUREMENT_H +#define ANDROID_HARDWARE_GNSS_V2_0_GNSSMEASUREMENT_H + +#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 GnssMeasurement : public IGnssMeasurement { + // Methods from V1_0::IGnssMeasurement follow. + Return setCallback( + const sp& callback) override; + Return close() override; + + // Methods from V1_1::IGnssMeasurement follow. + Return setCallback_1_1( + const sp& callback, bool enableFullTracking) override; + + // Methods from V2_0::IGnssMeasurement follow. + Return setCallback_2_0( + const sp& callback, bool enableFullTracking) override; +}; + +} // namespace implementation +} // namespace V2_0 +} // namespace gnss +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_GNSS_V2_0_GNSSMEASUREMENT_H diff --git a/gnss/2.0/default/OWNERS b/gnss/2.0/default/OWNERS new file mode 100644 index 0000000000..8da956c08f --- /dev/null +++ b/gnss/2.0/default/OWNERS @@ -0,0 +1,5 @@ +wyattriley@google.com +gomo@google.com +smalkos@google.com +yuhany@google.com +aadmal@google.com diff --git a/gnss/2.0/default/android.hardware.gnss@2.0-service.rc b/gnss/2.0/default/android.hardware.gnss@2.0-service.rc new file mode 100644 index 0000000000..a27240d909 --- /dev/null +++ b/gnss/2.0/default/android.hardware.gnss@2.0-service.rc @@ -0,0 +1,4 @@ +service vendor.gnss-2-0 /vendor/bin/hw/android.hardware.gnss@2.0-service + class hal + user system + group system diff --git a/gnss/2.0/default/service.cpp b/gnss/2.0/default/service.cpp new file mode 100644 index 0000000000..301d1816dd --- /dev/null +++ b/gnss/2.0/default/service.cpp @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2018 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 "android.hardware.gnss@2.0-service" + +#include +#include +#include "Gnss.h" + +using ::android::OK; +using ::android::sp; +using ::android::hardware::configureRpcThreadpool; +using ::android::hardware::joinRpcThreadpool; +using ::android::hardware::gnss::V2_0::IGnss; +using ::android::hardware::gnss::V2_0::implementation::Gnss; + +int main(int /* argc */, char* /* argv */ []) { + sp gnss = new Gnss(); + configureRpcThreadpool(1, true /* will join */); + if (gnss->registerAsService() != OK) { + ALOGE("Could not register gnss 2.0 service."); + return 1; + } + joinRpcThreadpool(); + + ALOGE("Service exited!"); + return 1; +} diff --git a/gnss/2.0/vts/OWNERS b/gnss/2.0/vts/OWNERS new file mode 100644 index 0000000000..0a7ce6c26d --- /dev/null +++ b/gnss/2.0/vts/OWNERS @@ -0,0 +1,8 @@ +wyattriley@google.com +gomo@google.com +smalkos@google.com +yuhany@google.com +aadmal@google.com + +# VTS team +yim@google.com diff --git a/gnss/2.0/vts/functional/Android.bp b/gnss/2.0/vts/functional/Android.bp new file mode 100644 index 0000000000..7db142f130 --- /dev/null +++ b/gnss/2.0/vts/functional/Android.bp @@ -0,0 +1,30 @@ +// +// Copyright (C) 2018 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. +// + +cc_test { + name: "VtsHalGnssV2_0TargetTest", + defaults: ["VtsHalTargetTestDefaults"], + srcs: [ + "gnss_hal_test.cpp", + "gnss_hal_test_cases.cpp", + "VtsHalGnssV2_0TargetTest.cpp", + ], + static_libs: [ + "android.hardware.gnss@1.0", + "android.hardware.gnss@1.1", + "android.hardware.gnss@2.0", + ], +} diff --git a/gnss/2.0/vts/functional/VtsHalGnssV2_0TargetTest.cpp b/gnss/2.0/vts/functional/VtsHalGnssV2_0TargetTest.cpp new file mode 100644 index 0000000000..ae36c50689 --- /dev/null +++ b/gnss/2.0/vts/functional/VtsHalGnssV2_0TargetTest.cpp @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2018 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 "VtsHalGnssV2_0TargetTest" + +#include + +#include "gnss_hal_test.h" + +int main(int argc, char** argv) { + ::testing::AddGlobalTestEnvironment(GnssHidlEnvironment::Instance()); + ::testing::InitGoogleTest(&argc, argv); + GnssHidlEnvironment::Instance()->init(&argc, argv); + int status = RUN_ALL_TESTS(); + ALOGI("Test result = %d", status); + return status; +} diff --git a/gnss/2.0/vts/functional/gnss_hal_test.cpp b/gnss/2.0/vts/functional/gnss_hal_test.cpp new file mode 100644 index 0000000000..d7101a03b7 --- /dev/null +++ b/gnss/2.0/vts/functional/gnss_hal_test.cpp @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2018 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 "GnssHalTest" + +#include + +#include + +// Implementations for the main test class for GNSS HAL +GnssHalTest::GnssHalTest() + : info_called_count_(0), + capabilities_called_count_(0), + location_called_count_(0), + name_called_count_(0), + notify_count_(0) {} + +void GnssHalTest::SetUp() { + gnss_hal_ = ::testing::VtsHalHidlTargetTestBase::getService( + GnssHidlEnvironment::Instance()->getServiceName()); + list_gnss_sv_status_.clear(); + ASSERT_NE(gnss_hal_, nullptr); + + SetUpGnssCallback(); +} + +void GnssHalTest::TearDown() { + if (gnss_hal_ != nullptr) { + gnss_hal_->cleanup(); + } + if (notify_count_ > 0) { + ALOGW("%d unprocessed callbacks discarded", notify_count_); + } +} + +void GnssHalTest::SetUpGnssCallback() { + gnss_cb_ = new GnssCallback(*this); + ASSERT_NE(gnss_cb_, nullptr); + + auto result = gnss_hal_->setCallback_1_1(gnss_cb_); + if (!result.isOk()) { + ALOGE("result of failed setCallback %s", result.description().c_str()); + } + + ASSERT_TRUE(result.isOk()); + ASSERT_TRUE(result); + + /* + * All capabilities, name and systemInfo callbacks should trigger + */ + EXPECT_EQ(std::cv_status::no_timeout, wait(TIMEOUT_SEC)); + EXPECT_EQ(std::cv_status::no_timeout, wait(TIMEOUT_SEC)); + EXPECT_EQ(std::cv_status::no_timeout, wait(TIMEOUT_SEC)); + + EXPECT_EQ(capabilities_called_count_, 1); + EXPECT_EQ(info_called_count_, 1); + EXPECT_EQ(name_called_count_, 1); +} + +void GnssHalTest::notify() { + std::unique_lock lock(mtx_); + notify_count_++; + cv_.notify_one(); +} + +std::cv_status GnssHalTest::wait(int timeout_seconds) { + std::unique_lock lock(mtx_); + + auto status = std::cv_status::no_timeout; + while (notify_count_ == 0) { + status = cv_.wait_for(lock, std::chrono::seconds(timeout_seconds)); + if (status == std::cv_status::timeout) return status; + } + notify_count_--; + return status; +} + +Return GnssHalTest::GnssCallback::gnssSetSystemInfoCb( + const IGnssCallback::GnssSystemInfo& info) { + ALOGI("Info received, year %d", info.yearOfHw); + parent_.info_called_count_++; + parent_.last_info_ = info; + parent_.notify(); + return Void(); +} + +Return GnssHalTest::GnssCallback::gnssSetCapabilitesCb(uint32_t capabilities) { + ALOGI("Capabilities received %d", capabilities); + parent_.capabilities_called_count_++; + parent_.last_capabilities_ = capabilities; + parent_.notify(); + return Void(); +} + +Return GnssHalTest::GnssCallback::gnssNameCb(const android::hardware::hidl_string& name) { + ALOGI("Name received: %s", name.c_str()); + parent_.name_called_count_++; + parent_.last_name_ = name; + parent_.notify(); + return Void(); +} + +Return GnssHalTest::GnssCallback::gnssLocationCb(const GnssLocation& location) { + ALOGI("Location received"); + parent_.location_called_count_++; + parent_.last_location_ = location; + parent_.notify(); + return Void(); +} + +Return GnssHalTest::GnssCallback::gnssSvStatusCb( + const IGnssCallback::GnssSvStatus& svStatus) { + ALOGI("GnssSvStatus received"); + parent_.list_gnss_sv_status_.emplace_back(svStatus); + return Void(); +} diff --git a/gnss/2.0/vts/functional/gnss_hal_test.h b/gnss/2.0/vts/functional/gnss_hal_test.h new file mode 100644 index 0000000000..64f3575419 --- /dev/null +++ b/gnss/2.0/vts/functional/gnss_hal_test.h @@ -0,0 +1,132 @@ +/* + * Copyright (C) 2018 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 GNSS_HAL_TEST_H_ +#define GNSS_HAL_TEST_H_ + +#include + +#include +#include + +#include +#include +#include + +using android::hardware::Return; +using android::hardware::Void; + +using android::hardware::gnss::V1_0::GnssLocation; + +using android::hardware::gnss::V1_0::GnssLocationFlags; +using android::hardware::gnss::V1_1::IGnssCallback; +using android::hardware::gnss::V2_0::IGnss; + +using android::sp; + +#define TIMEOUT_SEC 2 // for basic commands/responses + +// Test environment for GNSS HIDL HAL. +class GnssHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase { + public: + // get the test environment singleton + static GnssHidlEnvironment* Instance() { + static GnssHidlEnvironment* instance = new GnssHidlEnvironment; + return instance; + } + + virtual void registerTestServices() override { registerTestService(); } + + private: + GnssHidlEnvironment() {} +}; + +// The main test class for GNSS HAL. +class GnssHalTest : public ::testing::VtsHalHidlTargetTestBase { + public: + GnssHalTest(); + + virtual void SetUp() override; + + virtual void TearDown() override; + + /* Used as a mechanism to inform the test that a callback has occurred */ + void notify(); + + /* Test code calls this function to wait for a callback */ + std::cv_status wait(int timeout_seconds); + + /* Callback class for data & Event. */ + class GnssCallback : public IGnssCallback { + public: + GnssHalTest& parent_; + + GnssCallback(GnssHalTest& parent) : parent_(parent){}; + + virtual ~GnssCallback() = default; + + // Dummy callback handlers + Return gnssStatusCb(const IGnssCallback::GnssStatusValue /* status */) override { + return Void(); + } + Return gnssNmeaCb(int64_t /* timestamp */, + const android::hardware::hidl_string& /* nmea */) override { + return Void(); + } + Return gnssAcquireWakelockCb() override { return Void(); } + Return gnssReleaseWakelockCb() override { return Void(); } + Return gnssRequestLocationCb(bool /* independentFromGnss */) override { + return Void(); + } + Return gnssRequestTimeCb() override { return Void(); } + // Actual (test) callback handlers + Return gnssNameCb(const android::hardware::hidl_string& name) override; + Return gnssLocationCb(const GnssLocation& location) override; + Return gnssSetCapabilitesCb(uint32_t capabilities) override; + Return gnssSetSystemInfoCb(const IGnssCallback::GnssSystemInfo& info) override; + Return gnssSvStatusCb(const IGnssCallback::GnssSvStatus& svStatus) override; + }; + + /* + * SetUpGnssCallback: + * Set GnssCallback and verify the result. + */ + void SetUpGnssCallback(); + + sp gnss_hal_; // GNSS HAL to call into + sp gnss_cb_; // Primary callback interface + + /* Count of calls to set the following items, and the latest item (used by + * test.) + */ + int info_called_count_; + IGnssCallback::GnssSystemInfo last_info_; + uint32_t last_capabilities_; + int capabilities_called_count_; + int location_called_count_; + GnssLocation last_location_; + list list_gnss_sv_status_; + + int name_called_count_; + android::hardware::hidl_string last_name_; + + private: + std::mutex mtx_; + std::condition_variable cv_; + int notify_count_; +}; + +#endif // GNSS_HAL_TEST_H_ diff --git a/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp b/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp new file mode 100644 index 0000000000..12a15e8cc7 --- /dev/null +++ b/gnss/2.0/vts/functional/gnss_hal_test_cases.cpp @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2018 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 "GnssHalTestCases" + +#include +#include + +using android::hardware::hidl_vec; + +using IGnssMeasurement_2_0 = android::hardware::gnss::V2_0::IGnssMeasurement; +using IGnssMeasurement_1_1 = android::hardware::gnss::V1_1::IGnssMeasurement; + +/* + * SetupTeardownCreateCleanup: + * Requests the gnss HAL then calls cleanup + * + * Empty test fixture to verify basic Setup & Teardown + */ +TEST_F(GnssHalTest, SetupTeardownCreateCleanup) {} + +/* + * TestGnssMeasurementCallback: + * Gets the GnssMeasurementExtension and verify that it returns an actual extension. + */ +TEST_F(GnssHalTest, TestGnssMeasurementCallback) { + auto gnssMeasurement_2_0 = gnss_hal_->getExtensionGnssMeasurement_2_0(); + auto gnssMeasurement_1_1 = gnss_hal_->getExtensionGnssMeasurement_1_1(); + ASSERT_TRUE(gnssMeasurement_2_0.isOk() || gnssMeasurement_1_1.isOk()); + if (last_capabilities_ & IGnssCallback::Capabilities::MEASUREMENTS) { + sp iGnssMeas_2_0 = gnssMeasurement_2_0; + sp iGnssMeas_1_1 = gnssMeasurement_1_1; + // Exactly one interface is non-null. + ASSERT_TRUE((iGnssMeas_1_1 != nullptr) != (iGnssMeas_2_0 != nullptr)); + } +}