scanning/offload/offload_scan_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 #include "wificond/scanning/offload/offload_scan_utils.h"
  17
  18 #include <android-base/logging.h>
  19
  20 #include "wificond/scanning/scan_result.h"
  21 #include "wificond/scanning/offload/scan_stats.h"
  22
  23 using ::com::android::server::wifi::wificond::NativeScanResult;
  24 using ::com::android::server::wifi::wificond::NativeScanStats;
  25 using android::hardware::wifi::offload::V1_0::ScanResult;
  26 using android::hardware::wifi::offload::V1_0::ScanParam;
  27 using android::hardware::wifi::offload::V1_0::ScanFilter;
  28 using android::hardware::wifi::offload::V1_0::ScanStats;
  29 using android::hardware::wifi::offload::V1_0::NetworkInfo;
  30 using android::hardware::hidl_vec;
  31 using std::vector;
  32
  33 namespace android {
  34 namespace wificond {
  35
  36 vector<NativeScanResult> OffloadScanUtils::convertToNativeScanResults(
  37     const vector<ScanResult>& scan_result) {
  38   vector<NativeScanResult> native_scan_result;
  39   native_scan_result.reserve(scan_result.size());
  40   for (size_t i = 0; i < scan_result.size(); i++) {
  41     NativeScanResult single_scan_result;
  42     single_scan_result.ssid = scan_result[i].networkInfo.ssid;
  43     single_scan_result.bssid.assign(scan_result[i].networkInfo.ssid.begin(),
  44         scan_result[i].networkInfo.ssid.end());
  45     single_scan_result.frequency = scan_result[i].frequency;
  46     single_scan_result.signal_mbm = scan_result[i].rssi;
  47     single_scan_result.tsf = scan_result[i].tsf;
  48     single_scan_result.capability = scan_result[i].capability;
  49     single_scan_result.associated = false;
  50     native_scan_result.emplace_back(single_scan_result);
  51   }
  52   return native_scan_result;
  53 }
  54
  55 ScanParam OffloadScanUtils::createScanParam(
  56     const vector<vector<uint8_t>>& ssid_list,
  57     const vector<uint32_t>& frequency_list, uint32_t scan_interval_ms) {
  58   ScanParam scan_param;
  59   scan_param.disconnectedModeScanIntervalMs = scan_interval_ms;
  60   scan_param.frequencyList = frequency_list;
  61   vector<hidl_vec<uint8_t>> ssid_list_tmp;
  62   for (const auto& ssid : ssid_list) {
  63     ssid_list_tmp.push_back(ssid);
  64   }
  65   scan_param.ssidList = ssid_list_tmp;
  66   return scan_param;
  67 }
  68
  69 ScanFilter OffloadScanUtils::createScanFilter(
  70     const vector<vector<uint8_t>>& ssids,
  71     const vector<uint8_t>& flags, int8_t rssi_threshold) {
  72   ScanFilter scan_filter;
  73   vector<NetworkInfo> nw_info_list;
  74   size_t i = 0;
  75   scan_filter.rssiThreshold = rssi_threshold;
  76   // Note that the number of ssids should match the number of security flags
  77   for (const auto& ssid : ssids) {
  78       NetworkInfo nw_info;
  79       nw_info.ssid = ssid;
  80       if (i < flags.size()) {
  81         nw_info.flags = flags[i++];
  82       } else {
  83         continue;
  84       }
  85       nw_info_list.push_back(nw_info);
  86   }
  87   scan_filter.preferredNetworkInfoList = nw_info_list;
  88   return scan_filter;
  89 }
  90
  91 NativeScanStats OffloadScanUtils::convertToNativeScanStats(
  92     const ScanStats& scanStats) {
  93   uint32_t num_channels_scanned = 0;
  94   uint32_t scan_duration_ms = 0;
  95   vector<uint8_t> histogram_channels;
  96
  97   for (size_t i = 0; i < scanStats.scanRecord.size(); i++) {
  98     scan_duration_ms += scanStats.scanRecord[i].durationMs;
  99     num_channels_scanned +=
 100         scanStats.scanRecord[i].numChannelsScanned;
 101   }
 102   for (size_t i = 0; i < scanStats.histogramChannelsScanned.size(); i++) {
 103     histogram_channels.push_back(
 104       scanStats.histogramChannelsScanned[i]);
 105   }
 106
 107   NativeScanStats native_scan_stats(scanStats.numScansRequestedByWifi,
 108       scanStats.numScansServicedByWifi,
 109       scanStats.subscriptionDurationMs,
 110       scan_duration_ms,
 111       num_channels_scanned,
 112       histogram_channels);
 113   return native_scan_stats;
 114 }
 115
 116 } // namespace wificond
 117 } // namespace android
 118