fuquan/allwinner_a64
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

upload android base code part4

Browse source
This commit is contained in:
August 2018-08-08 17:00:29 +08:00
parent b9e30e05b1
commit 78ea2404cd
23455 changed files with 5250148 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

73
android/hardware/interfaces/wifi/offload/1.0/Android.bp Normal file
View file

@ -0,0 +1,73 @@
// This file is autogenerated by hidl-gen. Do not edit manually.
filegroup {
name: "android.hardware.wifi.offload@1.0_hal",
srcs: [
"types.hal",
"IOffload.hal",
"IOffloadCallback.hal",
],
}
genrule {
name: "android.hardware.wifi.offload@1.0_genc++",
tools: ["hidl-gen"],
cmd: "$(location hidl-gen) -o $(genDir) -Lc++-sources -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.wifi.offload@1.0",
srcs: [
":android.hardware.wifi.offload@1.0_hal",
],
out: [
"android/hardware/wifi/offload/1.0/types.cpp",
"android/hardware/wifi/offload/1.0/OffloadAll.cpp",
"android/hardware/wifi/offload/1.0/OffloadCallbackAll.cpp",
],
}
genrule {
name: "android.hardware.wifi.offload@1.0_genc++_headers",
tools: ["hidl-gen"],
cmd: "$(location hidl-gen) -o $(genDir) -Lc++-headers -randroid.hardware:hardware/interfaces -randroid.hidl:system/libhidl/transport android.hardware.wifi.offload@1.0",
srcs: [
":android.hardware.wifi.offload@1.0_hal",
],
out: [
"android/hardware/wifi/offload/1.0/types.h",
"android/hardware/wifi/offload/1.0/hwtypes.h",
"android/hardware/wifi/offload/1.0/IOffload.h",
"android/hardware/wifi/offload/1.0/IHwOffload.h",
"android/hardware/wifi/offload/1.0/BnHwOffload.h",
"android/hardware/wifi/offload/1.0/BpHwOffload.h",
"android/hardware/wifi/offload/1.0/BsOffload.h",
"android/hardware/wifi/offload/1.0/IOffloadCallback.h",
"android/hardware/wifi/offload/1.0/IHwOffloadCallback.h",
"android/hardware/wifi/offload/1.0/BnHwOffloadCallback.h",
"android/hardware/wifi/offload/1.0/BpHwOffloadCallback.h",
"android/hardware/wifi/offload/1.0/BsOffloadCallback.h",
],
}
cc_library {
name: "android.hardware.wifi.offload@1.0",
defaults: ["hidl-module-defaults"],
generated_sources: ["android.hardware.wifi.offload@1.0_genc++"],
generated_headers: ["android.hardware.wifi.offload@1.0_genc++_headers"],
export_generated_headers: ["android.hardware.wifi.offload@1.0_genc++_headers"],
vendor_available: true,
vndk: {
enabled: true,
},
shared_libs: [
"libhidlbase",
"libhidltransport",
"libhwbinder",
"liblog",
"libutils",
"libcutils",
],
export_shared_lib_headers: [
"libhidlbase",
"libhidltransport",
"libhwbinder",
"libutils",
],
}

87
android/hardware/interfaces/wifi/offload/1.0/IOffload.hal Normal file
View file

