Wificond: Introduce new APIS to OffloadScanManager

The following APIs are now supported
- startScan() and stopScan()

Including unit tests to verify behavior of these APIs

Test: Unit tests
Bug: 32842314
Change-Id: I23ddd436139976b0aefcbd05b486c934b748e3c4

4 files changed, 294 insertions, 34 deletions

diff --git a/tests/offload_scan_manager_test.cpp b/tests/offload_scan_manager_test.cpp
index cfccbc4..99e6aef 100644
--- a/tests/offload_scan_manager_test.cpp
+++ b/tests/offload_scan_manager_test.cpp
@@ -33,6 +33,8 @@
 
 using android::hardware::wifi::offload::V1_0::ScanResult;
 using android::hardware::wifi::offload::V1_0::OffloadStatus;
+using android::hardware::wifi::offload::V1_0::ScanParam;
+using android::hardware::wifi::offload::V1_0::ScanFilter;
 using com::android::server::wifi::wificond::NativeScanResult;
 using testing::NiceMock;
 using testing::_;
@@ -79,7 +81,8 @@ class OffloadScanManagerTest: public ::testing::Test {
  */
 TEST_F(OffloadScanManagerTest, ServiceUtilsNotAvailableTest) {
   offload_scan_manager_.reset(new OffloadScanManager(nullptr, nullptr));
-  EXPECT_EQ(OffloadScanManager::kError, offload_scan_manager_->getOffloadStatus());
+  EXPECT_EQ(OffloadScanManager::kError,
+      offload_scan_manager_->getOffloadStatus());
 }
 
 /**
@@ -89,9 +92,11 @@ TEST_F(OffloadScanManagerTest, ServiceUtilsNotAvailableTest) {
 TEST_F(OffloadScanManagerTest, ServiceNotAvailableTest) {
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(nullptr));
-  offload_scan_manager_.reset(new OffloadScanManager(mock_offload_service_utils_.get(),
-      [] (std::vector<NativeScanResult> scanResult) -> void {}));
-  EXPECT_EQ(OffloadScanManager::kNoService, offload_scan_manager_->getOffloadStatus());
+  offload_scan_manager_.reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [] (vector<NativeScanResult> scanResult) -> void {}));
+  EXPECT_EQ(OffloadScanManager::kNoService,
+      offload_scan_manager_->getOffloadStatus());
 }
 
 /**
@@ -102,9 +107,11 @@ TEST_F(OffloadScanManagerTest, ServiceAvailableTest) {
   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
-  offload_scan_manager_ .reset(new OffloadScanManager(mock_offload_service_utils_.get(),
-    [] (vector<NativeScanResult> scanResult) -> void {}));
-  EXPECT_EQ(OffloadScanManager::kNoError, offload_scan_manager_->getOffloadStatus());
+  offload_scan_manager_ .reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [] (vector<NativeScanResult> scanResult) -> void {}));
+  EXPECT_EQ(OffloadScanManager::kNoError,
+      offload_scan_manager_->getOffloadStatus());
 }
 
 /**
@@ -117,11 +124,13 @@ TEST_F(OffloadScanManagerTest, CallbackInvokedTest) {
   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
-  offload_scan_manager_.reset(new OffloadScanManager(mock_offload_service_utils_.get(),
-    [&callback_invoked] (vector<NativeScanResult> scanResult) -> void {
+  offload_scan_manager_.reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [&callback_invoked] (vector<NativeScanResult> scanResult) -> void {
         callback_invoked = true;
-    }));
-  vector<ScanResult> dummy_scan_results_ = OffloadTestUtils::createOffloadScanResults();
+      }));
+  vector<ScanResult> dummy_scan_results_ =
+      OffloadTestUtils::createOffloadScanResults();
   offload_callback_->onScanResult(dummy_scan_results_);
   EXPECT_EQ(true, callback_invoked);
 }
@@ -134,11 +143,213 @@ TEST_F(OffloadScanManagerTest, ErrorCallbackInvokedTest) {
   EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
   ON_CALL(*mock_offload_service_utils_, GetOffloadService())
       .WillByDefault(testing::Return(mock_offload_));
-  offload_scan_manager_.reset(new OffloadScanManager(mock_offload_service_utils_.get(),
-    [this] (std::vector<NativeScanResult> scanResult) -> void {}));
+  offload_scan_manager_.reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [this] (vector<NativeScanResult> scanResult) -> void {}));
   offload_callback_->onError(OffloadStatus::OFFLOAD_STATUS_ERROR);
-  EXPECT_EQ(offload_scan_manager_->getOffloadStatus(), OffloadScanManager::kError);
+  EXPECT_EQ(offload_scan_manager_->getOffloadStatus(),
+      OffloadScanManager::kError);
+}
+
+/**
+ * Testing OffloadScanManager for subscribing to the scan results from
+ * Offload HAL when service is running without errors
+ */
+TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsOk) {
+  EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
+  ON_CALL(*mock_offload_service_utils_, GetOffloadService())
+      .WillByDefault(testing::Return(mock_offload_));
+  offload_scan_manager_ .reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [] (vector<NativeScanResult> scanResult) -> void {}));
+  EXPECT_CALL(*mock_offload_, subscribeScanResults(_));
+  EXPECT_CALL(*mock_offload_, configureScans(_, _));
+  vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
+  vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
+  vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
+  vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
+  OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
+  bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
+      kRssiThreshold,
+      scan_ssids,
+      match_ssids,
+      security_flags,
+      frequencies,
+      &reason_code);
+  EXPECT_EQ(result, true);
+}
+
+/**
+ * Testing OffloadScanManager for subscribing to the scan results from
+ * Offload HAL when service is not available
+ */
+TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotAvailable) {
+  EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
+  ON_CALL(*mock_offload_service_utils_, GetOffloadService())
+      .WillByDefault(testing::Return(nullptr));
+  offload_scan_manager_ .reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [] (vector<NativeScanResult> scanResult) -> void {}));
+  vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
+  vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
+  vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
+  vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
+  OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
+  bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
+      kRssiThreshold,
+      scan_ssids,
+      match_ssids,
+      security_flags,
+      frequencies,
+      &reason_code);
+  EXPECT_EQ(result, false);
+  EXPECT_EQ(reason_code, OffloadScanManager::kNotSupported);
+}
+
+/**
+ * Testing OffloadScanManager for subscribing to the scan results from
+ * Offload HAL when service is not working correctly
+ */
+TEST_F(OffloadScanManagerTest, StartScanTestWhenServiceIsNotConnected) {
+  EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
+  ON_CALL(*mock_offload_service_utils_, GetOffloadService())
+      .WillByDefault(testing::Return(mock_offload_));
+  offload_scan_manager_ .reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [] (vector<NativeScanResult> scanResult) -> void {}));
+  vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
+  vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
+  vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
+  vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
+  offload_callback_->onError(OffloadStatus::OFFLOAD_STATUS_NO_CONNECTION);
+  OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
+  bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
+      kRssiThreshold,
+      scan_ssids,
+      match_ssids,
+      security_flags,
+      frequencies,
+      &reason_code);
+  EXPECT_EQ(result, false);
+  EXPECT_EQ(reason_code, OffloadScanManager::kNotAvailable);
+}
+
+/**
+ * Testing OffloadScanManager for subscribing to the scan results from
+ * Offload HAL twice when service is okay
+ */
+TEST_F(OffloadScanManagerTest, StartScanTwiceTestWhenServiceIsOk) {
+  EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
+  ON_CALL(*mock_offload_service_utils_, GetOffloadService())
+      .WillByDefault(testing::Return(mock_offload_));
+  offload_scan_manager_ .reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [] (vector<NativeScanResult> scanResult) -> void {}));
+  EXPECT_CALL(*mock_offload_, subscribeScanResults(_)).Times(1);
+  EXPECT_CALL(*mock_offload_, configureScans(_, _)).Times(2);
+  vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
+  vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
+  vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
+  vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
+  OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
+  bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
+      kRssiThreshold,
+      scan_ssids,
+      match_ssids,
+      security_flags,
+      frequencies,
+      &reason_code);
+  EXPECT_EQ(result, true);
+  result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
+      kRssiThreshold,
+      scan_ssids,
+      match_ssids,
+      security_flags,
+      frequencies,
+      &reason_code);
+  EXPECT_EQ(result, true);
+}
+
+/**
+ * Testing OffloadScanManager for unsubscribing to the scan results from
+ * Offload HAL when service is ok
+ */
+TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsOk) {
+  EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
+  ON_CALL(*mock_offload_service_utils_, GetOffloadService())
+      .WillByDefault(testing::Return(mock_offload_));
+  offload_scan_manager_ .reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [] (vector<NativeScanResult> scanResult) -> void {}));
+  EXPECT_CALL(*mock_offload_, subscribeScanResults(_));
+  EXPECT_CALL(*mock_offload_, configureScans(_, _));
+  EXPECT_CALL(*mock_offload_, unsubscribeScanResults());
+  vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
+  vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
+  vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
+  vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
+  OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
+  bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
+      kRssiThreshold,
+      scan_ssids,
+      match_ssids,
+      security_flags,
+      frequencies,
+      &reason_code);
+  EXPECT_EQ(result, true);
+  result = offload_scan_manager_->stopScan(&reason_code);
+  EXPECT_EQ(result, true);
+}
+
+/**
+ * Testing OffloadScanManager for unsubscribing to the scan results from
+ * Offload HAL without first subscribing
+ */
+TEST_F(OffloadScanManagerTest, StopScanTestWithoutStartWhenServiceIsOk) {
+  EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
+  ON_CALL(*mock_offload_service_utils_, GetOffloadService())
+      .WillByDefault(testing::Return(mock_offload_));
+  offload_scan_manager_ .reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [] (vector<NativeScanResult> scanResult) -> void {}));
+  OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
+  bool result = offload_scan_manager_->stopScan(&reason_code);
+  EXPECT_EQ(result, false);
+  EXPECT_EQ(reason_code, OffloadScanManager::kNotSubscribed);
+}
+
+/**
+ * Testing OffloadScanManager for unsubscribing to the scan results from
+ * Offload HAL without first subscribing when service is not working correctly
+ */
+TEST_F(OffloadScanManagerTest, StopScanTestWhenServiceIsNotConnectedAnymore) {
+  EXPECT_CALL(*mock_offload_service_utils_, GetOffloadService());
+  ON_CALL(*mock_offload_service_utils_, GetOffloadService())
+      .WillByDefault(testing::Return(mock_offload_));
+  offload_scan_manager_ .reset(new OffloadScanManager(
+      mock_offload_service_utils_.get(),
+      [] (vector<NativeScanResult> scanResult) -> void {}));
+  EXPECT_CALL(*mock_offload_, subscribeScanResults(_));
+  EXPECT_CALL(*mock_offload_, configureScans(_, _));
+  EXPECT_CALL(*mock_offload_, unsubscribeScanResults());
+  vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
+  vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
+  vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
+  vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
+  OffloadScanManager::ReasonCode reason_code = OffloadScanManager::kNone;
+  bool result = offload_scan_manager_->startScan(kDisconnectedModeScanIntervalMs,
+      kRssiThreshold,
+      scan_ssids,
+      match_ssids,
+      security_flags,
+      frequencies,
+      &reason_code);
+  EXPECT_EQ(result, true);
+  offload_callback_->onError(OffloadStatus::OFFLOAD_STATUS_NO_CONNECTION);
+  result = offload_scan_manager_->stopScan(&reason_code);
+  EXPECT_EQ(result, true);
+}
+
+}
 }
 
-} // namespace wificond
-} // namespace android
diff --git a/tests/offload_scan_utils_test.cpp b/tests/offload_scan_utils_test.cpp
index d7463ce..59a4b45 100644
--- a/tests/offload_scan_utils_test.cpp
+++ b/tests/offload_scan_utils_test.cpp
@@ -18,12 +18,16 @@
 
 #include <gtest/gtest.h>
 #include "wificond/tests/offload_test_utils.h"
-
+#include <android-base/logging.h>
 #include "wificond/scanning/scan_result.h"
 #include "wificond/scanning/offload/offload_scan_utils.h"
 
 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::NetworkInfo;
 using ::com::android::server::wifi::wificond::NativeScanResult;
+using std::vector;
 
 namespace android {
 namespace wificond {
@@ -38,22 +42,61 @@ class OffloadScanUtilsTest : public ::testing::Test {
     dummy_scan_results_.clear();
   }
 
-  std::vector<ScanResult> dummy_scan_results_;
+  vector<ScanResult> dummy_scan_results_;
 };
 
 TEST_F(OffloadScanUtilsTest, verifyConversion) {
-  std::vector<NativeScanResult> native_scan_results =
+  vector<NativeScanResult> native_scan_results =
       OffloadScanUtils::convertToNativeScanResults(dummy_scan_results_);
   EXPECT_EQ(native_scan_results.size(), dummy_scan_results_.size());
   for (size_t i = 0; i < native_scan_results.size(); i++) {
     EXPECT_EQ(native_scan_results[i].frequency, dummy_scan_results_[i].frequency);
     EXPECT_EQ(native_scan_results[i].tsf, dummy_scan_results_[i].tsf);
     EXPECT_EQ(native_scan_results[i].signal_mbm, dummy_scan_results_[i].rssi);
-    EXPECT_EQ(native_scan_results[i].ssid.size(), dummy_scan_results_[i].networkInfo.ssid.size());
-    EXPECT_EQ(native_scan_results[i].bssid.size(), dummy_scan_results_[i].bssid.elementCount());
+    EXPECT_EQ(native_scan_results[i].ssid.size(),
+        dummy_scan_results_[i].networkInfo.ssid.size());
+    EXPECT_EQ(native_scan_results[i].bssid.size(),
+        dummy_scan_results_[i].bssid.elementCount());
     EXPECT_EQ(native_scan_results[i].capability, dummy_scan_results_[i].capability);
   }
 }
 
+TEST_F(OffloadScanUtilsTest, verifyScanParam) {
+  vector<vector<uint8_t>> scan_ssids { kSsid1, kSsid2};
+  vector<uint32_t> frequencies { kFrequency1, kFrequency2 };
+  ScanParam scanParam = OffloadScanUtils::createScanParam(scan_ssids, frequencies,
+      kDisconnectedModeScanIntervalMs);
+  EXPECT_EQ(scanParam.disconnectedModeScanIntervalMs,
+          kDisconnectedModeScanIntervalMs);
+  for (size_t i = 0; i < frequencies.size(); i++) {
+    EXPECT_EQ(scanParam.frequencyList[i], frequencies[i]);
+  }
+  for (size_t j = 0; j < scan_ssids.size(); j++) {
+    vector<uint8_t> ssid_result = scanParam.ssidList[j];
+    vector<uint8_t> ssid_input = scan_ssids[j];
+    for (size_t k = 0; k < ssid_result.size(); k++) {
+      EXPECT_EQ(ssid_result[k], ssid_input[k]);
+    }
+  }
+}
+
+TEST_F(OffloadScanUtilsTest, verifyScanFilter) {
+  vector<vector<uint8_t>> match_ssids { kSsid1, kSsid2 };
+  vector<uint8_t> security_flags { kNetworkFlags, kNetworkFlags };
+  ScanFilter scanFilter = OffloadScanUtils::createScanFilter(match_ssids,
+      security_flags, kRssiThreshold);
+  EXPECT_EQ(kRssiThreshold, scanFilter.rssiThreshold);
+  EXPECT_FALSE(scanFilter.preferredNetworkInfoList.size() == 0);
+  for (size_t i = 0; i < security_flags.size(); ++i) {
+    NetworkInfo nwInfo = scanFilter.preferredNetworkInfoList[i];
+    vector<uint8_t> ssid = nwInfo.ssid;
+    vector<uint8_t> match_ssid = match_ssids[i];
+    EXPECT_EQ(nwInfo.flags, security_flags[i]);
+    for (size_t j = 0; j < ssid.size(); j++) {
+      EXPECT_EQ(ssid[j], match_ssid[j]);
+    }
+  }
+}
+
 } // namespace wificond
 } // namespace android
