Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 11:36:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add IGnssAntennaInfo AIDL HAL

Browse Source 
Bug: 205185369
Test: atest VtsHalGnssTargetTest
Change-Id: If269c61b408c2710a4fa224de4d684c99ac5732b
This commit is contained in:
Joe Huang
2021-12-30 13:14:29 +08:00
parent 946e355f82
commit 37d77dded6
16 changed files with 653 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnss.aidl
View File

@@ -53,6 +53,7 @@ interface IGnss {
void injectBestLocation(in android.hardware.gnss.GnssLocation location);
void deleteAidingData(in android.hardware.gnss.IGnss.GnssAidingData aidingDataFlags);
void setPositionMode(in android.hardware.gnss.IGnss.GnssPositionMode mode, in android.hardware.gnss.IGnss.GnssPositionRecurrence recurrence, in int minIntervalMs, in int preferredAccuracyMeters, in int preferredTimeMs, in boolean lowPowerMode);
android.hardware.gnss.IGnssAntennaInfo getExtensionGnssAntennaInfo();
const int ERROR_INVALID_ARGUMENT = 1;
const int ERROR_ALREADY_INIT = 2;
const int ERROR_GENERIC = 3;

39
gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnssAntennaInfo.aidl Normal file
View File

@@ -0,0 +1,39 @@
/*
* 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 <name>-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 IGnssAntennaInfo {
void setCallback(in android.hardware.gnss.IGnssAntennaInfoCallback callback);
void close();
}

60
gnss/aidl/aidl_api/android.hardware.gnss/current/android/hardware/gnss/IGnssAntennaInfoCallback.aidl Normal file
View File

@@ -0,0 +1,60 @@
/*
* 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 <name>-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 IGnssAntennaInfoCallback {
void gnssAntennaInfoCb(in android.hardware.gnss.IGnssAntennaInfoCallback.GnssAntennaInfo[] gnssAntennaInfos);
@VintfStability
parcelable Row {
double[] row;
}
@VintfStability
parcelable Coord {
double x;
double xUncertainty;
double y;
double yUncertainty;
double z;
double zUncertainty;
}
@VintfStability
parcelable GnssAntennaInfo {
long carrierFrequencyHz;
android.hardware.gnss.IGnssAntennaInfoCallback.Coord phaseCenterOffsetCoordinateMillimeters;
android.hardware.gnss.IGnssAntennaInfoCallback.Row[] phaseCenterVariationCorrectionMillimeters;
android.hardware.gnss.IGnssAntennaInfoCallback.Row[] phaseCenterVariationCorrectionUncertaintyMillimeters;
android.hardware.gnss.IGnssAntennaInfoCallback.Row[] signalGainCorrectionDbi;
android.hardware.gnss.IGnssAntennaInfoCallback.Row[] signalGainCorrectionUncertaintyDbi;
}
}

8
gnss/aidl/android/hardware/gnss/IGnss.aidl
View File

@@ -18,6 +18,7 @@ package android.hardware.gnss;
import android.hardware.gnss.GnssLocation;
import android.hardware.gnss.IAGnss;
import android.hardware.gnss.IGnssAntennaInfo;
import android.hardware.gnss.IGnssBatching;
import android.hardware.gnss.IGnssCallback;
import android.hardware.gnss.IGnssConfiguration;
@@ -277,4 +278,11 @@ interface IGnss {
void setPositionMode(in GnssPositionMode mode, in GnssPositionRecurrence recurrence,
in int minIntervalMs, in int preferredAccuracyMeters, in int preferredTimeMs,
in boolean lowPowerMode);
/*
* This method returns the IGnssAntennaInfo.
*
* @return Handle to the IGnssAntennaInfo.
*/
IGnssAntennaInfo getExtensionGnssAntennaInfo();
}

41
gnss/aidl/android/hardware/gnss/IGnssAntennaInfo.aidl Normal file
View File

@@ -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.
*/
package android.hardware.gnss;
import android.hardware.gnss.IGnssAntennaInfoCallback;
/**
* Extended interface for GNSS antenna information support.
*/
@VintfStability
interface IGnssAntennaInfo {
/**
* Registers the callback routines with the HAL.
*
* @param callback Handle to the GnssAntennaInfo callback interface.
*/
void setCallback(in IGnssAntennaInfoCallback callback);
/**
* Stops updates from the HAL, and unregisters the callback routines.
* After a call to close(), the previously registered callbacks must be
* considered invalid by the HAL.
* If close() is invoked without a previous setCallback, this function must perform
* no work.
*/
void close();
}

