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