1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_DELEGATE_H_ 6 #define EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_DELEGATE_H_ 7 8 #include <memory> 9 #include <string> 10 #include <vector> 11 12 #include "base/callback.h" 13 #include "base/macros.h" 14 #include "base/optional.h" 15 #include "base/values.h" 16 #include "components/keyed_service/core/keyed_service.h" 17 #include "extensions/common/api/networking_private.h" 18 19 namespace extensions { 20 21 class NetworkingPrivateDelegateObserver; 22 23 // Base class for platform dependent networkingPrivate API implementations. 24 // All inputs and results for this class use ONC values. See 25 // networking_private.idl for descriptions of the expected inputs and results. 26 class NetworkingPrivateDelegate : public KeyedService { 27 public: 28 using DictionaryCallback = 29 base::OnceCallback<void(std::unique_ptr<base::DictionaryValue>)>; 30 using VoidCallback = base::OnceCallback<void()>; 31 using BoolCallback = base::OnceCallback<void(bool)>; 32 using StringCallback = base::OnceCallback<void(const std::string&)>; 33 using NetworkListCallback = 34 base::OnceCallback<void(std::unique_ptr<base::ListValue>)>; 35 using FailureCallback = base::OnceCallback<void(const std::string&)>; 36 using DeviceStateList = std::vector< 37 std::unique_ptr<api::networking_private::DeviceStateProperties>>; 38 39 // Returns |result| on success, or |result|=nullopt and |error| on failure. 40 using PropertiesCallback = 41 base::OnceCallback<void(base::Optional<base::Value> result, 42 base::Optional<std::string> error)>; 43 44 // Delegate for forwarding UI requests, e.g. for showing the account UI. 45 class UIDelegate { 46 public: 47 UIDelegate(); 48 virtual ~UIDelegate(); 49 50 // Navigate to the acoount details page for the cellular network associated 51 // with |guid|. 52 virtual void ShowAccountDetails(const std::string& guid) const = 0; 53 54 private: 55 DISALLOW_COPY_AND_ASSIGN(UIDelegate); 56 }; 57 58 NetworkingPrivateDelegate(); 59 ~NetworkingPrivateDelegate() override; 60 set_ui_delegate(std::unique_ptr<UIDelegate> ui_delegate)61 void set_ui_delegate(std::unique_ptr<UIDelegate> ui_delegate) { 62 ui_delegate_ = std::move(ui_delegate); 63 } 64 ui_delegate()65 const UIDelegate* ui_delegate() { return ui_delegate_.get(); } 66 67 // Asynchronous methods 68 virtual void GetProperties(const std::string& guid, 69 PropertiesCallback callback) = 0; 70 virtual void GetManagedProperties(const std::string& guid, 71 PropertiesCallback callback) = 0; 72 virtual void GetState(const std::string& guid, 73 DictionaryCallback success_callback, 74 FailureCallback failure_callback) = 0; 75 virtual void SetProperties(const std::string& guid, 76 std::unique_ptr<base::DictionaryValue> properties, 77 bool allow_set_shared_config, 78 VoidCallback success_callback, 79 FailureCallback failure_callback) = 0; 80 virtual void CreateNetwork(bool shared, 81 std::unique_ptr<base::DictionaryValue> properties, 82 StringCallback success_callback, 83 FailureCallback failure_callback) = 0; 84 virtual void ForgetNetwork(const std::string& guid, 85 bool allow_forget_shared_config, 86 VoidCallback success_callback, 87 FailureCallback failure_callback) = 0; 88 virtual void GetNetworks(const std::string& network_type, 89 bool configured_only, 90 bool visible_only, 91 int limit, 92 NetworkListCallback success_callback, 93 FailureCallback failure_callback) = 0; 94 virtual void StartConnect(const std::string& guid, 95 VoidCallback success_callback, 96 FailureCallback failure_callback) = 0; 97 virtual void StartDisconnect(const std::string& guid, 98 VoidCallback success_callback, 99 FailureCallback failure_callback) = 0; 100 virtual void StartActivate(const std::string& guid, 101 const std::string& carrier, 102 VoidCallback success_callback, 103 FailureCallback failure_callback); 104 virtual void GetCaptivePortalStatus(const std::string& guid, 105 StringCallback success_callback, 106 FailureCallback failure_callback) = 0; 107 virtual void UnlockCellularSim(const std::string& guid, 108 const std::string& pin, 109 const std::string& puk, 110 VoidCallback success_callback, 111 FailureCallback failure_callback) = 0; 112 virtual void SetCellularSimState(const std::string& guid, 113 bool require_pin, 114 const std::string& current_pin, 115 const std::string& new_pin, 116 VoidCallback success_callback, 117 FailureCallback failure_callback) = 0; 118 virtual void SelectCellularMobileNetwork( 119 const std::string& guid, 120 const std::string& network_id, 121 VoidCallback success_callback, 122 FailureCallback failure_callback) = 0; 123 124 // Synchronous methods 125 126 // Returns a list of ONC type strings. 127 virtual std::unique_ptr<base::ListValue> GetEnabledNetworkTypes() = 0; 128 129 // Returns a list of DeviceStateProperties. 130 virtual std::unique_ptr<DeviceStateList> GetDeviceStateList() = 0; 131 132 // Returns a dictionary of global policy values (may be empty). Note: the 133 // dictionary is expected to be a superset of the networkingPrivate 134 // GlobalPolicy dictionary. Any properties not in GlobalPolicy will be 135 // ignored. 136 virtual std::unique_ptr<base::DictionaryValue> GetGlobalPolicy() = 0; 137 138 // Returns a dictionary of certificate lists. 139 virtual std::unique_ptr<base::DictionaryValue> GetCertificateLists() = 0; 140 141 // Returns true if the ONC network type |type| is enabled. 142 virtual bool EnableNetworkType(const std::string& type) = 0; 143 144 // Returns true if the ONC network type |type| is disabled. 145 virtual bool DisableNetworkType(const std::string& type) = 0; 146 147 // Returns true if a scan was requested. It may take many seconds for a scan 148 // to complete. The scan may or may not trigger API events when complete. 149 // |type| is the type of network to request a scan for; if empty, scans for 150 // all supported network types except Cellular, which must be requested 151 // explicitly. 152 virtual bool RequestScan(const std::string& type) = 0; 153 154 // Optional methods for adding a NetworkingPrivateDelegateObserver for 155 // implementations that require it (non-chromeos). 156 virtual void AddObserver(NetworkingPrivateDelegateObserver* observer); 157 virtual void RemoveObserver(NetworkingPrivateDelegateObserver* observer); 158 159 private: 160 // Interface for UI methods. May be null. 161 std::unique_ptr<UIDelegate> ui_delegate_; 162 163 DISALLOW_COPY_AND_ASSIGN(NetworkingPrivateDelegate); 164 }; 165 166 } // namespace extensions 167 168 #endif // EXTENSIONS_BROWSER_API_NETWORKING_PRIVATE_NETWORKING_PRIVATE_DELEGATE_H_ 169