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 17 #ifndef WIFI_H_ 18 #define WIFI_H_ 19 20 #include <functional> 21 22 #include <android-base/macros.h> 23 #include <android/hardware/wifi/1.2/IWifi.h> 24 #include <utils/Looper.h> 25 26 #include "hidl_callback_util.h" 27 #include "wifi_chip.h" 28 #include "wifi_feature_flags.h" 29 #include "wifi_legacy_hal.h" 30 #include "wifi_mode_controller.h" 31 32 namespace android { 33 namespace hardware { 34 namespace wifi { 35 namespace V1_2 { 36 namespace implementation { 37 38 /** 39 * Root HIDL interface object used to control the Wifi HAL. 40 */ 41 class Wifi : public V1_2::IWifi { 42 public: 43 Wifi(const std::shared_ptr<legacy_hal::WifiLegacyHal> legacy_hal, 44 const std::shared_ptr<mode_controller::WifiModeController> 45 mode_controller, 46 const std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags); 47 48 bool isValid(); 49 50 // HIDL methods exposed. 51 Return<void> registerEventCallback( 52 const sp<IWifiEventCallback>& event_callback, 53 registerEventCallback_cb hidl_status_cb) override; 54 Return<bool> isStarted() override; 55 Return<void> start(start_cb hidl_status_cb) override; 56 Return<void> stop(stop_cb hidl_status_cb) override; 57 Return<void> getChipIds(getChipIds_cb hidl_status_cb) override; 58 Return<void> getChip(ChipId chip_id, getChip_cb hidl_status_cb) override; 59 Return<void> debug(const hidl_handle& handle, 60 const hidl_vec<hidl_string>& options) override; 61 62 private: 63 enum class RunState { STOPPED, STARTED, STOPPING }; 64 65 // Corresponding worker functions for the HIDL methods. 66 WifiStatus registerEventCallbackInternal( 67 const sp<IWifiEventCallback>& event_callback); 68 WifiStatus startInternal(); 69 WifiStatus stopInternal(std::unique_lock<std::recursive_mutex>* lock); 70 std::pair<WifiStatus, std::vector<ChipId>> getChipIdsInternal(); 71 std::pair<WifiStatus, sp<IWifiChip>> getChipInternal(ChipId chip_id); 72 73 WifiStatus initializeModeControllerAndLegacyHal(); 74 WifiStatus stopLegacyHalAndDeinitializeModeController( 75 std::unique_lock<std::recursive_mutex>* lock); 76 77 // Instance is created in this root level |IWifi| HIDL interface object 78 // and shared with all the child HIDL interface objects. 79 std::shared_ptr<legacy_hal::WifiLegacyHal> legacy_hal_; 80 std::shared_ptr<mode_controller::WifiModeController> mode_controller_; 81 std::shared_ptr<feature_flags::WifiFeatureFlags> feature_flags_; 82 RunState run_state_; 83 sp<WifiChip> chip_; 84 hidl_callback_util::HidlCallbackHandler<IWifiEventCallback> 85 event_cb_handler_; 86 87 DISALLOW_COPY_AND_ASSIGN(Wifi); 88 }; 89 90 } // namespace implementation 91 } // namespace V1_2 92 } // namespace wifi 93 } // namespace hardware 94 } // namespace android 95 96 #endif // WIFI_H_ 97