@ -0,0 +1,87 @@
/*
* Copyright 2016 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.wifi.offload@1.0;
import IOffloadCallback;
interface IOffload {
/**
* Configure the offload module to perform scans and filter results
* Scans must not be triggered due to configuration of the module.
*
* @param ScanParam paramters for scanning
* @param ScanFilter settings to filter scan result
* @return OffloadStatus indicating status of operation provided by this API
* If OffloadStatusCode::OK is returned, the operation was successful
* If OffloadStatusCode::NO_CONNECTION is returned, connection to the hardware is lost
* If OffloadStatusCode::ERROR is returned, requested operation could not be completed
*/
@entry
@callflow(next={"setEventCallback", "subscribeScanResults"})
configureScans(ScanParam param, ScanFilter filter) generates (OffloadStatus status);
/**
* Get scan statistics
*
* @return OffloadStatus indicating status of operation provided by this API
* @return ScanStats statistics of scans performed
* If OffloadStatusCode::OK is returned, the operation was successful
* If OffloadStatusCode::NO_CONNECTION is returned, connection to the hardware is lost
* If OffloadStatusCode::ERROR is returned, requested operation could not be completed
* If OffloadStatusCode::TIMEOUT is returned, time out waiting for the requested data
*/
@exit
@callflow(next={"subscribeScanResults", "unsubscribeScanResults", "getScanStats"})
getScanStats() generates (OffloadStatus status, ScanStats scanStats);
/**
* Subscribe to asynchronous scan events sent by offload module. This enables
* offload scans to be performed as per scan parameters, filtering the scan
* results based on configured scan filter and delivering the results after
* at least delayMs milliseconds from this call. If the client is already
* subscribed to the scan results, a call to this API must be a no-op.
*
* @param delayMs an integer expressing the minimum delay in mS after
* subscribing when scan results must be delivered to the client
* @return OffloadStatus indicating status of operation provided by this API
* If OffloadStatusCode::OK is returned, the operation was successful
* If OffloadStatusCode::NO_CONNECTION is returned, connection to the hardware is lost
* If OffloadStatusCode::ERROR is returned, requested operation could not be completed
*/
@callflow(next={"unsubscribeScanResults", "getScanStats"})
subscribeScanResults(uint32_t delayMs) generates (OffloadStatus status);
/**
* Unsubscribe to scan events sent by the offload module, hence disabling scans.
* If the client is already unsubscribed, a call to this API will be a no-op.
*/
@exit
@callflow(next={"*"})
unsubscribeScanResults();
/**
* Setup the HIDL interface for reporting asynchronous scan events. A maximum
* of one callback interface is supported. Only one callback must be registered
* at any given time. If two consecutive calls are made with different callback
* interface objects, the latest one must be used to deliver events to client.
*
* @param cb An instance of the |IOffloadCallback| HIDL interface object
*/
@entry
@callflow(next={"subscribeScanStats", "configureScans"})
setEventCallback(IOffloadCallback cb);
};

32
android/hardware/interfaces/wifi/offload/1.0/IOffloadCallback.hal Normal file
View file

@ -0,0 +1,32 @@
/*
* Copyright 2016 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.wifi.offload@1.0;
interface IOffloadCallback {
/**
* Interface for the Offload HAL to return scan events to the client
*
* @param scanResult a vector of scan result objects
*/
oneway onScanResult(vec<ScanResult> scanResult);
/**
* Interface for the Offload HAL to inform the client of error conditions
* see OffloadStatus for the error conditions to be reported
*
* @param status OffloadStatus
*/
oneway onError(OffloadStatus status);
};

226
android/hardware/interfaces/wifi/offload/1.0/types.hal Normal file
View file