140
gnss/aidl/android/hardware/gnss/IGnssAntennaInfoCallback.aidl Normal file
View File

@@ -0,0 +1,140 @@
/*
* 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;
/**
* The callback interface to report GNSS antenna information from the HAL.
*/
@VintfStability
interface IGnssAntennaInfoCallback {
/**
* A row of doubles. This is used to represent a row in a 2D array, which are used to
* characterize the phase center variation corrections and signal gain corrections.
*/
@VintfStability
parcelable Row {
double[] row;
}
/**
* A point in 3D space, with associated uncertainty.
*/
@VintfStability
parcelable Coord {
double x;
double xUncertainty;
double y;
double yUncertainty;
double z;
double zUncertainty;
}
@VintfStability
parcelable GnssAntennaInfo {
/**
* The carrier frequency in Hz.
*/
long carrierFrequencyHz;
/**
* Phase center offset (PCO) with associated 1-sigma uncertainty. PCO is defined with
* respect to the origin of the Android sensor coordinate system, e.g., center of primary
* screen for mobiles - see sensor or form factor documents for details.
*/
Coord phaseCenterOffsetCoordinateMillimeters;
/**
* 2D vectors representing the phase center variation (PCV) corrections, in
* millimeters, at regularly spaced azimuthal angle (theta) and zenith angle
* (phi). The PCV correction is added to the phase measurement to obtain the
* corrected value.
*
* The azimuthal angle, theta, is defined with respect to the X axis of the
* Android sensor coordinate system, increasing toward the Y axis. The zenith
* angle, phi, is defined with respect to the Z axis of the Android Sensor
* coordinate system, increasing toward the X-Y plane.
*
* Each row vector (outer vectors) represents a fixed theta. The first row
* corresponds to a theta angle of 0 degrees. The last row corresponds to a
* theta angle of (360 - deltaTheta) degrees, where deltaTheta is the regular
* spacing between azimuthal angles, i.e., deltaTheta = 360 / (number of rows).
*
* The columns (inner vectors) represent fixed zenith angles, beginning at 0
* degrees and ending at 180 degrees. They are separated by deltaPhi, the regular
* spacing between zenith angles, i.e., deltaPhi = 180 / (number of columns - 1).
*
* This field is optional, i.e., an empty vector.
*/
Row[] phaseCenterVariationCorrectionMillimeters;
/**
* 2D vectors of 1-sigma uncertainty in millimeters associated with the PCV
* correction values.
*
* This field is optional, i.e., an empty vector.
*/
Row[] phaseCenterVariationCorrectionUncertaintyMillimeters;
/**
* 2D vectors representing the signal gain corrections at regularly spaced
* azimuthal angle (theta) and zenith angle (phi). The values are calculated or
* measured at the antenna feed point without considering the radio and receiver
* noise figure and path loss contribution, in dBi, i.e., decibel over isotropic
* antenna with the same total power. The signal gain correction is added the
* signal gain measurement to obtain the corrected value.
*
* The azimuthal angle, theta, is defined with respect to the X axis of the
* Android sensor coordinate system, increasing toward the Y axis. The zenith
* angle, phi, is defined with respect to the Z axis of the Android Sensor
* coordinate system, increasing toward the X-Y plane.
*
* Each row vector (outer vectors) represents a fixed theta. The first row
* corresponds to a theta angle of 0 degrees. The last row corresponds to a
* theta angle of (360 - deltaTheta) degrees, where deltaTheta is the regular
* spacing between azimuthal angles, i.e., deltaTheta = 360 / (number of rows).
*
* The columns (inner vectors) represent fixed zenith angles, beginning at 0
* degrees and ending at 180 degrees. They are separated by deltaPhi, the regular
* spacing between zenith angles, i.e., deltaPhi = 180 / (number of columns - 1).
*
* This field is optional, i.e., an empty vector.
*/
Row[] signalGainCorrectionDbi;
/**
* 2D vectors of 1-sigma uncertainty in dBi associated with the signal
* gain correction values.
*
* This field is optional, i.e., an empty vector.
*/
Row[] signalGainCorrectionUncertaintyDbi;
}
/**
* Called when on connection, and on known-change to these values, such as upon a known
* GNSS RF antenna tuning change, or a foldable device state change.
*
* This is optional. It can never be called if the GNSS antenna information is not
* available.
*/
void gnssAntennaInfoCb(in GnssAntennaInfo[] gnssAntennaInfos);
}

