From 3089df3bd8ac7528c5f33317b00bf626d361e770 Mon Sep 17 00:00:00 2001 From: Yu-Han Yang Date: Wed, 29 Sep 2021 21:31:23 -0700 Subject: [PATCH] Add GnssGeofence AIDL HAL (hardware/interfaces) Bug: 201253590 Test: on cuttlefish Change-Id: I3acb2a667f7a31e7ba21b2552549df8fb236e38d --- .../current/android/hardware/gnss/IGnss.aidl | 1 + .../android/hardware/gnss/IGnssGeofence.aidl | 42 ++++ .../hardware/gnss/IGnssGeofenceCallback.aidl | 54 +++++ gnss/aidl/android/hardware/gnss/IGnss.aidl | 8 + .../android/hardware/gnss/IGnssGeofence.aidl | 82 ++++++++ .../hardware/gnss/IGnssGeofenceCallback.aidl | 184 ++++++++++++++++++ gnss/aidl/default/Android.bp | 1 + gnss/aidl/default/Gnss.cpp | 8 + gnss/aidl/default/Gnss.h | 2 + gnss/aidl/default/GnssGeofence.cpp | 61 ++++++ gnss/aidl/default/GnssGeofence.h | 41 ++++ gnss/aidl/vts/Android.bp | 1 + gnss/aidl/vts/GnssGeofenceCallback.cpp | 46 +++++ gnss/aidl/vts/GnssGeofenceCallback.h | 38 ++++ gnss/aidl/vts/gnss_hal_test_cases.cpp | 33 ++-- 15 files changed, 588 insertions(+), 14 deletions(-) create mode 100644 gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnssGeofence.aidl create mode 100644 gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnssGeofenceCallback.aidl create mode 100644 gnss/aidl/android/hardware/gnss/IGnssGeofence.aidl create mode 100644 gnss/aidl/android/hardware/gnss/IGnssGeofenceCallback.aidl create mode 100644 gnss/aidl/default/GnssGeofence.cpp create mode 100644 gnss/aidl/default/GnssGeofence.h create mode 100644 gnss/aidl/vts/GnssGeofenceCallback.cpp create mode 100644 gnss/aidl/vts/GnssGeofenceCallback.h diff --git a/gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnss.aidl b/gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnss.aidl index 52276b4279..a3cd8ae553 100644 --- a/gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnss.aidl +++ b/gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnss.aidl @@ -41,6 +41,7 @@ interface IGnss { android.hardware.gnss.IGnssMeasurementInterface getExtensionGnssMeasurement(); android.hardware.gnss.IGnssPowerIndication getExtensionGnssPowerIndication(); @nullable android.hardware.gnss.IGnssBatching getExtensionGnssBatching(); + @nullable android.hardware.gnss.IGnssGeofence getExtensionGnssGeofence(); const int ERROR_INVALID_ARGUMENT = 1; const int ERROR_ALREADY_INIT = 2; const int ERROR_GENERIC = 3; diff --git a/gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnssGeofence.aidl b/gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnssGeofence.aidl new file mode 100644 index 0000000000..50da5bf4aa --- /dev/null +++ b/gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnssGeofence.aidl @@ -0,0 +1,42 @@ +/* + * Copyright (C) 2021 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.gnss; +@VintfStability +interface IGnssGeofence { + void setCallback(in android.hardware.gnss.IGnssGeofenceCallback callback); + void addGeofence(in int geofenceId, in double latitudeDegrees, in double longitudeDegrees, in double radiusMeters, in int lastTransition, in int monitorTransitions, in int notificationResponsivenessMs, in int unknownTimerMs); + void pauseGeofence(in int geofenceId); + void resumeGeofence(in int geofenceId, in int monitorTransitions); + void removeGeofence(in int geofenceId); +} diff --git a/gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnssGeofenceCallback.aidl b/gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnssGeofenceCallback.aidl new file mode 100644 index 0000000000..26482eadeb --- /dev/null +++ b/gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnssGeofenceCallback.aidl @@ -0,0 +1,54 @@ +/* + * Copyright (C) 2021 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. + */ +/////////////////////////////////////////////////////////////////////////////// +// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. // +/////////////////////////////////////////////////////////////////////////////// + +// This file is a snapshot of an AIDL file. Do not edit it manually. There are +// two cases: +// 1). this is a frozen version file - do not edit this in any case. +// 2). this is a 'current' file. If you make a backwards compatible change to +// the interface (from the latest frozen version), the build system will +// prompt you to update this file with `m -update-api`. +// +// You must not make a backward incompatible change to any AIDL file built +// with the aidl_interface module type with versions property set. The module +// type is used to build AIDL files in a way that they can be used across +// independently updatable components of the system. If a device is shipped +// with such a backward incompatible change, it has a high risk of breaking +// later when a module using the interface is updated, e.g., Mainline modules. + +package android.hardware.gnss; +@VintfStability +interface IGnssGeofenceCallback { + void gnssGeofenceTransitionCb(in int geofenceId, in android.hardware.gnss.GnssLocation location, in int transition, in long timestampMillis); + void gnssGeofenceStatusCb(in int availability, in android.hardware.gnss.GnssLocation lastLocation); + void gnssGeofenceAddCb(in int geofenceId, in int status); + void gnssGeofenceRemoveCb(in int geofenceId, in int status); + void gnssGeofencePauseCb(in int geofenceId, in int status); + void gnssGeofenceResumeCb(in int geofenceId, in int status); + const int ENTERED = 1; + const int EXITED = 2; + const int UNCERTAIN = 4; + const int UNAVAILABLE = 1; + const int AVAILABLE = 2; + const int OPERATION_SUCCESS = 0; + const int ERROR_TOO_MANY_GEOFENCES = -100; + const int ERROR_ID_EXISTS = -101; + const int ERROR_ID_UNKNOWN = -102; + const int ERROR_INVALID_TRANSITION = -103; + const int ERROR_GENERIC = -149; +} diff --git a/gnss/aidl/android/hardware/gnss/IGnss.aidl b/gnss/aidl/android/hardware/gnss/IGnss.aidl index b12fb825ed..e019d3597a 100644 --- a/gnss/aidl/android/hardware/gnss/IGnss.aidl +++ b/gnss/aidl/android/hardware/gnss/IGnss.aidl @@ -19,6 +19,7 @@ package android.hardware.gnss; import android.hardware.gnss.IGnssBatching; import android.hardware.gnss.IGnssCallback; import android.hardware.gnss.IGnssConfiguration; +import android.hardware.gnss.IGnssGeofence; import android.hardware.gnss.IGnssMeasurementInterface; import android.hardware.gnss.IGnssPowerIndication; import android.hardware.gnss.IGnssPsds; @@ -110,4 +111,11 @@ interface IGnss { * @return Handle to the IGnssBatching interface. */ @nullable IGnssBatching getExtensionGnssBatching(); + + /** + * This method returns the IGnssGeofence interface. + * + * @return Handle to the IGnssGeofence interface. + */ + @nullable IGnssGeofence getExtensionGnssGeofence(); } diff --git a/gnss/aidl/android/hardware/gnss/IGnssGeofence.aidl b/gnss/aidl/android/hardware/gnss/IGnssGeofence.aidl new file mode 100644 index 0000000000..bb4ff9307f --- /dev/null +++ b/gnss/aidl/android/hardware/gnss/IGnssGeofence.aidl @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2021 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; + +import android.hardware.gnss.IGnssGeofenceCallback; + +/** Extended interface for GNSS Geofence support. */ +@VintfStability +interface IGnssGeofence { + /** + * Opens the geofence interface and provides the callback routines to the HAL. + * + * @param callback Handle to the IGnssGeofenceCallback interface. + */ + void setCallback(in IGnssGeofenceCallback callback); + + /** + * Add a geofence area. This api currently supports circular geofences. + * + * @param geofenceId The id for the geofence. If a geofence with this id already exists, an + * error value (ERROR_ID_EXISTS) must be returned. + * @param latitudeDegrees The latitude(in degrees) for the geofence lastTransition. + * @param longitudeDegrees The longitude(in degrees) for the geofence lastTransition. + * @param radiusMeters The radius(in meters) for the geofence lastTransition. + * @param lastTransition The current state of the geofence. It can be one of the transition + * states (ENTERED, EXITED, UNCERTAIN) as defined in IGnssGeofenceCallback. For example, if + * the system already knows that the user is inside the geofence, this will be set to ENTERED. + * In most cases, it will be UNCERTAIN. + * @param monitorTransitions A bitfield of ENTERED, EXITED and UNCERTAIN. It represents which + * transitions to monitor. + * @param notificationResponsivenessMs - Defines the best-effort description of how soon must + * the callback be called when the transition associated with the Geofence is triggered. For + * instance, if set to 1000 milliseconds with ENTERED, the callback must be called 1000 + * milliseconds within entering the geofence. This parameter is defined in milliseconds. + * NOTE: This is not to be confused with the rate that the GNSS is polled at. It is acceptable + * to dynamically vary the rate of sampling the GNSS for power-saving reasons; thus the rate of + * sampling may be faster or slower than this. + * @param unknownTimerMs - The time limit in millisecondsafter which the UNCERTAIN transition + * must be triggered. + */ + void addGeofence(in int geofenceId, in double latitudeDegrees, in double longitudeDegrees, + in double radiusMeters, in int lastTransition, in int monitorTransitions, + in int notificationResponsivenessMs, in int unknownTimerMs); + + /** + * Pause monitoring a particular geofence. + * + * @param geofenceId The id for the geofence. + */ + void pauseGeofence(in int geofenceId); + + /** + * Resume monitoring a particular geofence. + * + * @param geofenceId - The id for the geofence. + * @param monitorTransitions Specifies which transitions to monitor. It can be a bitwise OR of + * ENTERED, EXITED and UNCERTAIN. This supersedes the value associated provided in the + * addGeofence call. + */ + void resumeGeofence(in int geofenceId, in int monitorTransitions); + + /** + * Remove a geofence area. After the function returns, no notifications must be sent. + * + * @param geofenceId The id of the geofence. + */ + void removeGeofence(in int geofenceId); +} diff --git a/gnss/aidl/android/hardware/gnss/IGnssGeofenceCallback.aidl b/gnss/aidl/android/hardware/gnss/IGnssGeofenceCallback.aidl new file mode 100644 index 0000000000..c1769653b5 --- /dev/null +++ b/gnss/aidl/android/hardware/gnss/IGnssGeofenceCallback.aidl @@ -0,0 +1,184 @@ +/* + * Copyright (C) 2021 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; + +import android.hardware.gnss.GnssLocation; + +/** + * The callback interface to report GNSS geofence events from the HAL. + * + * There are 3 states associated with a Geofence: Inside, Outside, Unknown. + * There are 3 transitions: ENTERED, EXITED, UNCERTAIN. + * + * An example state diagram with confidence level: 95% and Unknown time limit + * set as 30 secs is shown below. (confidence level and Unknown time limit are + * explained latter). + * ____________________________ + * | Unknown (30 secs) | + * """""""""""""""""""""""""""" + * ^ | | ^ + * UNCERTAIN| |ENTERED EXITED| |UNCERTAIN + * | v v | + * ________ EXITED _________ + * | Inside | -----------> | Outside | + * | | <----------- | | + * """""""" ENTERED """"""""" + * + * Inside state: We are 95% confident that the user is inside the geofence. + * Outside state: We are 95% confident that the user is outside the geofence + * Unknown state: Rest of the time. + * + * The Unknown state is better explained with an example: + * + * __________ + * | c| + * | ___ | _______ + * | |a| | | b | + * | """ | """"""" + * | | + * """""""""" + * In the diagram above, "a" and "b" are 2 geofences and "c" is the accuracy + * circle reported by the GNSS subsystem. Now with regard to "b", the system is + * confident that the user is outside. But with regard to "a" is not confident + * whether it is inside or outside the geofence. If the accuracy remains the + * same for a sufficient period of time, the UNCERTAIN transition must be + * triggered with the state set to Unknown. If the accuracy improves later, an + * appropriate transition must be triggered. This "sufficient period of time" + * is defined by the parameter in the addGeofenceArea API. + * In other words, Unknown state can be interpreted as a state in which the + * GNSS subsystem isn't confident enough that the user is either inside or + * outside the Geofence. It moves to Unknown state only after the expiry of the + * timeout. + * + * The geofence callback needs to be triggered for the ENTERED and EXITED + * transitions, when the GNSS system is confident that the user has entered + * (Inside state) or exited (Outside state) the Geofence. An implementation + * which uses a value of 95% as the confidence is recommended. The callback + * must be triggered only for the transitions requested by the + * addGeofenceArea method. + * + * Even though the diagram and explanation talks about states and transitions, + * the callee is only interested in the transitions. The states are mentioned + * here for illustrative purposes. + * + * Startup Scenario: When the device boots up, if an application adds geofences, + * and then we get an accurate GNSS location fix, it needs to trigger the + * appropriate (ENTERED or EXITED) transition for every Geofence it knows about. + * By default, all the Geofences will be in the Unknown state. + * + * When the GNSS system is unavailable, gnssGeofenceStatusCb must be + * called to inform the upper layers of the same. Similarly, when it becomes + * available the callback must be called. This is a global state while the + * UNKNOWN transition described above is per geofence. + * + * An important aspect to note is that users of this API (framework), will use + * other subsystems like wifi, sensors, cell to handle Unknown case and + * hopefully provide a definitive state transition to the third party + * application. GNSS Geofence will just be a signal indicating what the GNSS + * subsystem knows about the Geofence. + */ +@VintfStability +interface IGnssGeofenceCallback { + // Geofence transition status + const int ENTERED = 1 << 0; + const int EXITED = 1 << 1; + const int UNCERTAIN = 1 << 2; + + // Geofence availability status + const int UNAVAILABLE = 1 << 0; + const int AVAILABLE = 1 << 1; + + // Geofence operation status + const int OPERATION_SUCCESS = 0; + const int ERROR_TOO_MANY_GEOFENCES = -100; + const int ERROR_ID_EXISTS = -101; + const int ERROR_ID_UNKNOWN = -102; + const int ERROR_INVALID_TRANSITION = -103; + const int ERROR_GENERIC = -149; + + /** + * The callback associated with the geofence transition. + * + * The callback must only be called when the caller is interested in that particular transition. + * For instance, if the caller is interested only in ENTERED transition, then the callback must + * not be called with the EXITED transition. + * + * IMPORTANT: If a transition is triggered resulting in this callback, the GNSS subsystem will + * wake up the application processor, if it is in suspend state. + * + * @param geofenceId The id associated with the addGeofenceArea. + * @param location The current GNSS location. + * @param transition Can be one of ENTERED, EXITED or UNCERTAIN. + * @param timestamp Timestamp (in UTC milliseconds) when the transition was detected. + */ + void gnssGeofenceTransitionCb(in int geofenceId, in GnssLocation location, in int transition, + in long timestampMillis); + + /** + * The callback associated with the availability of the GNSS system for geofencing monitoring. + * If the GNSS system determines that it cannot monitor geofences because of lack of reliability + * or unavailability of the GNSS signals, it will call this callback with UNAVAILABLE parameter. + * + * @param status - UNAVAILABLE or AVAILABLE. + * @param lastLocation - Last known location. + */ + void gnssGeofenceStatusCb(in int availability, in GnssLocation lastLocation); + + /** + * The callback associated with the addGeofence call. + * + * @param geofenceId Id of the geofence. + * @param status Returns OPERATION_SUCCESS if the geofence add was successful, + * returns ERROR_TOO_MANY_GEOFENCES if the geofence limit has been reached, + * returns ERROR_ID_EXISTS if geofence with id already exists, + * returns ERROR_INVALID_TRANSITION if the monitorTransition contains an invalid + * transition, and + * returns ERROR_GENERIC for other errors. + */ + void gnssGeofenceAddCb(in int geofenceId, in int status); + + /** + * The callback associated with the removeGeofence call. + * + * @param geofenceId Id of the geofence. + * @param status Returns OPERATION_SUCCESS if successful, + * returns ERROR_ID_UNKNOWN for invalid id and + * returns ERROR_GENERIC for others. + */ + void gnssGeofenceRemoveCb(in int geofenceId, in int status); + + /** + * The callback associated with the pauseGeofence call. + * + * @param geofenceId Id of the geofence. + * @param status Returns OPERATION_SUCCESS if success, + * returns ERROR_ID_UNKNOWN for invalid id, + * returns ERROR_INVALID_TRANSITION when monitorTransitions is invalid, and + * returns ERROR_GENERIC for other err errors. + */ + void gnssGeofencePauseCb(in int geofenceId, in int status); + + /** + * The callback associated with the resumeGeofence call. + * + * @param geofenceId - Id of the geofence. + * @param status Returns OPERATION_SUCCESS if successful, + * returns ERROR_ID_UNKNOWN for invalid id, and + * returns ERROR_GENERIC for others. + */ + void gnssGeofenceResumeCb(in int geofenceId, in int status); +} diff --git a/gnss/aidl/default/Android.bp b/gnss/aidl/default/Android.bp index 892ad15a19..29bc5c42d7 100644 --- a/gnss/aidl/default/Android.bp +++ b/gnss/aidl/default/Android.bp @@ -57,6 +57,7 @@ cc_binary { srcs: [ "Gnss.cpp", "GnssBatching.cpp", + "GnssGeofence.cpp", "GnssHidlHal.cpp", "GnssPowerIndication.cpp", "GnssPsds.cpp", diff --git a/gnss/aidl/default/Gnss.cpp b/gnss/aidl/default/Gnss.cpp index fbfa2bbd0d..03d9e31f30 100644 --- a/gnss/aidl/default/Gnss.cpp +++ b/gnss/aidl/default/Gnss.cpp @@ -20,6 +20,7 @@ #include #include "GnssBatching.h" #include "GnssConfiguration.h" +#include "GnssGeofence.h" #include "GnssMeasurementInterface.h" #include "GnssPsds.h" @@ -96,4 +97,11 @@ ndk::ScopedAStatus Gnss::getExtensionGnssBatching(std::shared_ptr return ndk::ScopedAStatus::ok(); } +ndk::ScopedAStatus Gnss::getExtensionGnssGeofence(std::shared_ptr* iGnssGeofence) { + ALOGD("Gnss::getExtensionGnssGeofence"); + + *iGnssGeofence = SharedRefBase::make(); + return ndk::ScopedAStatus::ok(); +} + } // namespace aidl::android::hardware::gnss diff --git a/gnss/aidl/default/Gnss.h b/gnss/aidl/default/Gnss.h index 3959ef86e0..8e573b5f2b 100644 --- a/gnss/aidl/default/Gnss.h +++ b/gnss/aidl/default/Gnss.h @@ -40,6 +40,8 @@ class Gnss : public BnGnss { std::shared_ptr* iGnssMeasurement) override; ndk::ScopedAStatus getExtensionGnssBatching( std::shared_ptr* iGnssBatching) override; + ndk::ScopedAStatus getExtensionGnssGeofence( + std::shared_ptr* iGnssGeofence) override; std::shared_ptr mGnssConfiguration; std::shared_ptr mGnssPowerIndication; diff --git a/gnss/aidl/default/GnssGeofence.cpp b/gnss/aidl/default/GnssGeofence.cpp new file mode 100644 index 0000000000..eda33cc1b6 --- /dev/null +++ b/gnss/aidl/default/GnssGeofence.cpp @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2021 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 "GnssGeofenceAidl" + +#include "GnssGeofence.h" +#include +#include + +namespace aidl::android::hardware::gnss { + +std::shared_ptr GnssGeofence::sCallback = nullptr; + +ndk::ScopedAStatus GnssGeofence::setCallback( + const std::shared_ptr& callback) { + ALOGD("setCallback"); + std::unique_lock lock(mMutex); + sCallback = callback; + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus GnssGeofence::addGeofence(int geofenceId, double latitudeDegrees, + double longitudeDegrees, double radiusMeters, + int lastTransition, int monitorTransitions, + int notificationResponsivenessMs, int unknownTimerMs) { + ALOGD("addGeofence. geofenceId=%d, lat=%lf, lng=%lf, rad=%lf, lastTransition=%d, " + "monitorTransitions=%d, notificationResponsivenessMs=%d, unknownTimerMs=%d", + geofenceId, latitudeDegrees, longitudeDegrees, radiusMeters, lastTransition, + monitorTransitions, notificationResponsivenessMs, unknownTimerMs); + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus GnssGeofence::pauseGeofence(int geofenceId) { + ALOGD("pauseGeofence. id=%d", geofenceId); + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus GnssGeofence::resumeGeofence(int geofenceId, int monitorTransitions) { + ALOGD("resumeGeofence. id=%d, monitorTransitions=%d", geofenceId, monitorTransitions); + return ndk::ScopedAStatus::ok(); +} + +ndk::ScopedAStatus GnssGeofence::removeGeofence(int geofenceId) { + ALOGD("removeGeofence. id=%d", geofenceId); + return ndk::ScopedAStatus::ok(); +} + +} // namespace aidl::android::hardware::gnss diff --git a/gnss/aidl/default/GnssGeofence.h b/gnss/aidl/default/GnssGeofence.h new file mode 100644 index 0000000000..313e832265 --- /dev/null +++ b/gnss/aidl/default/GnssGeofence.h @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2021 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 + +namespace aidl::android::hardware::gnss { + +struct GnssGeofence : public BnGnssGeofence { + public: + ndk::ScopedAStatus setCallback(const std::shared_ptr& callback) override; + ndk::ScopedAStatus addGeofence(int geofenceId, double latitudeDegrees, double longitudeDegrees, + double radiusMeters, int lastTransition, int monitorTransitions, + int notificationResponsivenessMs, int unknownTimerMs) override; + ndk::ScopedAStatus pauseGeofence(int geofenceId) override; + ndk::ScopedAStatus resumeGeofence(int geofenceId, int monitorTransitions) override; + ndk::ScopedAStatus removeGeofence(int geofenceId) override; + + private: + // Guarded by mMutex + static std::shared_ptr sCallback; + + // Synchronization lock for sCallback + mutable std::mutex mMutex; +}; + +} // namespace aidl::android::hardware::gnss diff --git a/gnss/aidl/vts/Android.bp b/gnss/aidl/vts/Android.bp index 6096d4dd9c..8582b62dfd 100644 --- a/gnss/aidl/vts/Android.bp +++ b/gnss/aidl/vts/Android.bp @@ -32,6 +32,7 @@ cc_test { "gnss_hal_test_cases.cpp", "GnssBatchingCallback.cpp", "GnssCallbackAidl.cpp", + "GnssGeofenceCallback.cpp", "GnssMeasurementCallbackAidl.cpp", "GnssPowerIndicationCallback.cpp", "VtsHalGnssTargetTest.cpp", diff --git a/gnss/aidl/vts/GnssGeofenceCallback.cpp b/gnss/aidl/vts/GnssGeofenceCallback.cpp new file mode 100644 index 0000000000..b841cb96c7 --- /dev/null +++ b/gnss/aidl/vts/GnssGeofenceCallback.cpp @@ -0,0 +1,46 @@ +/* + * Copyright (C) 2021 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 "GnssGeofenceCallback.h" +#include + +using android::binder::Status; +using android::hardware::gnss::GnssLocation; + +Status GnssGeofenceCallback::gnssGeofenceTransitionCb(int, const GnssLocation&, int, int64_t) { + // To implement + return Status::ok(); +} +Status GnssGeofenceCallback::gnssGeofenceStatusCb(int, const GnssLocation&) { + // To implement + return Status::ok(); +} +Status GnssGeofenceCallback::gnssGeofenceAddCb(int, int) { + // To implement + return Status::ok(); +} +Status GnssGeofenceCallback::gnssGeofenceRemoveCb(int, int) { + // To implement + return Status::ok(); +} +Status GnssGeofenceCallback::gnssGeofencePauseCb(int, int) { + // To implement + return Status::ok(); +} +Status GnssGeofenceCallback::gnssGeofenceResumeCb(int, int) { + // To implement + return Status::ok(); +} diff --git a/gnss/aidl/vts/GnssGeofenceCallback.h b/gnss/aidl/vts/GnssGeofenceCallback.h new file mode 100644 index 0000000000..b10551871a --- /dev/null +++ b/gnss/aidl/vts/GnssGeofenceCallback.h @@ -0,0 +1,38 @@ +/* + * Copyright (C) 2021 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 "GnssCallbackEventQueue.h" + +/** Implementation for IGnssGeofenceCallback. */ +class GnssGeofenceCallback : public android::hardware::gnss::BnGnssGeofenceCallback { + public: + GnssGeofenceCallback() {} + ~GnssGeofenceCallback() {} + + android::binder::Status gnssGeofenceTransitionCb( + int geofenceId, const android::hardware::gnss::GnssLocation& location, int transition, + int64_t timestampMillis) override; + android::binder::Status gnssGeofenceStatusCb( + int availability, const android::hardware::gnss::GnssLocation& lastLocation) override; + android::binder::Status gnssGeofenceAddCb(int geofenceId, int status) override; + android::binder::Status gnssGeofenceRemoveCb(int geofenceId, int status) override; + android::binder::Status gnssGeofencePauseCb(int geofenceId, int status) override; + android::binder::Status gnssGeofenceResumeCb(int geofenceId, int status) override; +}; diff --git a/gnss/aidl/vts/gnss_hal_test_cases.cpp b/gnss/aidl/vts/gnss_hal_test_cases.cpp index 86140cc6b2..09f94122b2 100644 --- a/gnss/aidl/vts/gnss_hal_test_cases.cpp +++ b/gnss/aidl/vts/gnss_hal_test_cases.cpp @@ -23,6 +23,7 @@ #include #include #include "GnssBatchingCallback.h" +#include "GnssGeofenceCallback.h" #include "GnssMeasurementCallbackAidl.h" #include "GnssPowerIndicationCallback.h" #include "gnss_hal_test.h" @@ -38,6 +39,8 @@ using android::hardware::gnss::IGnss; using android::hardware::gnss::IGnssBatching; using android::hardware::gnss::IGnssBatchingCallback; using android::hardware::gnss::IGnssConfiguration; +using android::hardware::gnss::IGnssGeofence; +using android::hardware::gnss::IGnssGeofenceCallback; using android::hardware::gnss::IGnssMeasurementCallback; using android::hardware::gnss::IGnssMeasurementInterface; using android::hardware::gnss::IGnssPowerIndication; @@ -755,23 +758,25 @@ TEST_P(GnssHalTest, BlocklistConstellationLocationOn) { } /* - * TestGnssBatchingExtension: - * 1. Gets the IGnssBatching extension. - * 2. Initializes the interface with an IGnssBatchingCallback. - * 3. Clean up. + * TestAllExtensions. */ -TEST_P(GnssHalTest, TestGnssBatchingExtension) { +TEST_P(GnssHalTest, TestAllExtensions) { sp iGnssBatching; auto status = aidl_gnss_hal_->getExtensionGnssBatching(&iGnssBatching); - if (!status.isOk() || iGnssBatching == nullptr) { - // Device doesn't support batching. Skip the test. - return; + if (status.isOk() && iGnssBatching != nullptr) { + auto gnssBatchingCallback = sp::make(); + status = iGnssBatching->init(gnssBatchingCallback); + ASSERT_TRUE(status.isOk()); + + status = iGnssBatching->cleanup(); + ASSERT_TRUE(status.isOk()); } - sp iGnssBatchingCallback; - status = iGnssBatching->init(iGnssBatchingCallback); - ASSERT_TRUE(status.isOk()); - - status = iGnssBatching->cleanup(); - ASSERT_TRUE(status.isOk()); + sp iGnssGeofence; + status = aidl_gnss_hal_->getExtensionGnssGeofence(&iGnssGeofence); + if (status.isOk() && iGnssGeofence != nullptr) { + auto gnssGeofenceCallback = sp::make(); + status = iGnssGeofence->setCallback(gnssGeofenceCallback); + ASSERT_TRUE(status.isOk()); + } }