mirror of
https://github.com/Evolution-X-Devices/device_google_wahoo
synced 2026-02-01 07:50:47 +00:00
286 lines
12 KiB
C++
286 lines
12 KiB
C++
|
/*
|
||
|
|
* 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 "offload_utils.h"
|
||
|
|
|
||
|
|
#include <android-base/logging.h>
|
||
|
|
#include <chre/apps/wifi_offload/error_codes.h>
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
|
||
|
|
bool ToHidlRecordName(const wifi_offload::RpcLogRecord::RpcLogRecordType& chreRecordType,
|
||
|
|
android::hardware::wifi::offload::V1_0::RecordName* hidlRecordName) {
|
||
|
|
bool result = true;
|
||
|
|
switch (chreRecordType) {
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_INIT:
|
||
|
|
*hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::CMD_INT;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_CONFIG_SCANS:
|
||
|
|
*hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::CMD_CONFIG_SCANS;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_SUBSCRIBE_SCAN_RESULTS:
|
||
|
|
*hidlRecordName =
|
||
|
|
android::hardware::wifi::offload::V1_0::RecordName::CMD_SUBSCRIBE_SCAN_RESULTS;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_UNSUBSCRIBE_SCAN_RESULTS:
|
||
|
|
*hidlRecordName =
|
||
|
|
android::hardware::wifi::offload::V1_0::RecordName::CMD_UNSUBSCRIBE_SCAN_RESULTS;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_GET_SCAN_STATS:
|
||
|
|
*hidlRecordName =
|
||
|
|
android::hardware::wifi::offload::V1_0::RecordName::CMD_GET_SCAN_STATS;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::CMD_RESET:
|
||
|
|
*hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::CMD_RESET;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::EVENT_RECVD_SCAN_RESULT_ASYNC:
|
||
|
|
*hidlRecordName =
|
||
|
|
android::hardware::wifi::offload::V1_0::RecordName::EVENT_RECVD_SCAN_RESULT_ASYNC;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::EVENT_RECVD_SCAN_RESULT:
|
||
|
|
*hidlRecordName =
|
||
|
|
android::hardware::wifi::offload::V1_0::RecordName::EVENT_RECVD_SCAN_RESULT;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::EVENT_SENT_SCAN_RESULT:
|
||
|
|
*hidlRecordName =
|
||
|
|
android::hardware::wifi::offload::V1_0::RecordName::EVENT_SENT_SCAN_RESULT;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::EVENT_SENT_ABORT:
|
||
|
|
*hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::EVENT_SENT_ABORT;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::EVENT_SENT_ERROR:
|
||
|
|
*hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::EVENT_SENT_ERROR;
|
||
|
|
break;
|
||
|
|
case wifi_offload::RpcLogRecord::RpcLogRecordType::REQ_SCAN:
|
||
|
|
*hidlRecordName = android::hardware::wifi::offload::V1_0::RecordName::REQ_SCAN;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
result = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8_t ToChreSecurityMode(uint8_t hidlSecurityMode) {
|
||
|
|
uint8_t chreSecurityMode = 0;
|
||
|
|
if (hidlSecurityMode & android::hardware::wifi::offload::V1_0::SecurityMode::OPEN) {
|
||
|
|
chreSecurityMode |= wifi_offload::SecurityMode::OPEN;
|
||
|
|
}
|
||
|
|
if (hidlSecurityMode & android::hardware::wifi::offload::V1_0::SecurityMode::WEP) {
|
||
|
|
chreSecurityMode |= wifi_offload::SecurityMode::WEP;
|
||
|
|
}
|
||
|
|
if (hidlSecurityMode & android::hardware::wifi::offload::V1_0::SecurityMode::PSK) {
|
||
|
|
chreSecurityMode |= wifi_offload::SecurityMode::PSK;
|
||
|
|
}
|
||
|
|
if (hidlSecurityMode & android::hardware::wifi::offload::V1_0::SecurityMode::EAP) {
|
||
|
|
chreSecurityMode |= wifi_offload::SecurityMode::EAP;
|
||
|
|
}
|
||
|
|
return chreSecurityMode;
|
||
|
|
}
|
||
|
|
|
||
|
|
uint8_t ToHidlSecurityMode(uint8_t chreSecurityMode) {
|
||
|
|
uint8_t hidlSecurityMode = 0;
|
||
|
|
if (chreSecurityMode & wifi_offload::SecurityMode::OPEN) {
|
||
|
|
hidlSecurityMode |= android::hardware::wifi::offload::V1_0::SecurityMode::OPEN;
|
||
|
|
}
|
||
|
|
if (chreSecurityMode & wifi_offload::SecurityMode::WEP) {
|
||
|
|
hidlSecurityMode |= android::hardware::wifi::offload::V1_0::SecurityMode::WEP;
|
||
|
|
}
|
||
|
|
if (chreSecurityMode & wifi_offload::SecurityMode::PSK) {
|
||
|
|
hidlSecurityMode |= android::hardware::wifi::offload::V1_0::SecurityMode::PSK;
|
||
|
|
}
|
||
|
|
if (chreSecurityMode & wifi_offload::SecurityMode::EAP) {
|
||
|
|
hidlSecurityMode |= android::hardware::wifi::offload::V1_0::SecurityMode::EAP;
|
||
|
|
}
|
||
|
|
return hidlSecurityMode;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace
|
||
|
|
|
||
|
|
namespace android {
|
||
|
|
namespace hardware {
|
||
|
|
namespace wifi {
|
||
|
|
namespace offload {
|
||
|
|
namespace V1_0 {
|
||
|
|
namespace implementation {
|
||
|
|
namespace offload_utils {
|
||
|
|
|
||
|
|
bool ToHidlScanResult(const wifi_offload::ScanResult& chreScanResult, ScanResult* hidlScanResult) {
|
||
|
|
if (hidlScanResult == nullptr) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
hidlScanResult->tsf = chreScanResult.tsf_;
|
||
|
|
hidlScanResult->capability = chreScanResult.capability_;
|
||
|
|
hidlScanResult->rssi = chreScanResult.rssi_dbm_;
|
||
|
|
hidlScanResult->frequency = chreScanResult.frequency_scanned_mhz_;
|
||
|
|
memcpy(&hidlScanResult->bssid[0], &chreScanResult.bssid_[0],
|
||
|
|
wifi_offload::ScanResult::kBssidSize);
|
||
|
|
chreWifiSsidListItem chreWifiSsid;
|
||
|
|
chreScanResult.ssid_.ToChreWifiSsidListItem(&chreWifiSsid);
|
||
|
|
std::vector<uint8_t> ssid;
|
||
|
|
for (size_t i = 0; i < chreWifiSsid.ssidLen; i++) {
|
||
|
|
ssid.push_back(chreWifiSsid.ssid[i]);
|
||
|
|
}
|
||
|
|
hidlScanResult->networkInfo.ssid = ssid;
|
||
|
|
hidlScanResult->networkInfo.flags = ToHidlSecurityMode(chreScanResult.security_modes_);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ToHidlScanResults(const std::vector<wifi_offload::ScanResult>& chreScanResults,
|
||
|
|
std::vector<ScanResult>* hidlScanResults) {
|
||
|
|
LOG(VERBOSE) << "ScanResults from CHRE, size=" << chreScanResults.size();
|
||
|
|
for (const auto& scan_result_from_nano_app : chreScanResults) {
|
||
|
|
ScanResult hidl_scan_result;
|
||
|
|
if (!ToHidlScanResult(scan_result_from_nano_app, &hidl_scan_result)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
hidlScanResults->push_back(hidl_scan_result);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ToHidlScanStats(const wifi_offload::ScanStats& chreScanStats, ScanStats* hidlScanStats) {
|
||
|
|
hidlScanStats->subscriptionDurationMs = chreScanStats.last_subscription_duration_ms_;
|
||
|
|
hidlScanStats->numScansRequestedByWifi = chreScanStats.num_scans_requested_by_nanoapp_;
|
||
|
|
hidlScanStats->numScansServicedByWifi = chreScanStats.num_scans_serviced_by_hardware_;
|
||
|
|
hidlScanStats->numScansServicedbyCache = chreScanStats.num_scans_serviced_by_cache_;
|
||
|
|
std::vector<ScanRecord> hidlScanRecords;
|
||
|
|
for (const auto& chreScanRecord : chreScanStats.scan_records_) {
|
||
|
|
ScanRecord hidlScanRecord;
|
||
|
|
hidlScanRecord.durationMs = chreScanRecord.time_spent_scanning_ms_;
|
||
|
|
hidlScanRecord.numChannelsScanned = chreScanRecord.num_channels_scanned_;
|
||
|
|
hidlScanRecord.numEntriesAggregated = chreScanRecord.num_entries_aggregated_;
|
||
|
|
hidlScanRecords.push_back(hidlScanRecord);
|
||
|
|
}
|
||
|
|
hidlScanStats->scanRecord = hidlScanRecords;
|
||
|
|
std::vector<LogRecord> logRecords;
|
||
|
|
for (const auto& chreLogRecord : chreScanStats.rpc_log_records_) {
|
||
|
|
LogRecord logRecord;
|
||
|
|
if (!ToHidlRecordName(chreLogRecord.record_type_, &logRecord.recordName)) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
logRecord.logTimeMs = chreLogRecord.timestamp_chre_ms_;
|
||
|
|
logRecords.push_back(logRecord);
|
||
|
|
}
|
||
|
|
hidlScanStats->logRecord = logRecords;
|
||
|
|
for (size_t i = 0; i < hidlScanStats->histogramChannelsScanned.elementCount(); i++) {
|
||
|
|
hidlScanStats->histogramChannelsScanned[i] =
|
||
|
|
chreScanStats.channel_histogram_.GetChannelScanCount(i);
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ToChreScanConfig(const ScanParam& param, const ScanFilter& filter,
|
||
|
|
wifi_offload::ScanConfig* scanConfig) {
|
||
|
|
scanConfig->scan_params_.disconnected_mode_scan_interval_ms_ =
|
||
|
|
param.disconnectedModeScanIntervalMs;
|
||
|
|
for (const auto& ssid : param.ssidList) {
|
||
|
|
wifi_offload::Ssid chreSsid;
|
||
|
|
chreSsid.SetData(ssid.data(), ssid.size());
|
||
|
|
scanConfig->scan_params_.ssids_to_scan_.push_back(chreSsid);
|
||
|
|
}
|
||
|
|
for (const auto& freq : param.frequencyList) {
|
||
|
|
scanConfig->scan_params_.frequencies_to_scan_mhz_.push_back(freq);
|
||
|
|
}
|
||
|
|
scanConfig->scan_filter_.min_rssi_threshold_dbm_ = filter.rssiThreshold;
|
||
|
|
for (const auto& nwInfo : filter.preferredNetworkInfoList) {
|
||
|
|
wifi_offload::PreferredNetwork chreNwInfo;
|
||
|
|
chreNwInfo.security_modes_ = ToChreSecurityMode(nwInfo.flags);
|
||
|
|
chreNwInfo.ssid_.SetData(nwInfo.ssid.data(), nwInfo.ssid.size());
|
||
|
|
scanConfig->scan_filter_.networks_to_match_.push_back(std::move(chreNwInfo));
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ToHidlErrorMessage(uint32_t errorCode, std::string* errorMessage) {
|
||
|
|
bool reportError = true;
|
||
|
|
switch (errorCode) {
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_ALLOCATE_MESSAGE_BUFFER:
|
||
|
|
*errorMessage = "Failed to allocate message buffer";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_SERIALIZE_MESSAGE:
|
||
|
|
*errorMessage = "Failed to serialize message";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_SEND_MESSAGE:
|
||
|
|
*errorMessage = "Failed to send message";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_DESERIALIZE_SCAN_CONFIG:
|
||
|
|
*errorMessage = "Failed to deserialize scan config";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::INVALID_SUBSCRIBE_MESSAGE_SIZE:
|
||
|
|
*errorMessage = "Invalid subscribe message size";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::SCAN_CONFIG_NOT_INITIALIZED:
|
||
|
|
*errorMessage = "Scan config not initialized";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::UNSPECIFIED_HOST_ENDPOINT:
|
||
|
|
*errorMessage = "Unspecified host end point";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_SEND_SCAN_RESULTS:
|
||
|
|
*errorMessage = "Failed to send scan results";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_SEND_SCAN_STATS:
|
||
|
|
*errorMessage = "Failed to send scan stats";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::ONDEMAND_SCAN_NOT_SUPPORTED:
|
||
|
|
*errorMessage = "On demand scans not supported";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_SEND_ONDEMAND_SCAN_REQUEST:
|
||
|
|
*errorMessage = "Failed to send on demand scan request";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_SEND_ONDEMAND_SCAN_REQUEST_ASYNC:
|
||
|
|
*errorMessage = "Failed to send on demand scan request async";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::OUT_OF_ORDER_SCAN_RESULTS:
|
||
|
|
*errorMessage = "Out of order scan results";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::INCOMPLETE_SCAN_RESULTS_BEFORE_SCAN_REQUEST:
|
||
|
|
*errorMessage = "Incomplete scan results before scan request";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_SET_SCAN_TIMER:
|
||
|
|
*errorMessage = "Failed to set scan timer";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::SCAN_MONITORING_NOT_SUPPORTED:
|
||
|
|
*errorMessage = "Scan Monitoring not supported";
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_START_SCAN_MONITORING:
|
||
|
|
*errorMessage = "Failed to start scan monitoring";
|
||
|
|
reportError = false;
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_STOP_SCAN_MONITORING:
|
||
|
|
*errorMessage = "Failed to stop scan monitoring";
|
||
|
|
reportError = false;
|
||
|
|
break;
|
||
|
|
case wifi_offload::ErrorCode::FAILED_TO_CONFIGURE_SCAN_MONITORING_ASYNC:
|
||
|
|
*errorMessage = "Failed to configure scan monitoring async";
|
||
|
|
reportError = false;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
*errorMessage = "Invalid error code";
|
||
|
|
reportError = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
return reportError;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace offload_utils
|
||
|
|
} // namespace implementation
|
||
|
|
} // namespace V1_0
|
||
|
|
} // namespace offload
|
||
|
|
} // namespace wifi
|
||
|
|
} // namespace hardware
|
||
|
|
} // namespace android
|