wifi/1.0/vts/functional/wifi_hidl_test_utils.cpp

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <VtsHalHidlTargetTestBase.h>
  18
  19 #include "wifi_hidl_call_util.h"
  20 #include "wifi_hidl_test_utils.h"
  21
  22 using ::android::hardware::wifi::V1_0::IWifi;
  23 using ::android::hardware::wifi::V1_0::IWifiApIface;
  24 using ::android::hardware::wifi::V1_0::IWifiChip;
  25 using ::android::hardware::wifi::V1_0::IWifiNanIface;
  26 using ::android::hardware::wifi::V1_0::IWifiP2pIface;
  27 using ::android::hardware::wifi::V1_0::IWifiRttController;
  28 using ::android::hardware::wifi::V1_0::IWifiStaIface;
  29 using ::android::hardware::wifi::V1_0::ChipModeId;
  30 using ::android::hardware::wifi::V1_0::ChipId;
  31 using ::android::hardware::wifi::V1_0::IfaceType;
  32 using ::android::hardware::wifi::V1_0::WifiStatus;
  33 using ::android::hardware::wifi::V1_0::WifiStatusCode;
  34 using ::android::sp;
  35 using ::android::hardware::hidl_string;
  36 using ::android::hardware::hidl_vec;
  37
  38 namespace {
  39 bool findAnyModeSupportingIfaceType(
  40     IfaceType desired_type, const std::vector<IWifiChip::ChipMode>& modes,
  41     ChipModeId* mode_id) {
  42     for (const auto& mode : modes) {
  43         for (const auto& combination : mode.availableCombinations) {
  44             for (const auto& iface_limit : combination.limits) {
  45                 const auto& iface_types = iface_limit.types;
  46                 if (std::find(iface_types.begin(), iface_types.end(),
  47                               desired_type) != iface_types.end()) {
  48                     *mode_id = mode.id;
  49                     return true;
  50                 }
  51             }
  52         }
  53     }
  54     return false;
  55 }
  56
  57 bool configureChipToSupportIfaceTypeInternal(const sp<IWifiChip>& wifi_chip,
  58                                              IfaceType type,
  59                                              ChipModeId* configured_mode_id) {
  60     if (!configured_mode_id) {
  61         return false;
  62     }
  63     const auto& status_and_modes = HIDL_INVOKE(wifi_chip, getAvailableModes);
  64     if (status_and_modes.first.code != WifiStatusCode::SUCCESS) {
  65         return false;
  66     }
  67     if (!findAnyModeSupportingIfaceType(type, status_and_modes.second,
  68                                         configured_mode_id)) {
  69         return false;
  70     }
  71     if (HIDL_INVOKE(wifi_chip, configureChip, *configured_mode_id).code !=
  72         WifiStatusCode::SUCCESS) {
  73         return false;
  74     }
  75     return true;
  76 }
  77
  78 bool configureChipToSupportIfaceTypeInternal(const sp<IWifiChip>& wifi_chip,
  79                                              IfaceType type) {
  80     ChipModeId mode_id;
  81     return configureChipToSupportIfaceTypeInternal(wifi_chip, type, &mode_id);
  82 }
  83 }  // namespace
  84
  85 sp<IWifi> getWifi() {
  86     sp<IWifi> wifi = ::testing::VtsHalHidlTargetTestBase::getService<IWifi>();
  87     return wifi;
  88 }
  89
  90 sp<IWifiChip> getWifiChip() {
  91     sp<IWifi> wifi = getWifi();
  92     if (!wifi.get()) {
  93         return nullptr;
  94     }
  95     if (HIDL_INVOKE(wifi, start).code != WifiStatusCode::SUCCESS) {
  96         return nullptr;
  97     }
  98     const auto& status_and_chip_ids = HIDL_INVOKE(wifi, getChipIds);
  99     const auto& chip_ids = status_and_chip_ids.second;
 100     if (status_and_chip_ids.first.code != WifiStatusCode::SUCCESS ||
 101         chip_ids.size() != 1) {
 102         return nullptr;
 103     }
 104     const auto& status_and_chip = HIDL_INVOKE(wifi, getChip, chip_ids[0]);
 105     if (status_and_chip.first.code != WifiStatusCode::SUCCESS) {
 106         return nullptr;
 107     }
 108     return status_and_chip.second;
 109 }
 110
 111 sp<IWifiApIface> getWifiApIface() {
 112     sp<IWifiChip> wifi_chip = getWifiChip();
 113     if (!wifi_chip.get()) {
 114         return nullptr;
 115     }
 116     if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::AP)) {
 117         return nullptr;
 118     }
 119     const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createApIface);
 120     if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {
 121         return nullptr;
 122     }
 123     return status_and_iface.second;
 124 }
 125
 126 sp<IWifiNanIface> getWifiNanIface() {
 127     sp<IWifiChip> wifi_chip = getWifiChip();
 128     if (!wifi_chip.get()) {
 129         return nullptr;
 130     }
 131     if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::NAN)) {
 132         return nullptr;
 133     }
 134     const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createNanIface);
 135     if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {
 136         return nullptr;
 137     }
 138     return status_and_iface.second;
 139 }
 140
 141 sp<IWifiP2pIface> getWifiP2pIface() {
 142     sp<IWifiChip> wifi_chip = getWifiChip();
 143     if (!wifi_chip.get()) {
 144         return nullptr;
 145     }
 146     if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::P2P)) {
 147         return nullptr;
 148     }
 149     const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createP2pIface);
 150     if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {
 151         return nullptr;
 152     }
 153     return status_and_iface.second;
 154 }
 155
 156 sp<IWifiStaIface> getWifiStaIface() {
 157     sp<IWifiChip> wifi_chip = getWifiChip();
 158     if (!wifi_chip.get()) {
 159         return nullptr;
 160     }
 161     if (!configureChipToSupportIfaceTypeInternal(wifi_chip, IfaceType::STA)) {
 162         return nullptr;
 163     }
 164     const auto& status_and_iface = HIDL_INVOKE(wifi_chip, createStaIface);
 165     if (status_and_iface.first.code != WifiStatusCode::SUCCESS) {
 166         return nullptr;
 167     }
 168     return status_and_iface.second;
 169 }
 170
 171 sp<IWifiRttController> getWifiRttController() {
 172     sp<IWifiChip> wifi_chip = getWifiChip();
 173     if (!wifi_chip.get()) {
 174         return nullptr;
 175     }
 176     sp<IWifiStaIface> wifi_sta_iface = getWifiStaIface();
 177     if (!wifi_sta_iface.get()) {
 178         return nullptr;
 179     }
 180     const auto& status_and_controller =
 181         HIDL_INVOKE(wifi_chip, createRttController, wifi_sta_iface);
 182     if (status_and_controller.first.code != WifiStatusCode::SUCCESS) {
 183         return nullptr;
 184     }
 185     return status_and_controller.second;
 186 }
 187
 188 bool configureChipToSupportIfaceType(const sp<IWifiChip>& wifi_chip,
 189                                      IfaceType type,
 190                                      ChipModeId* configured_mode_id) {
 191     return configureChipToSupportIfaceTypeInternal(wifi_chip, type,
 192                                                    configured_mode_id);
 193 }
 194
 195 void stopWifi() {
 196     sp<IWifi> wifi = getWifi();
 197     ASSERT_NE(wifi, nullptr);
 198     ASSERT_EQ(HIDL_INVOKE(wifi, stop).code, WifiStatusCode::SUCCESS);
 199 }