| /* |
| * 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 WIFICOND_OFFLOAD_SCAN_MANAGER_H_ |
| #define WIFICOND_OFFLOAD_SCAN_MANAGER_H_ |
| |
| #include <android/hardware/wifi/offload/1.0/IOffload.h> |
| #include "wificond/scanning/offload/offload_callback.h" |
| #include "wificond/scanning/offload/offload_callback_handlers.h" |
| #include "wificond/scanning/offload_scan_callback_interface_impl.h" |
| |
| #include <vector> |
| |
| namespace com { |
| namespace android { |
| namespace server { |
| namespace wifi { |
| namespace wificond { |
| |
| class NativeScanResult; |
| class NativeScanStats; |
| |
| } // namespace wificond |
| } // namespace wifi |
| } // namespace server |
| } // namespace android |
| } // namespace com |
| |
| namespace android { |
| namespace wificond { |
| |
| class OffloadScanManager; |
| class OffloadDeathRecipient; |
| class OffloadServiceUtils; |
| |
| // Provides callback interface implementation from Offload HAL |
| class OffloadCallbackHandlersImpl : public OffloadCallbackHandlers { |
| public: |
| OffloadCallbackHandlersImpl(OffloadScanManager* parent); |
| ~OffloadCallbackHandlersImpl() override; |
| |
| void OnScanResultHandler( |
| const std::vector<android::hardware::wifi::offload::V1_0::ScanResult>& |
| scanResult) override; |
| void OnErrorHandler( |
| const android::hardware::wifi::offload::V1_0::OffloadStatus& status) |
| override; |
| |
| private: |
| OffloadScanManager* offload_scan_manager_; |
| }; |
| |
| // Provides methods to interact with Offload HAL |
| class OffloadScanManager { |
| public: |
| enum StatusCode { |
| /* Corresponds to OffloadStatusCode::OK */ |
| kNoError, |
| /* Offload HAL service not avaialble */ |
| kNoService, |
| /* Corresponds to OffloadStatusCode::NO_CONNECTION */ |
| kNotConnected, |
| /* Corresponds to OffloadStatusCode::TIMEOUT */ |
| kTimeOut, |
| /* Corresponds to OffloadStatusCode::ERROR */ |
| kError |
| }; |
| |
| enum ReasonCode { |
| /* Default value */ |
| kNone, |
| /* Offload HAL scans is not available */ |
| kNotAvailable, |
| /* Offload HAL requested operation failure */ |
| kOperationFailed, |
| /* Binder failed to deliver message to Offload HAL*/ |
| kTransactionFailed, |
| }; |
| |
| explicit OffloadScanManager( |
| std::weak_ptr<OffloadServiceUtils> utils, |
| std::shared_ptr<OffloadScanCallbackInterface> callback); |
| virtual ~OffloadScanManager(); |
| /* Request start of offload scans with scan parameters and scan filter |
| * settings. Internally calls Offload HAL service with configureScans() |
| * and subscribeScanResults() APIs. Reason code indicates failure reason. |
| */ |
| virtual bool startScan( |
| uint32_t /* interval_ms */, int32_t /* rssi_threshold */, |
| const std::vector<std::vector<uint8_t>>& /* scan_ssids */, |
| const std::vector<std::vector<uint8_t>>& /* match_ssids */, |
| const std::vector<uint8_t>& /* match_security */, |
| const std::vector<uint32_t>& /* freqs */, |
| ReasonCode* /* failure reason */); |
| /* Request stop of offload scans, returns true if the operation succeeds |
| * Otherwise, returns false. Reason code is updated in case of failure. |
| */ |
| virtual bool stopScan(ReasonCode* /* failure reason */); |
| /* Get statistics for scans performed by Offload HAL */ |
| virtual bool getScanStats( |
| ::com::android::server::wifi::wificond::NativeScanStats* /* scanStats */); |
| /* Otain status of the Offload HAL service */ |
| virtual StatusCode getOffloadStatus() const; |
| /* Returns the most recent scan result available from Offload HAL */ |
| virtual bool getScanResults( |
| std::vector<::com::android::server::wifi::wificond::NativeScanResult>* |
| out_scan_results); |
| |
| private: |
| void ReportScanResults( |
| const std::vector<android::hardware::wifi::offload::V1_0::ScanResult>& |
| scanResult); |
| void ReportError( |
| const android::hardware::wifi::offload::V1_0::OffloadStatus& status); |
| bool VerifyAndConvertHIDLStatus( |
| std::pair<android::hardware::wifi::offload::V1_0::OffloadStatus, bool> |
| result, |
| OffloadScanManager::ReasonCode* reason_code); |
| bool GetScanStats( |
| ::com::android::server::wifi::wificond::NativeScanStats* stats); |
| bool SubscribeScanResults( |
| OffloadScanManager::ReasonCode* reason_code); |
| bool ConfigureScans( |
| android::hardware::wifi::offload::V1_0::ScanParam, |
| android::hardware::wifi::offload::V1_0::ScanFilter, |
| OffloadScanManager::ReasonCode* reason_code); |
| bool InitServiceIfNeeded(); |
| bool InitService(); |
| |
| /* Handle binder death */ |
| void OnObjectDeath(uint64_t /* cookie */); |
| |
| android::sp<android::hardware::wifi::offload::V1_0::IOffload> |
| wifi_offload_hal_; |
| android::sp<OffloadCallback> wifi_offload_callback_; |
| android::sp<OffloadDeathRecipient> death_recipient_; |
| StatusCode offload_status_; |
| std::vector<::com::android::server::wifi::wificond::NativeScanResult> |
| cached_scan_results_; |
| bool service_available_; |
| |
| const std::weak_ptr<OffloadServiceUtils> offload_service_utils_; |
| const std::shared_ptr<OffloadCallbackHandlersImpl> offload_callback_handlers_; |
| std::shared_ptr<OffloadScanCallbackInterface> event_callback_; |
| |
| friend class OffloadCallbackHandlersImpl; |
| }; |
| |
| } // namespace wificond |
| } // namespace android |
| |
| #endif // WIFICOND_OFFLOAD_SCAN_MANAGER_H_ |