Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 69d5025e authored by Sohani Rao's avatar Sohani Rao
Browse files

Add Error callback from Offload HAL 

Error callback to report errors in Offload HAL service. Included VTS
tests to verify these callbacks are invoked.

Bug: 32842314
Test: Unit tests
Change-Id: I389b28b6ed5db7782ce6425beae67f5bdc2cf4aa
parent 0f7c890c

wifi/offload/1.0/IOffloadCallback.hal

+7 −0
Original line number Diff line number Diff line
@@ -22,4 +22,11 @@ interface IOffloadCallback { 
     * @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);

};

wifi/offload/1.0/types.hal

+14 −0
Original line number Diff line number Diff line
@@ -199,6 +199,20 @@ struct ScanStats { 
    vec<LogRecord> logRecord;

};



/**

 * Defines a list of return codes to indicate status of Offload HAL

 */

enum OffloadStatus : uint32_t {

    /* No error */

    OFFLOAD_STATUS_OK,

    /* No Connection to underlying implementation */

    OFFLOAD_STATUS_NO_CONNECTION,

    /* Operation timeout */

    OFFLOAD_STATUS_TIMEOUT,

    /* Other errors */

    OFFLOAD_STATUS_ERROR

};

wifi/offload/1.0/vts/functional/VtsHalWifiOffloadV1_0TargetTest.cpp

+70 −23
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#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>
@@ -31,13 +32,31 @@ using ::android::hardware::wifi::offload::V1_0::ScanResult; 
using ::android::hardware::wifi::offload::V1_0::ScanParam;

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::Return;

using ::android::hardware::Void;

using ::android::hardware::hidl_vec;

using ::android::sp;



typedef std::function<void(const std::vector<ScanResult>& scanResult)>

    OnOffloadScanResultsReadyHandler;

constexpr char kOffloadCallbackSendScanResult[] = "onScanResult";

constexpr char kOffloadCallbackSendError[] = "onError";



namespace {

const uint8_t kSsid[] = {'G', 'o', 'o', 'g', 'l', 'e'};

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;

}



class OffloadCallbackArgs {

   public:

    hidl_vec<ScanResult> scan_results_;

    OffloadStatus error_code_;

};



// The main test class for WifiOffload HIDL HAL.

class WifiOffloadHidlTest : public ::testing::VtsHalHidlTargetTestBase {
@@ -47,43 +66,39 @@ class WifiOffloadHidlTest : public ::testing::VtsHalHidlTargetTestBase { 
            ::testing::VtsHalHidlTargetTestBase::getService<IOffload>();

        ASSERT_NE(wifi_offload_, nullptr);



        wifi_offload_cb_ = new OffloadCallback(

            [this](std::vector<ScanResult> scanResult) -> void {

                this->reportScanResults(scanResult);

            });

        wifi_offload_cb_ = new OffloadCallback();

        ASSERT_NE(wifi_offload_cb_, nullptr);



        defaultSize = 0;

    }



    virtual void TearDown() override {}



    void reportScanResults(std::vector<ScanResult> scanResult) {

        defaultSize = scanResult.size();

    }



    /* Callback class for scanResult. */

    class OffloadCallback : public IOffloadCallback {

    /* Callback class for Offload HAL. */

    class OffloadCallback

        : public ::testing::VtsHalHidlTargetCallbackBase<OffloadCallbackArgs>,

          public IOffloadCallback {

       public:

        OffloadCallback(OnOffloadScanResultsReadyHandler handler)

            : handler_(handler){};

        OffloadCallback(){};



        virtual ~OffloadCallback() = default;



        Return<void> onScanResult(

            const hidl_vec<ScanResult>& scanResult) override {

            const std::vector<ScanResult> scanResult_(scanResult);

            handler_(scanResult_);

            const hidl_vec<ScanResult>& scan_result) override {

            OffloadCallbackArgs args;

            args.scan_results_ = scan_result;

            NotifyFromCallback(kOffloadCallbackSendScanResult, args);

            return Void();

        };



       private:

        OnOffloadScanResultsReadyHandler handler_;

        Return<void> onError(OffloadStatus status) {

            OffloadCallbackArgs args;

            args.error_code_ = status;

            NotifyFromCallback(kOffloadCallbackSendError, args);

            return Void();

        }

    };



    sp<IOffload> wifi_offload_;

    sp<IOffloadCallback> wifi_offload_cb_;

    int defaultSize = 0;

    sp<OffloadCallback> wifi_offload_cb_;

};



/*
@@ -133,6 +148,38 @@ TEST_F(WifiOffloadHidlTest, getScanStats) { 
    ASSERT_EQ(returnObject.isOk(), true);

}



/*

 * 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(kSsid, kSsid + sizeof(kSsid));

    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(res.no_timeout, true);

}



/*

 * Verify that onError callback is invoked

 */

TEST_F(WifiOffloadHidlTest, getError) {

    wifi_offload_->setEventCallback(wifi_offload_cb_);

    wifi_offload_cb_->onError(OffloadStatus::OFFLOAD_STATUS_ERROR);

    auto res = wifi_offload_cb_->WaitForCallback(kOffloadCallbackSendError);

    ASSERT_EQ(res.no_timeout, true);

}



// A class for test environment setup

class WifiOffloadHalHidlEnvironment : public ::testing::Environment {

   public: