Merge "wifi: Add utility for struct conversions"

wifi/1.0/default/Android.mk

@@ -18,6 +18,7 @@ LOCAL_MODULE := android.hardware.wifi@1.0-service
 LOCAL_MODULE_RELATIVE_PATH := hw
 LOCAL_CPPFLAGS := -Wall -Wno-unused-parameter -Werror -Wextra
 LOCAL_SRC_FILES := \
+    hidl_struct_util.cpp \
     service.cpp \
     wifi.cpp \
     wifi_ap_iface.cpp \

wifi/1.0/default/hidl_struct_util.cpp

@@ -0,0 +1,259 @@
+/*
+ * 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 <android-base/logging.h>
+#include <utils/SystemClock.h>
+
+#include "hidl_struct_util.h"
+
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_0 {
+namespace implementation {
+namespace hidl_struct_util {
+
+uint8_t ConvertHidlReportEventFlagToLegacy(
+    StaBackgroundScanBucketEventReportSchemeMask hidl_flag) {
+  using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
+  switch (hidl_flag) {
+    case HidlFlag::EACH_SCAN:
+      return REPORT_EVENTS_EACH_SCAN;
+    case HidlFlag::FULL_RESULTS:
+      return REPORT_EVENTS_FULL_RESULTS;
+    case HidlFlag::NO_BATCH:
+      return REPORT_EVENTS_NO_BATCH;
+  };
+}
+
+bool convertHidlScanParamsToLegacy(
+    const StaBackgroundScanParameters& hidl_scan_params,
+    legacy_hal::wifi_scan_cmd_params* legacy_scan_params) {
+  if (!legacy_scan_params) {
+    return false;
+  }
+  legacy_scan_params->base_period = hidl_scan_params.basePeriodInMs;
+  legacy_scan_params->max_ap_per_scan = hidl_scan_params.maxApPerScan;
+  legacy_scan_params->report_threshold_percent =
+      hidl_scan_params.reportThresholdPercent;
+  legacy_scan_params->report_threshold_num_scans =
+      hidl_scan_params.reportThresholdNumScans;
+  // TODO(b/33194311): Expose these max limits in the HIDL interface.
+  if (hidl_scan_params.buckets.size() > MAX_BUCKETS) {
+    return false;
+  }
+  legacy_scan_params->num_buckets = hidl_scan_params.buckets.size();
+  for (uint32_t bucket_idx = 0; bucket_idx < hidl_scan_params.buckets.size();
+       bucket_idx++) {
+    const StaBackgroundScanBucketParameters& hidl_bucket_spec =
+        hidl_scan_params.buckets[bucket_idx];
+    legacy_hal::wifi_scan_bucket_spec& legacy_bucket_spec =
+        legacy_scan_params->buckets[bucket_idx];
+    legacy_bucket_spec.bucket = bucket_idx;
+    legacy_bucket_spec.band =
+        static_cast<legacy_hal::wifi_band>(hidl_bucket_spec.band);
+    legacy_bucket_spec.period = hidl_bucket_spec.periodInMs;
+    legacy_bucket_spec.max_period = hidl_bucket_spec.exponentialMaxPeriodInMs;
+    legacy_bucket_spec.base = hidl_bucket_spec.exponentialBase;
+    legacy_bucket_spec.step_count = hidl_bucket_spec.exponentialStepCount;
+    legacy_bucket_spec.report_events = 0;
+    using HidlFlag = StaBackgroundScanBucketEventReportSchemeMask;
+    for (const auto flag :
+         {HidlFlag::EACH_SCAN, HidlFlag::FULL_RESULTS, HidlFlag::NO_BATCH}) {
+      if (hidl_bucket_spec.eventReportScheme &
+          static_cast<std::underlying_type<HidlFlag>::type>(flag)) {
+        legacy_bucket_spec.report_events |=
+            ConvertHidlReportEventFlagToLegacy(flag);
+      }
+    }
+    // TODO(b/33194311): Expose these max limits in the HIDL interface.
+    if (hidl_bucket_spec.frequencies.size() > MAX_CHANNELS) {
+      return false;
+    }
+    legacy_bucket_spec.num_channels = hidl_bucket_spec.frequencies.size();
+    for (uint32_t freq_idx = 0; freq_idx < hidl_bucket_spec.frequencies.size();
+         freq_idx++) {
+      legacy_bucket_spec.channels[freq_idx].channel =
+          hidl_bucket_spec.frequencies[freq_idx];
+    }
+  }
+  return true;
+}
+
+bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob,
+                               uint32_t ie_blob_len,
+                               std::vector<WifiInformationElement>* hidl_ies) {
+  if (!ie_blob || !hidl_ies) {
+    return false;
+  }
+  const uint8_t* ies_begin = ie_blob;
+  const uint8_t* ies_end = ie_blob + ie_blob_len;
+  const uint8_t* next_ie = ies_begin;
+  using wifi_ie = legacy_hal::wifi_information_element;
+  constexpr size_t kIeHeaderLen = sizeof(wifi_ie);
+  // Each IE should atleast have the header (i.e |id| & |len| fields).
+  while (next_ie + kIeHeaderLen <= ies_end) {
+    const wifi_ie& legacy_ie = (*reinterpret_cast<const wifi_ie*>(next_ie));
+    uint32_t curr_ie_len = kIeHeaderLen + legacy_ie.len;
+    if (next_ie + curr_ie_len > ies_end) {
+      return false;
+    }
+    WifiInformationElement hidl_ie;
+    hidl_ie.id = legacy_ie.id;
+    hidl_ie.data =
+        std::vector<uint8_t>(legacy_ie.data, legacy_ie.data + legacy_ie.len);
+    hidl_ies->push_back(std::move(hidl_ie));
+    next_ie += curr_ie_len;
+  }
+  // Ensure that the blob has been fully consumed.
+  return (next_ie == ies_end);
+}
+
+bool convertLegacyScanResultToHidl(
+    const legacy_hal::wifi_scan_result& legacy_scan_result,
+    bool has_ie_data,
+    StaScanResult* hidl_scan_result) {
+  if (!hidl_scan_result) {
+    return false;
+  }
+  hidl_scan_result->timeStampInUs = legacy_scan_result.ts;
+  hidl_scan_result->ssid = std::vector<uint8_t>(
+      legacy_scan_result.ssid,
+      legacy_scan_result.ssid + sizeof(legacy_scan_result.ssid));
+  memcpy(hidl_scan_result->bssid.data(),
+         legacy_scan_result.bssid,
+         hidl_scan_result->bssid.size());
+  hidl_scan_result->frequency = legacy_scan_result.channel;
+  hidl_scan_result->rssi = legacy_scan_result.rssi;
+  hidl_scan_result->beaconPeriodInMs = legacy_scan_result.beacon_period;
+  hidl_scan_result->capability = legacy_scan_result.capability;
+  if (has_ie_data) {
+    std::vector<WifiInformationElement> ies;
+    if (!convertLegacyIeBlobToHidl(
+            reinterpret_cast<const uint8_t*>(legacy_scan_result.ie_data),
+            legacy_scan_result.ie_length,
+            &ies)) {
+      return false;
+    }
+    hidl_scan_result->informationElements = std::move(ies);
+  }
+  return true;
+}
+
+bool convertLegacyCachedScanResultsToHidl(
+    const legacy_hal::wifi_cached_scan_results& legacy_cached_scan_result,
+    StaScanData* hidl_scan_data) {
+  if (!hidl_scan_data) {
+    return false;
+  }
+  hidl_scan_data->flags = legacy_cached_scan_result.flags;
+  hidl_scan_data->bucketsScanned = legacy_cached_scan_result.buckets_scanned;
+
+  CHECK(legacy_cached_scan_result.num_results >= 0 &&
+        legacy_cached_scan_result.num_results <= MAX_AP_CACHE_PER_SCAN);
+  std::vector<StaScanResult> hidl_scan_results;
+  for (int32_t result_idx = 0;
+       result_idx < legacy_cached_scan_result.num_results;
+       result_idx++) {
+    StaScanResult hidl_scan_result;
+    if (!convertLegacyScanResultToHidl(
+            legacy_cached_scan_result.results[result_idx],
+            false,
+            &hidl_scan_result)) {
+      return false;
+    }
+    hidl_scan_results.push_back(hidl_scan_result);
+  }
+  hidl_scan_data->results = std::move(hidl_scan_results);
+  return true;
+}
+
+bool convertLegacyVectorOfCachedScanResultsToHidl(
+    const std::vector<legacy_hal::wifi_cached_scan_results>&
+        legacy_cached_scan_results,
+    std::vector<StaScanData>* hidl_scan_datas) {
+  if (!hidl_scan_datas) {
+    return false;
+  }
+  for (const auto& legacy_cached_scan_result : legacy_cached_scan_results) {
+    StaScanData hidl_scan_data;
+    if (!convertLegacyCachedScanResultsToHidl(legacy_cached_scan_result,
+                                              &hidl_scan_data)) {
+      return false;
+    }
+    hidl_scan_datas->push_back(hidl_scan_data);
+  }
+  return true;
+}
+
+bool convertLegacyLinkLayerStatsToHidl(
+    const legacy_hal::LinkLayerStats& legacy_stats,
+    StaLinkLayerStats* hidl_stats) {
+  if (!hidl_stats) {
+    return false;
+  }
+  // iface legacy_stats conversion.
+  hidl_stats->iface.beaconRx = legacy_stats.iface.beacon_rx;
+  hidl_stats->iface.avgRssiMgmt = legacy_stats.iface.rssi_mgmt;
+  hidl_stats->iface.wmeBePktStats.rxMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].rx_mpdu;
+  hidl_stats->iface.wmeBePktStats.txMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].tx_mpdu;
+  hidl_stats->iface.wmeBePktStats.lostMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].mpdu_lost;
+  hidl_stats->iface.wmeBePktStats.retries =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BE].retries;
+  hidl_stats->iface.wmeBkPktStats.rxMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].rx_mpdu;
+  hidl_stats->iface.wmeBkPktStats.txMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].tx_mpdu;
+  hidl_stats->iface.wmeBkPktStats.lostMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].mpdu_lost;
+  hidl_stats->iface.wmeBkPktStats.retries =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_BK].retries;
+  hidl_stats->iface.wmeViPktStats.rxMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].rx_mpdu;
+  hidl_stats->iface.wmeViPktStats.txMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].tx_mpdu;
+  hidl_stats->iface.wmeViPktStats.lostMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].mpdu_lost;
+  hidl_stats->iface.wmeViPktStats.retries =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VI].retries;
+  hidl_stats->iface.wmeVoPktStats.rxMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].rx_mpdu;
+  hidl_stats->iface.wmeVoPktStats.txMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].tx_mpdu;
+  hidl_stats->iface.wmeVoPktStats.lostMpdu =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].mpdu_lost;
+  hidl_stats->iface.wmeVoPktStats.retries =
+      legacy_stats.iface.ac[legacy_hal::WIFI_AC_VO].retries;
+  // radio legacy_stats conversion.
+  hidl_stats->radio.onTimeInMs = legacy_stats.radio.on_time;
+  hidl_stats->radio.txTimeInMs = legacy_stats.radio.tx_time;
+  hidl_stats->radio.rxTimeInMs = legacy_stats.radio.rx_time;
+  hidl_stats->radio.onTimeInMsForScan = legacy_stats.radio.on_time_scan;
+  hidl_stats->radio.txTimeInMsPerLevel = legacy_stats.radio_tx_time_per_levels;
+  // Timestamp in the HAL wrapper here since it's not provided in the legacy
+  // HAL API.
+  hidl_stats->timeStampInMs = uptimeMillis();
+  return true;
+}
+}  // namespace hidl_struct_util
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android

wifi/1.0/default/hidl_struct_util.h

@@ -0,0 +1,69 @@
+/*
+ * 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.
+ */
+
+#ifndef HIDL_STRUCT_UTIL_H_
+#define HIDL_STRUCT_UTIL_H_
+
+#include <vector>
+
+#include <android/hardware/wifi/1.0/IWifi.h>
+
+#include "wifi_legacy_hal.h"
+
+/**
+ * This file contains a bunch of functions to convert structs from the legacy
+ * HAL to HIDL and vice versa.
+ * TODO(b/32093047): Add unit tests for these conversion methods in the VTS test
+ * suite.
+ */
+namespace android {
+namespace hardware {
+namespace wifi {
+namespace V1_0 {
+namespace implementation {
+namespace hidl_struct_util {
+
+// Convert hidl gscan params to legacy gscan params.
+bool convertHidlScanParamsToLegacy(
+    const StaBackgroundScanParameters& hidl_scan_params,
+    legacy_hal::wifi_scan_cmd_params* legacy_scan_params);
+// Convert the blob of packed IE elements to vector of
+// |WifiInformationElement| structures.
+bool convertLegacyIeBlobToHidl(const uint8_t* ie_blob,
+                               uint32_t ie_blob_len,
+                               std::vector<WifiInformationElement>* hidl_ies);
+// |has_ie_data| indicates whether or not the wifi_scan_result includes 802.11
+// Information Elements (IEs)
+bool convertLegacyScanResultToHidl(
+    const legacy_hal::wifi_scan_result& legacy_scan_result,
+    bool has_ie_data,
+    StaScanResult* hidl_scan_result);
+// |cached_results| is assumed to not include IEs.
+bool convertLegacyVectorOfCachedScanResultsToHidl(
+    const std::vector<legacy_hal::wifi_cached_scan_results>&
+        legacy_cached_scan_results,
+    std::vector<StaScanData>* hidl_scan_datas);
+bool convertLegacyLinkLayerStatsToHidl(
+    const legacy_hal::LinkLayerStats& legacy_stats,
+    StaLinkLayerStats* hidl_stats);
+}  // namespace hidl_struct_util
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace wifi
+}  // namespace hardware
+}  // namespace android
+
+#endif  // HIDL_STRUCT_UTIL_H_