2
gnss/aidl/android/hardware/gnss/IGnssCallback.aidl
View File

@@ -67,7 +67,7 @@ interface IGnssCallback {
/** Capability bit mask indicating that GNSS supports measurement corrections */
const int CAPABILITY_MEASUREMENT_CORRECTIONS = 1 << 10;
/** Capability bit mask indicating that GNSS supports measurement corrections */
/** Capability bit mask indicating that GNSS supports antenna info */
const int CAPABILITY_ANTENNA_INFO = 1 << 11;
/** Capability bit mask indicating that GNSS supports correlation vector */

1
gnss/aidl/default/Android.bp
View File

@@ -58,6 +58,7 @@ cc_binary {
srcs: [
"AGnss.cpp",
"Gnss.cpp",
"GnssAntennaInfo.cpp",
"GnssBatching.cpp",
"GnssDebug.cpp",
"GnssGeofence.cpp",

12
gnss/aidl/default/Gnss.cpp
View File

@@ -21,6 +21,7 @@
#include <log/log.h>
#include "AGnss.h"
#include "DeviceFileReader.h"
#include "GnssAntennaInfo.h"
#include "GnssBatching.h"
#include "GnssConfiguration.h"
#include "GnssDebug.h"
@@ -56,7 +57,8 @@ ScopedAStatus Gnss::setCallback(const std::shared_ptr<IGnssCallback>& callback)
int capabilities = (int)(IGnssCallback::CAPABILITY_SATELLITE_BLOCKLIST |
IGnssCallback::CAPABILITY_SATELLITE_PVT |
IGnssCallback::CAPABILITY_CORRELATION_VECTOR);
IGnssCallback::CAPABILITY_CORRELATION_VECTOR |
IGnssCallback::CAPABILITY_ANTENNA_INFO);
auto status = sGnssCallback->gnssSetCapabilitiesCb(capabilities);
if (!status.isOk()) {
@@ -279,4 +281,12 @@ ndk::ScopedAStatus Gnss::getExtensionGnssVisibilityControl(
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Gnss::getExtensionGnssAntennaInfo(
std::shared_ptr<IGnssAntennaInfo>* iGnssAntennaInfo) {
ALOGD("Gnss::getExtensionGnssAntennaInfo");
*iGnssAntennaInfo = SharedRefBase::make<GnssAntennaInfo>();
return ndk::ScopedAStatus::ok();
}
} // namespace aidl::android::hardware::gnss

3
gnss/aidl/default/Gnss.h
View File

@@ -18,6 +18,7 @@
#include <aidl/android/hardware/gnss/BnAGnss.h>
#include <aidl/android/hardware/gnss/BnGnss.h>
#include <aidl/android/hardware/gnss/BnGnssAntennaInfo.h>
#include <aidl/android/hardware/gnss/BnGnssBatching.h>
#include <aidl/android/hardware/gnss/BnGnssConfiguration.h>
#include <aidl/android/hardware/gnss/BnGnssDebug.h>
@@ -69,6 +70,8 @@ class Gnss : public BnGnss {
ndk::ScopedAStatus getExtensionGnssVisibilityControl(
std::shared_ptr<android::hardware::gnss::visibility_control::IGnssVisibilityControl>*
iGnssVisibilityControl) override;
ndk::ScopedAStatus getExtensionGnssAntennaInfo(
std::shared_ptr<IGnssAntennaInfo>* iGnssAntennaInfo) override;
std::shared_ptr<GnssConfiguration> mGnssConfiguration;
std::shared_ptr<GnssPowerIndication> mGnssPowerIndication;

149
gnss/aidl/default/GnssAntennaInfo.cpp Normal file
View File

@@ -0,0 +1,149 @@
/*
* 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 "GnssAntennaInfoAidl"
#include "GnssAntennaInfo.h"
#include <aidl/android/hardware/gnss/BnGnss.h>
#include <log/log.h>
#include "Utils.h"
namespace aidl::android::hardware::gnss {
using namespace ::android::hardware::gnss;
using Row = IGnssAntennaInfoCallback::Row;
using Coord = IGnssAntennaInfoCallback::Coord;
std::shared_ptr<IGnssAntennaInfoCallback> GnssAntennaInfo::sCallback = nullptr;
GnssAntennaInfo::GnssAntennaInfo() : mMinIntervalMs(1000) {}
GnssAntennaInfo::~GnssAntennaInfo() {
stop();
}
// Methods from ::android::hardware::gnss::V2_1::IGnssAntennaInfo follow.
ndk::ScopedAStatus GnssAntennaInfo::setCallback(
const std::shared_ptr<IGnssAntennaInfoCallback>& callback) {
ALOGD("setCallback");
std::unique_lock<std::mutex> lock(mMutex);
sCallback = callback;
if (mIsActive) {
ALOGW("GnssAntennaInfo callback already set. Resetting the callback...");
stop();
}
start();
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus GnssAntennaInfo::close() {
ALOGD("close");
stop();
std::unique_lock<std::mutex> lock(mMutex);
sCallback = nullptr;
return ndk::ScopedAStatus::ok();
}
void GnssAntennaInfo::start() {
ALOGD("start");
mIsActive = true;
mThread = std::thread([this]() {
while (mIsActive == true) {
if (sCallback != nullptr) {
IGnssAntennaInfoCallback::GnssAntennaInfo mockAntennaInfo_1 = {
.carrierFrequencyHz = 1575420000,
.phaseCenterOffsetCoordinateMillimeters = Coord{.x = 1,
.xUncertainty = 0.1,
.y = 2,
.yUncertainty = 0.1,
.z = 3,
.zUncertainty = 0.1},
.phaseCenterVariationCorrectionMillimeters =
{
Row{std::vector<double>{1, -1, 5, -2, 3, -1}},
Row{std::vector<double>{-2, 3, 2, 0, 1, 2}},
Row{std::vector<double>{1, 3, 2, -1, -3, 5}},
},
.phaseCenterVariationCorrectionUncertaintyMillimeters =
{
Row{std::vector<double>{0.1, 0.2, 0.4, 0.1, 0.2, 0.3}},
Row{std::vector<double>{0.3, 0.2, 0.3, 0.6, 0.1, 0.1}},
Row{std::vector<double>{0.1, 0.1, 0.4, 0.2, 0.5, 0.3}},
},
.signalGainCorrectionDbi =
{
Row{std::vector<double>{2, -3, 1, -3, 0, -4}},
Row{std::vector<double>{1, 0, -4, 1, 3, -2}},
Row{std::vector<double>{3, -2, 0, -2, 3, 0}},
},
.signalGainCorrectionUncertaintyDbi =
{
Row{std::vector<double>{0.3, 0.1, 0.2, 0.6, 0.1, 0.3}},
Row{std::vector<double>{0.1, 0.1, 0.5, 0.2, 0.3, 0.1}},
Row{std::vector<double>{0.2, 0.4, 0.2, 0.1, 0.1, 0.2}},
},
};
IGnssAntennaInfoCallback::GnssAntennaInfo mockAntennaInfo_2 = {
.carrierFrequencyHz = 1176450000,
.phaseCenterOffsetCoordinateMillimeters = Coord{.x = 5,
.xUncertainty = 0.1,
.y = 6,
.yUncertainty = 0.1,
.z = 7,
.zUncertainty = 0.1},
};
std::vector<IGnssAntennaInfoCallback::GnssAntennaInfo> mockAntennaInfos = {
mockAntennaInfo_1,
mockAntennaInfo_2,
};
this->reportAntennaInfo(mockAntennaInfos);
}
/** For mock implementation this is good. On real device, we should only report
antennaInfo at start and when there is a configuration change. **/
std::this_thread::sleep_for(std::chrono::milliseconds(mMinIntervalMs));
}
});
}
void GnssAntennaInfo::stop() {
ALOGD("stop");
mIsActive = false;
if (mThread.joinable()) {
mThread.join();
}
}
void GnssAntennaInfo::reportAntennaInfo(
const std::vector<IGnssAntennaInfoCallback::GnssAntennaInfo>& antennaInfo) const {
std::unique_lock<std::mutex> lock(mMutex);
if (sCallback == nullptr) {
ALOGE("%s: No non-null callback", __func__);
return;
}
auto ret = sCallback->gnssAntennaInfoCb(antennaInfo);
if (!ret.isOk()) {
ALOGE("%s: Unable to invoke callback", __func__);
}
}
} // namespace aidl::android::hardware::gnss