@ -0,0 +1,226 @@
/*
* Copyright 2017 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.wifi.offload@1.0;
/**
* Defines a bitmap of security modes
*/
enum SecurityMode : uint8_t {
OPEN = 0x1 << 1,
WEP = 0x1 << 2,
PSK = 0x1 << 3,
EAP = 0x1 << 4,
};
/**
* SSID of the Access Point, maximum 32 characters
*/
typedef vec<uint8_t> Ssid;
/**
* Preferred network information
* SSID and associated security mode(s)
*/
struct NetworkInfo {
Ssid ssid;
/* SecurityMode flags that are associated with this SSID
* More than one security mode can be supported, see SecurityMode */
bitfield<SecurityMode> flags;
};
/**
* This is a bit mask describing the capabilities of a BSS.
* See IEEE Std 802.11: 8.4.1.4
*/
enum Capability : uint16_t {
ESS = 1 << 0,
IBSS = 1 << 1,
CF_POLLABLE = 1 << 2,
CF_PLL_REQ = 1 << 3,
PRIVACY = 1 << 4,
SHORT_PREAMBLE = 1 << 5,
PBCC = 1 << 6,
CHANNEL_AGILITY = 1 << 7,
SPECTURM_MGMT = 1 << 8,
QOS = 1 << 9,
SHORT_SLOT_TIME = 1 << 10,
APSD = 1 << 11,
RADIO_MEASUREMENT = 1 << 12,
DSSS_OFDM = 1 << 13,
DELAYED_BLOCK_ACK = 1 << 14,
IMMEDIATE_BLOCK_ACK = 1 << 15,
};
/**
* Scan Results returned by the offload Hal
*/
struct ScanResult {
/* Information about this BSS
* SSID and security modes supported */
NetworkInfo networkInfo;
/* BSSID of the BSS */
uint8_t[6] bssid;
/* Can have multiple bits set, see Capability */
bitfield<Capability> capability;
/* Frequency scanned, in mHz */
uint32_t frequency;
/* Signal strength in dBm */
int8_t rssi;
/* TSF found in beacon/probe response */
uint64_t tsf;
};
/**
* Parameters for performing offload scans
*/
struct ScanParam {
/* Specify a list of SSIDs to scan, an empty list implies no preferred
* networks to scan */
vec<Ssid> ssidList;
/* Frequencies to scan, in mHz, an empty frequency list implies a full scan */
vec<uint32_t> frequencyList;
/* Periodicity of the scans to be performed by the offload module
* A value of zero indicates disable periodic scans. For this revision,
* where offload module is performing scans in disconnected mode, this value
* should not be zero. In future versions, periodic scans can be eliminated */
uint32_t disconnectedModeScanIntervalMs;
};
/**
* Instruction on how to filter the scan result before performing network
* selection and waking up the AP to connect
*/
struct ScanFilter {
/* Preferred network List of SSIDs and their security mode of interest
* The filter will drop the remaining scan results in the scan event.
* An empty list implies no filtering of scan result based on SSID and
* security mode. */
vec<NetworkInfo> preferredNetworkInfoList;
/* Minimum qualifying RSSI to be considered for network selection (dBm) */
int8_t rssiThreshold;
};
struct ScanRecord {
/* Amount of time spent scanning */
uint64_t durationMs;
/* Number of channels scanned */
uint32_t numChannelsScanned;
/* Number of entries aggregated into this record */
uint32_t numEntriesAggregated;
};
/**
* Enumerates the type of log that is recorded
*/
enum RecordName : uint32_t {
CMD_BASE = 0x00001000,
/* Record name corresponding to initialization */
CMD_INT = CMD_BASE + 0,
/* Record name corresponding to configureScans() API */
CMD_CONFIG_SCANS = CMD_BASE + 1,
/* Record name corresponding to subscribeScanResults() API */
CMD_SUBSCRIBE_SCAN_RESULTS = CMD_BASE + 2,
/* Record name corresponding to unsubscribeScanResults() API */
CMD_UNSUBSCRIBE_SCAN_RESULTS = CMD_BASE + 3,
/* Record name corresponding to getScanStats() API */
CMD_GET_SCAN_STATS = CMD_BASE + 4,
/* Record name corresponding to a reset*/
CMD_RESET = CMD_BASE + 5,
/* Add new commands here */
EVENT_RECVD_BASE = 0x00002000,
/* Record name corresponding to scan monitor event*/
EVENT_RECVD_SCAN_RESULT_ASYNC = EVENT_RECVD_BASE + 0,
/* Record name corresponding to scan response event */
EVENT_RECVD_SCAN_RESULT = EVENT_RECVD_BASE + 1,
/* Add new events received here */
EVENT_SENT_BASE = 0x00003000,
/* Record name corresponding to scan event sent */
EVENT_SENT_SCAN_RESULT = EVENT_SENT_BASE + 0,
/* Record name corresponding to abort event sent */
EVENT_SENT_ABORT = EVENT_SENT_BASE + 1,
/* Record name corresponding to error event sent */
EVENT_SENT_ERROR = EVENT_SENT_BASE + 2,
/* Add new events sent here */
REQ_BASE = 0x00004000,
/* Record name corresponding to scan request sent*/
REQ_SCAN = REQ_BASE + 0,
/* Add new requests here */
};
/**
* Defines the structure of each log record
*/
struct LogRecord {
/* Indicates the log recorded */
RecordName recordName;
/* Platform reference time in milliseconds when the log is recorded */
uint64_t logTimeMs;
};
/**
* Defines the scan statistics to be returned to the framework
*/
struct ScanStats {
/* Incremented everytime a new scan is requested */
uint32_t numScansRequestedByWifi;
/* Incremented everytime the scan is serviced by performing a scan*/
uint32_t numScansServicedByWifi;
/* Incremented everytime the scan is serviced by the scan cache */
uint32_t numScansServicedbyCache;
/* The last (CHRE reference) time this data structure is updated */
uint64_t lastUpdated;
/* The last (CHRE reference) time this data structure is read */
uint64_t lastRead;
/* The total time when the Offload module could be performing scans (T2 - T1)
* T1 - time when the framework subscribes for scan result (includes delayMs)
* T2 - min (time when the framework unsubscribes for scan result,
* currentTime) */
uint64_t subscriptionDurationMs;
/* Histograms of the channels scanned, 802.11 and with an 8 bit
* representation, only 256 channels are available */
uint8_t[256] histogramChannelsScanned;
/* Scan Record for this subscribe duration */
vec<ScanRecord> scanRecord;
/* Vector of the logRecord entries */
vec<LogRecord> logRecord;
};
/**
* Defines a list of return codes to indicate status of Offload HAL
*/
enum OffloadStatusCode : uint32_t {
/* No error */
OK,
/* No Connection to underlying implementation */
NO_CONNECTION,
/* Operation timeout */
TIMEOUT,
/* Other errors */
ERROR
};
/**
* Generic structures to return the status of an operation
*/
struct OffloadStatus {
OffloadStatusCode code;
/* Error message */
string description;
};