diff --git a/tests/offload_test_utils.cpp b/tests/offload_test_utils.cpp
index 4309006..c0c3e15 100644
--- a/tests/offload_test_utils.cpp
+++ b/tests/offload_test_utils.cpp
@@ -23,24 +23,13 @@ using android::hardware::wifi::offload::V1_0::ScanResult;
 namespace android {
 namespace wificond {
 
-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;
-} // namespace
-
 std::vector<ScanResult> OffloadTestUtils::createOffloadScanResults() {
   std::vector<ScanResult> scanResults;
   ScanResult scanResult;
-  std::vector<uint8_t> ssid(kSsid, kSsid + sizeof(kSsid));
+  std::vector<uint8_t> ssid(kSsid1, kSsid1 + sizeof(kSsid1));
   scanResult.tsf = kTsf;
   scanResult.rssi = kRssi;
-  scanResult.frequency = kFrequency;
+  scanResult.frequency = kFrequency1;
   scanResult.capability = kCapability;
   memcpy(&scanResult.bssid[0], &kBssid[0], kBssidSize);
   scanResult.networkInfo.ssid = ssid;
diff --git a/tests/offload_test_utils.h b/tests/offload_test_utils.h
index 621f297..499d620 100644
--- a/tests/offload_test_utils.h
+++ b/tests/offload_test_utils.h
@@ -19,10 +19,27 @@
 
 #include <android/hardware/wifi/offload/1.0/IOffload.h>
 #include <vector>
+
 using android::hardware::wifi::offload::V1_0::ScanResult;
+
 namespace android {
 namespace wificond {
 
+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 int16_t kRssiThreshold = -76;
+  const uint32_t kFrequency1 = 2412;
+  const uint32_t kFrequency2 = 2437;
+  const uint8_t kBssidSize = 6;
+  const uint64_t kTsf = 0;
+  const uint16_t kCapability = 0;
+  const uint8_t kNetworkFlags = 0;
+  const uint32_t kDisconnectedModeScanIntervalMs = 5000;
+} // namespace
+
 class OffloadTestUtils {
  public:
   static std::vector<ScanResult> createOffloadScanResults();