51
gnss/aidl/default/GnssAntennaInfo.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* 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 <aidl/android/hardware/gnss/BnGnssAntennaInfo.h>
#include <atomic>
#include <mutex>
#include <thread>
namespace aidl::android::hardware::gnss {
struct GnssAntennaInfo : public BnGnssAntennaInfo {
public:
GnssAntennaInfo();
~GnssAntennaInfo();
ndk::ScopedAStatus setCallback(
const std::shared_ptr<IGnssAntennaInfoCallback>& callback) override;
ndk::ScopedAStatus close() override;
private:
void start();
void stop();
void reportAntennaInfo(
const std::vector<IGnssAntennaInfoCallback::GnssAntennaInfo>& antennaInfo) const;
// Guarded by mMutex
static std::shared_ptr<IGnssAntennaInfoCallback> sCallback;
std::atomic<bool> mIsActive;
std::atomic<long> mMinIntervalMs;
std::thread mThread;
// Synchronization lock for sCallback
mutable std::mutex mMutex;
};
} // namespace aidl::android::hardware::gnss

1
gnss/aidl/vts/Android.bp
View File

@@ -31,6 +31,7 @@ cc_test {
"gnss_hal_test.cpp",
"gnss_hal_test_cases.cpp",
"AGnssCallbackAidl.cpp",
"GnssAntennaInfoCallbackAidl.cpp",
"GnssBatchingCallback.cpp",
"GnssCallbackAidl.cpp",
"GnssGeofenceCallback.cpp",

26
gnss/aidl/vts/GnssAntennaInfoCallbackAidl.cpp Normal file
View File

@@ -0,0 +1,26 @@
/*
* 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 "GnssAntennaInfoCallbackAidl.h"
#include <inttypes.h>
#include <log/log.h>
android::binder::Status GnssAntennaInfoCallbackAidl::gnssAntennaInfoCb(
const std::vector<IGnssAntennaInfoCallback::GnssAntennaInfo>& gnssAntennaInfos) {
ALOGD("GnssAntennaInfo received. Size = %d", (int)gnssAntennaInfos.size());
antenna_info_cbq_.store(gnssAntennaInfos);
return android::binder::Status::ok();
}

36
gnss/aidl/vts/GnssAntennaInfoCallbackAidl.h Normal file
View File

@@ -0,0 +1,36 @@
/*
* 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 <android/hardware/gnss/BnGnssAntennaInfoCallback.h>
#include <vector>
#include "GnssCallbackEventQueue.h"
/** Implementation for IGnssAntennaInfoCallback. */
class GnssAntennaInfoCallbackAidl : public android::hardware::gnss::BnGnssAntennaInfoCallback {
public:
GnssAntennaInfoCallbackAidl() : antenna_info_cbq_("info"){};
~GnssAntennaInfoCallbackAidl(){};
android::binder::Status gnssAntennaInfoCb(
const std::vector<IGnssAntennaInfoCallback::GnssAntennaInfo>& gnssAntennaInfos)
override;
android::hardware::gnss::common::GnssCallbackEventQueue<
std::vector<IGnssAntennaInfoCallback::GnssAntennaInfo>>
antenna_info_cbq_;
};

85
gnss/aidl/vts/gnss_hal_test_cases.cpp
View File

@@ -18,6 +18,7 @@
#include <android/hardware/gnss/IAGnss.h>
#include <android/hardware/gnss/IGnss.h>
#include <android/hardware/gnss/IGnssAntennaInfo.h>
#include <android/hardware/gnss/IGnssBatching.h>
#include <android/hardware/gnss/IGnssDebug.h>
#include <android/hardware/gnss/IGnssMeasurementCallback.h>
@@ -27,6 +28,7 @@
#include <android/hardware/gnss/visibility_control/IGnssVisibilityControl.h>
#include <cutils/properties.h>
#include "AGnssCallbackAidl.h"
#include "GnssAntennaInfoCallbackAidl.h"
#include "GnssBatchingCallback.h"
#include "GnssGeofenceCallback.h"
#include "GnssMeasurementCallbackAidl.h"
@@ -44,6 +46,8 @@ using android::hardware::gnss::GnssMeasurement;
using android::hardware::gnss::GnssPowerStats;
using android::hardware::gnss::IAGnss;
using android::hardware::gnss::IGnss;
using android::hardware::gnss::IGnssAntennaInfo;
using android::hardware::gnss::IGnssAntennaInfoCallback;
using android::hardware::gnss::IGnssBatching;
using android::hardware::gnss::IGnssBatchingCallback;
using android::hardware::gnss::IGnssCallback;
@@ -1009,3 +1013,84 @@ TEST_P(GnssHalTest, TestGnssAgcInGnssMeasurement) {
status = iGnssMeasurement->close();
ASSERT_TRUE(status.isOk());
}
/*
* TestGnssAntennaInfo:
* Sets a GnssAntennaInfoCallback, waits for report, and verifies
* 1. phaseCenterOffsetCoordinateMillimeters is valid
* 2. phaseCenterOffsetCoordinateUncertaintyMillimeters is valid.
* PhaseCenterVariationCorrections and SignalGainCorrections are optional.
*/
TEST_P(GnssHalTest, TestGnssAntennaInfo) {
const int kAntennaInfoTimeoutSeconds = 2;
if (aidl_gnss_hal_->getInterfaceVersion() == 1) {
return;
}
sp<IGnssAntennaInfo> iGnssAntennaInfo;
auto status = aidl_gnss_hal_->getExtensionGnssAntennaInfo(&iGnssAntennaInfo);
ASSERT_TRUE(status.isOk());
if (!(aidl_gnss_cb_->last_capabilities_ & (int)GnssCallbackAidl::CAPABILITY_ANTENNA_INFO) ||
iGnssAntennaInfo == nullptr) {
ALOGD("GnssAntennaInfo AIDL is not supported.");
return;
}
auto callback = sp<GnssAntennaInfoCallbackAidl>::make();
status = iGnssAntennaInfo->setCallback(callback);
ASSERT_TRUE(status.isOk());
std::vector<IGnssAntennaInfoCallback::GnssAntennaInfo> antennaInfos;
ASSERT_TRUE(callback->antenna_info_cbq_.retrieve(antennaInfos, kAntennaInfoTimeoutSeconds));
EXPECT_EQ(callback->antenna_info_cbq_.calledCount(), 1);
ASSERT_TRUE(antennaInfos.size() > 0);
for (auto antennaInfo : antennaInfos) {
// Remaining fields are optional
if (!antennaInfo.phaseCenterVariationCorrectionMillimeters.empty()) {
int numRows = antennaInfo.phaseCenterVariationCorrectionMillimeters.size();
int numColumns = antennaInfo.phaseCenterVariationCorrectionMillimeters[0].row.size();
// Must have at least 1 row and 2 columns
ASSERT_TRUE(numRows >= 1 && numColumns >= 2);
// Corrections and uncertainties must have same dimensions
ASSERT_TRUE(antennaInfo.phaseCenterVariationCorrectionMillimeters.size() ==
antennaInfo.phaseCenterVariationCorrectionUncertaintyMillimeters.size());
ASSERT_TRUE(
antennaInfo.phaseCenterVariationCorrectionMillimeters[0].row.size() ==
antennaInfo.phaseCenterVariationCorrectionUncertaintyMillimeters[0].row.size());
// Must be rectangular
for (auto row : antennaInfo.phaseCenterVariationCorrectionMillimeters) {
ASSERT_TRUE(row.row.size() == numColumns);
}
for (auto row : antennaInfo.phaseCenterVariationCorrectionUncertaintyMillimeters) {
ASSERT_TRUE(row.row.size() == numColumns);
}
}
if (!antennaInfo.signalGainCorrectionDbi.empty()) {
int numRows = antennaInfo.signalGainCorrectionDbi.size();
int numColumns = antennaInfo.signalGainCorrectionUncertaintyDbi[0].row.size();
// Must have at least 1 row and 2 columns
ASSERT_TRUE(numRows >= 1 && numColumns >= 2);
// Corrections and uncertainties must have same dimensions
ASSERT_TRUE(antennaInfo.signalGainCorrectionDbi.size() ==
antennaInfo.signalGainCorrectionUncertaintyDbi.size());
ASSERT_TRUE(antennaInfo.signalGainCorrectionDbi[0].row.size() ==
antennaInfo.signalGainCorrectionUncertaintyDbi[0].row.size());
// Must be rectangular
for (auto row : antennaInfo.signalGainCorrectionDbi) {
ASSERT_TRUE(row.row.size() == numColumns);
}
for (auto row : antennaInfo.signalGainCorrectionUncertaintyDbi) {
ASSERT_TRUE(row.row.size() == numColumns);
}
}
}
iGnssAntennaInfo->close();
}