22
android/hardware/interfaces/wifi/offload/1.0/vts/functional/Android.bp Normal file
View file

@ -0,0 +1,22 @@
//
// Copyright (C) 2017 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: "VtsHalWifiOffloadV1_0TargetTest",
defaults: ["VtsHalTargetTestDefaults"],
srcs: ["VtsHalWifiOffloadV1_0TargetTest.cpp"],
static_libs: ["android.hardware.wifi.offload@1.0"],
}

227
android/hardware/interfaces/wifi/offload/1.0/vts/functional/VtsHalWifiOffloadV1_0TargetTest.cpp Normal file
View file

@ -0,0 +1,227 @@
/*
* Copyright (C) 2016 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 "wifi_offload_hidl_hal_test"
#include <android-base/logging.h>
#include <android/hardware/wifi/offload/1.0/IOffload.h>
#include <android/hardware/wifi/offload/1.0/IOffloadCallback.h>
#include <android/hardware/wifi/offload/1.0/types.h>
#include <VtsHalHidlTargetCallbackBase.h>
#include <VtsHalHidlTargetTestBase.h>
#include <vector>
#include "hidl_call_util.h"
using ::android::hardware::wifi::offload::V1_0::IOffload;
using ::android::hardware::wifi::offload::V1_0::IOffloadCallback;
using ::android::hardware::wifi::offload::V1_0::ScanResult;
using ::android::hardware::wifi::offload::V1_0::ScanParam;
using ::android::hardware::wifi::offload::V1_0::Ssid;
using ::android::hardware::wifi::offload::V1_0::NetworkInfo;
using ::android::hardware::wifi::offload::V1_0::ScanFilter;
using ::android::hardware::wifi::offload::V1_0::ScanStats;
using ::android::hardware::wifi::offload::V1_0::OffloadStatus;
using ::android::hardware::wifi::offload::V1_0::OffloadStatusCode;
using ::android::hardware::Return;
using ::android::hardware::Void;
using ::android::hardware::hidl_vec;
using ::android::sp;
constexpr char kOffloadCallbackSendScanResult[] = "onScanResult";
constexpr char kOffloadCallbackSendError[] = "onError";
namespace {
const uint8_t kSsid1[] = {'G', 'o', 'o', 'g', 'l', 'e'};
const uint8_t kSsid2[] = {'X', 'f', 'i', 'n', 'i', 't', 'y'};
const uint8_t kBssid[6] = {0x12, 0xef, 0xa1, 0x2c, 0x97, 0x8b};
const int16_t kRssi = -60;
const uint32_t kFrequency = 2412;
const uint8_t kBssidSize = 6;
const uint64_t kTsf = 0;
const uint16_t kCapability = 0;
const uint8_t kNetworkFlags = 0;
const uint32_t kFrequency1 = 2412;
const uint32_t kFrequency2 = 2437;
const uint32_t kDisconnectedModeScanIntervalMs = 5000;
const int16_t kRssiThreshold = -76;
}
class OffloadCallbackArgs {
public:
hidl_vec<ScanResult> scan_results_;
OffloadStatus error_code_;
};
// The main test class for WifiOffload HIDL HAL.
class WifiOffloadHidlTest : public ::testing::VtsHalHidlTargetTestBase {
public:
virtual void SetUp() override {
wifi_offload_ =
::testing::VtsHalHidlTargetTestBase::getService<IOffload>();
ASSERT_NE(wifi_offload_, nullptr);
wifi_offload_cb_ = new OffloadCallback();
ASSERT_NE(wifi_offload_cb_, nullptr);
}
virtual void TearDown() override {}
/* Callback class for Offload HAL. */
class OffloadCallback
: public ::testing::VtsHalHidlTargetCallbackBase<OffloadCallbackArgs>,
public IOffloadCallback {
public:
OffloadCallback(){};
virtual ~OffloadCallback() = default;
Return<void> onScanResult(
const hidl_vec<ScanResult>& scan_result) override {
OffloadCallbackArgs args;
args.scan_results_ = scan_result;
NotifyFromCallback(kOffloadCallbackSendScanResult, args);
return Void();
};
Return<void> onError(const OffloadStatus& status) override {
OffloadCallbackArgs args;
args.error_code_ = status;
NotifyFromCallback(kOffloadCallbackSendError, args);
return Void();
}
};
sp<IOffload> wifi_offload_;
sp<OffloadCallback> wifi_offload_cb_;
};
/*
* Verify that setEventCallback method returns without errors
*/
TEST_F(WifiOffloadHidlTest, setEventCallback) {
auto returnObject = wifi_offload_->setEventCallback(wifi_offload_cb_);
ASSERT_EQ(true, returnObject.isOk());
}
/*
* Verify that subscribeScanResults method returns without errors
*/
TEST_F(WifiOffloadHidlTest, subscribeScanResults) {
const auto& result = HIDL_INVOKE(wifi_offload_, subscribeScanResults, 0);
ASSERT_EQ(OffloadStatusCode::OK, result.code);
}
/*
* Verify that unsubscribeScanResults method returns without errors
*/
TEST_F(WifiOffloadHidlTest, unsubscribeScanResults) {
auto returnObject = wifi_offload_->unsubscribeScanResults();
ASSERT_EQ(true, returnObject.isOk());
}
/*
* Verify that configureScans method returns without errors
*/
TEST_F(WifiOffloadHidlTest, configureScans) {
ScanParam* pScanParam = new ScanParam();
std::vector<uint32_t> frequencyList = {kFrequency1, kFrequency2};
pScanParam->disconnectedModeScanIntervalMs =
kDisconnectedModeScanIntervalMs;
pScanParam->frequencyList = frequencyList;
std::vector<Ssid> ssidList;
std::vector<std::vector<uint8_t>> ssids{kSsid1, kSsid2};
for (const auto& ssid : ssids) {
Ssid tmp = ssid;
ssidList.push_back(tmp);
}
pScanParam->ssidList = ssidList;
ScanFilter* pScanFilter = new ScanFilter();
pScanFilter->rssiThreshold = kRssiThreshold;
std::vector<std::vector<uint8_t>> match_ssids{kSsid1, kSsid2};
std::vector<uint8_t> security_flags{kNetworkFlags, kNetworkFlags};
std::vector<NetworkInfo> preferredNetworksList;
for (size_t i = 0; i < security_flags.size(); i++) {
NetworkInfo nwInfo;
nwInfo.ssid = match_ssids[i];
nwInfo.flags = security_flags[i];
preferredNetworksList.push_back(nwInfo);
}
const auto& result =
HIDL_INVOKE(wifi_offload_, configureScans, *pScanParam, *pScanFilter);
ASSERT_EQ(OffloadStatusCode::OK, result.code);
}
/*
* Verify that getScanStats returns without any errors
*/
TEST_F(WifiOffloadHidlTest, getScanStats) {
const auto& result = HIDL_INVOKE(wifi_offload_, getScanStats);
OffloadStatus status = result.first;
ASSERT_EQ(OffloadStatusCode::OK, status.code);
}
/*
* Verify that onScanResult callback is invoked
*/
TEST_F(WifiOffloadHidlTest, getScanResults) {
wifi_offload_->setEventCallback(wifi_offload_cb_);
std::vector<ScanResult> scan_results;
std::vector<uint8_t> ssid(kSsid1, kSsid1 + sizeof(kSsid1));
ScanResult scan_result;
scan_result.tsf = kTsf;
scan_result.rssi = kRssi;
scan_result.frequency = kFrequency;
scan_result.capability = kCapability;
memcpy(&scan_result.bssid[0], &kBssid[0], kBssidSize);
scan_result.networkInfo.ssid = ssid;
scan_result.networkInfo.flags = kNetworkFlags;
scan_results.push_back(scan_result);
wifi_offload_cb_->onScanResult(scan_results);
auto res =
wifi_offload_cb_->WaitForCallback(kOffloadCallbackSendScanResult);
ASSERT_EQ(true, res.no_timeout);
}
/*
* Verify that onError callback is invoked
*/
TEST_F(WifiOffloadHidlTest, getError) {
wifi_offload_->setEventCallback(wifi_offload_cb_);
OffloadStatus status = {OffloadStatusCode::ERROR, ""};
wifi_offload_cb_->onError(status);
auto res = wifi_offload_cb_->WaitForCallback(kOffloadCallbackSendError);
ASSERT_EQ(true, res.no_timeout);
}
// A class for test environment setup
class WifiOffloadHalHidlEnvironment : public ::testing::Environment {
public:
virtual void SetUp() {}
virtual void TearDown() {}
};
int main(int argc, char** argv) {
::testing::AddGlobalTestEnvironment(new WifiOffloadHalHidlEnvironment);
::testing::InitGoogleTest(&argc, argv);
int status = RUN_ALL_TESTS();
LOG(INFO) << "Test result = " << status;
return status;
}

123
android/hardware/interfaces/wifi/offload/1.0/vts/functional/hidl_call_util.h Normal file
View file

@ -0,0 +1,123 @@
/*
* Copyright (C) 2017 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 <functional>
#include <tuple>
#include <type_traits>
#include <utility>
#include <VtsHalHidlTargetTestBase.h>
namespace {
namespace detail {
template <typename>
struct functionArgSaver;
// Provides a std::function that takes one argument, and a buffer
// wherein the function will store its argument. The buffer has
// the same type as the argument, but with const and reference
// modifiers removed.
template <typename ArgT>
struct functionArgSaver<std::function<void(ArgT)>> final {
using StorageT = typename std::remove_const<
typename std::remove_reference<ArgT>::type>::type;
std::function<void(ArgT)> saveArgs = [this](ArgT arg) {
this->saved_values = arg;
};
StorageT saved_values;
};
// Provides a std::function that takes two arguments, and a buffer
// wherein the function will store its arguments. The buffer is a
// std::pair, whose elements have the same types as the arguments
// (but with const and reference modifiers removed).
template <typename Arg1T, typename Arg2T>
struct functionArgSaver<std::function<void(Arg1T, Arg2T)>> final {
using StorageT =
std::pair<typename std::remove_const<
typename std::remove_reference<Arg1T>::type>::type,
typename std::remove_const<
typename std::remove_reference<Arg2T>::type>::type>;
std::function<void(Arg1T, Arg2T)> saveArgs = [this](Arg1T arg1,
Arg2T arg2) {
this->saved_values = {arg1, arg2};
};
StorageT saved_values;
};
// Provides a std::function that takes three or more arguments, and a
// buffer wherein the function will store its arguments. The buffer is a
// std::tuple whose elements have the same types as the arguments (but
// with const and reference modifiers removed).
template <typename... ArgT>
struct functionArgSaver<std::function<void(ArgT...)>> final {
using StorageT = std::tuple<typename std::remove_const<
typename std::remove_reference<ArgT>::type>::type...>;
std::function<void(ArgT...)> saveArgs = [this](ArgT... arg) {
this->saved_values = {arg...};
};
StorageT saved_values;
};
// Invokes |method| on |object|, providing |method| a CallbackT as the
// final argument. Returns a copy of the parameters that |method| provided
// to CallbackT. (The parameters are returned by value.)
template <typename CallbackT, typename MethodT, typename ObjectT,
typename... ArgT>
typename functionArgSaver<CallbackT>::StorageT invokeMethod(
MethodT method, ObjectT object, ArgT&&... methodArg) {
functionArgSaver<CallbackT> result_buffer;
const auto& res = ((*object).*method)(std::forward<ArgT>(methodArg)...,
result_buffer.saveArgs);
EXPECT_TRUE(res.isOk());
return result_buffer.saved_values;
}
} // namespace detail
} // namespace
// Invokes |method| on |strong_pointer|, passing provided arguments through to
// |method|.
//
// Returns either:
// - A copy of the result callback parameter (for callbacks with a single
// parameter), OR
// - A pair containing a copy of the result callback parameters (for callbacks
// with two parameters), OR
// - A tuple containing a copy of the result callback paramters (for callbacks
// with three or more parameters).
//
// Example usage:
// EXPECT_EQ(WifiStatusCode::SUCCESS,
// HIDL_INVOKE(strong_pointer, methodReturningWifiStatus).code);
// EXPECT_EQ(WifiStatusCode::SUCCESS,
// HIDL_INVOKE(strong_pointer, methodReturningWifiStatusAndOneMore)
// .first.code);
// EXPECT_EQ(WifiStatusCode::SUCCESS, std::get<0>(
// HIDL_INVOKE(strong_pointer, methodReturningWifiStatusAndTwoMore))
// .code);
#define HIDL_INVOKE(strong_pointer, method, ...) \
(detail::invokeMethod< \
std::remove_reference<decltype(*strong_pointer)>::type::method##_cb>( \
&std::remove_reference<decltype(*strong_pointer)>::type::method, \
strong_pointer, ##__VA_ARGS__))