tray_network_state_model.cc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312
  1. // Copyright (c) 2012 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. #include "ash/system/network/tray_network_state_model.h"
  5. #include <set>
  6. #include <string>
  7. #include "ash/public/cpp/network_config_service.h"
  8. #include "ash/system/network/vpn_list.h"
  9. #include "base/bind.h"
  10. #include "base/callback_helpers.h"
  11. #include "base/containers/contains.h"
  12. #include "base/location.h"
  13. #include "chromeos/services/network_config/public/cpp/cros_network_config_observer.h"
  14. #include "chromeos/services/network_config/public/cpp/cros_network_config_util.h"
  15. #include "mojo/public/cpp/bindings/receiver.h"
  16. #include "mojo/public/cpp/bindings/remote.h"
  17. #include "third_party/cros_system_api/dbus/service_constants.h"
  18. #include "ui/compositor/scoped_animation_duration_scale_mode.h"
  19. using chromeos::network_config::mojom::ConnectionStateType;
  20. using chromeos::network_config::mojom::DeviceStateProperties;
  21. using chromeos::network_config::mojom::DeviceStatePropertiesPtr;
  22. using chromeos::network_config::mojom::DeviceStateType;
  23. using chromeos::network_config::mojom::FilterType;
  24. using chromeos::network_config::mojom::NetworkFilter;
  25. using chromeos::network_config::mojom::NetworkStateProperties;
  26. using chromeos::network_config::mojom::NetworkStatePropertiesPtr;
  27. using chromeos::network_config::mojom::NetworkType;
  28. namespace {
  29. const int kUpdateFrequencyMs = 1000;
  30. NetworkStatePropertiesPtr GetConnectingOrConnected(
  31. const NetworkStatePropertiesPtr* connecting_network,
  32. const NetworkStatePropertiesPtr* connected_network) {
  33. if (connecting_network &&
  34. (!connected_network || connecting_network->get()->connect_requested)) {
  35. // If connecting to a network, and there is either no connected network or
  36. // the connection was user requested, use the connecting network.
  37. return connecting_network->Clone();
  38. }
  39. if (connected_network)
  40. return connected_network->Clone();
  41. return nullptr;
  42. }
  43. } // namespace
  44. namespace ash {
  45. class TrayNetworkStateModel::Impl
  46. : public chromeos::network_config::CrosNetworkConfigObserver {
  47. public:
  48. explicit Impl(TrayNetworkStateModel* model) : model_(model) {
  49. GetNetworkConfigService(
  50. remote_cros_network_config_.BindNewPipeAndPassReceiver());
  51. remote_cros_network_config_->AddObserver(
  52. cros_network_config_observer_receiver_.BindNewPipeAndPassRemote());
  53. }
  54. Impl(const Impl&) = delete;
  55. Impl& operator=(const Impl&) = delete;
  56. ~Impl() override = default;
  57. void GetActiveNetworks() {
  58. DCHECK(remote_cros_network_config_);
  59. remote_cros_network_config_->GetNetworkStateList(
  60. NetworkFilter::New(FilterType::kActive, NetworkType::kAll,
  61. /*limit=*/0),
  62. base::BindOnce(&TrayNetworkStateModel::Impl::OnActiveNetworksChanged,
  63. base::Unretained(this)));
  64. }
  65. void GetVirtualNetworks() {
  66. DCHECK(remote_cros_network_config_);
  67. remote_cros_network_config_->GetNetworkStateList(
  68. NetworkFilter::New(FilterType::kConfigured, NetworkType::kVPN,
  69. /*limit=*/0),
  70. base::BindOnce(&TrayNetworkStateModel::OnGetVirtualNetworks,
  71. base::Unretained(model_)));
  72. }
  73. void GetDeviceStateList() {
  74. DCHECK(remote_cros_network_config_);
  75. remote_cros_network_config_->GetDeviceStateList(
  76. base::BindOnce(&TrayNetworkStateModel::OnGetDeviceStateList,
  77. base::Unretained(model_)));
  78. }
  79. void GetGlobalPolicy() {
  80. DCHECK(remote_cros_network_config_);
  81. remote_cros_network_config_->GetGlobalPolicy(base::BindOnce(
  82. &TrayNetworkStateModel::OnGetGlobalPolicy, base::Unretained(model_)));
  83. }
  84. void SetNetworkTypeEnabledState(NetworkType type, bool enabled) {
  85. DCHECK(remote_cros_network_config_);
  86. remote_cros_network_config_->SetNetworkTypeEnabledState(type, enabled,
  87. base::DoNothing());
  88. }
  89. chromeos::network_config::mojom::CrosNetworkConfig* cros_network_config() {
  90. return remote_cros_network_config_.get();
  91. }
  92. private:
  93. // CrosNetworkConfigObserver
  94. void OnActiveNetworksChanged(
  95. std::vector<NetworkStatePropertiesPtr> networks) override {
  96. model_->UpdateActiveNetworks(std::move(networks));
  97. model_->SendActiveNetworkStateChanged();
  98. }
  99. void OnNetworkStateListChanged() override {
  100. model_->NotifyNetworkListChanged();
  101. GetVirtualNetworks();
  102. }
  103. void OnDeviceStateListChanged() override { GetDeviceStateList(); }
  104. void OnVpnProvidersChanged() override { model_->NotifyVpnProvidersChanged(); }
  105. void OnPoliciesApplied(const std::string& userhash) override {
  106. GetGlobalPolicy();
  107. }
  108. TrayNetworkStateModel* model_;
  109. mojo::Remote<chromeos::network_config::mojom::CrosNetworkConfig>
  110. remote_cros_network_config_;
  111. mojo::Receiver<chromeos::network_config::mojom::CrosNetworkConfigObserver>
  112. cros_network_config_observer_receiver_{this};
  113. };
  114. TrayNetworkStateModel::TrayNetworkStateModel()
  115. : update_frequency_(kUpdateFrequencyMs) {
  116. if (ui::ScopedAnimationDurationScaleMode::duration_multiplier() !=
  117. ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION) {
  118. update_frequency_ = 0; // Send updates immediately for tests.
  119. }
  120. impl_ = std::make_unique<Impl>(this);
  121. vpn_list_ = std::make_unique<VpnList>(this);
  122. impl_->GetActiveNetworks();
  123. impl_->GetVirtualNetworks();
  124. impl_->GetDeviceStateList();
  125. impl_->GetGlobalPolicy();
  126. }
  127. TrayNetworkStateModel::~TrayNetworkStateModel() {
  128. vpn_list_.reset();
  129. }
  130. void TrayNetworkStateModel::AddObserver(TrayNetworkStateObserver* observer) {
  131. observer_list_.AddObserver(observer);
  132. }
  133. void TrayNetworkStateModel::RemoveObserver(TrayNetworkStateObserver* observer) {
  134. observer_list_.RemoveObserver(observer);
  135. }
  136. const DeviceStateProperties* TrayNetworkStateModel::GetDevice(
  137. NetworkType type) const {
  138. auto iter = devices_.find(type);
  139. if (iter == devices_.end())
  140. return nullptr;
  141. return iter->second.get();
  142. }
  143. DeviceStateType TrayNetworkStateModel::GetDeviceState(NetworkType type) const {
  144. const DeviceStateProperties* device = GetDevice(type);
  145. return device ? device->device_state : DeviceStateType::kUnavailable;
  146. }
  147. void TrayNetworkStateModel::SetNetworkTypeEnabledState(NetworkType type,
  148. bool enabled) {
  149. impl_->SetNetworkTypeEnabledState(type, enabled);
  150. }
  151. void TrayNetworkStateModel::FlushGlobalPolicyForTesting() {
  152. impl_->GetGlobalPolicy();
  153. }
  154. bool TrayNetworkStateModel::IsBuiltinVpnProhibited() const {
  155. return TrayNetworkStateModel::GetDeviceState(
  156. chromeos::network_config::mojom::NetworkType::kVPN) ==
  157. chromeos::network_config::mojom::DeviceStateType::kProhibited;
  158. }
  159. chromeos::network_config::mojom::CrosNetworkConfig*
  160. TrayNetworkStateModel::cros_network_config() {
  161. return impl_->cros_network_config();
  162. }
  163. void TrayNetworkStateModel::OnGetDeviceStateList(
  164. std::vector<DeviceStatePropertiesPtr> devices) {
  165. devices_.clear();
  166. for (auto& device : devices) {
  167. NetworkType type = device->type;
  168. if (base::Contains(devices_, type))
  169. continue; // Ignore multiple entries with the same type.
  170. devices_.emplace(std::make_pair(type, std::move(device)));
  171. }
  172. impl_->GetActiveNetworks(); // Will trigger an observer event.
  173. SendDeviceStateListChanged();
  174. }
  175. void TrayNetworkStateModel::UpdateActiveNetworks(
  176. std::vector<NetworkStatePropertiesPtr> networks) {
  177. active_cellular_.reset();
  178. active_vpn_.reset();
  179. const NetworkStatePropertiesPtr* connected_network = nullptr;
  180. const NetworkStatePropertiesPtr* connected_non_cellular = nullptr;
  181. const NetworkStatePropertiesPtr* connecting_network = nullptr;
  182. const NetworkStatePropertiesPtr* connecting_non_cellular = nullptr;
  183. for (const NetworkStatePropertiesPtr& network : networks) {
  184. if (network->type == NetworkType::kVPN) {
  185. if (!active_vpn_)
  186. active_vpn_ = network.Clone();
  187. continue;
  188. }
  189. if (network->type == NetworkType::kCellular) {
  190. if (!active_cellular_)
  191. active_cellular_ = network.Clone();
  192. }
  193. if (chromeos::network_config::StateIsConnected(network->connection_state)) {
  194. if (!connected_network)
  195. connected_network = &network;
  196. if (!connected_non_cellular && network->type != NetworkType::kCellular) {
  197. connected_non_cellular = &network;
  198. }
  199. continue;
  200. }
  201. // Active non connected networks are connecting.
  202. if (chromeos::network_config::NetworkStateMatchesType(
  203. network.get(), NetworkType::kWireless)) {
  204. if (!connecting_network)
  205. connecting_network = &network;
  206. if (!connecting_non_cellular && network->type != NetworkType::kCellular) {
  207. connecting_non_cellular = &network;
  208. }
  209. }
  210. }
  211. VLOG_IF(2, connected_network)
  212. << __func__ << ": Connected network: " << connected_network->get()->name
  213. << " State: " << connected_network->get()->connection_state;
  214. VLOG_IF(2, connecting_network)
  215. << __func__ << ": Connecting network: " << connecting_network->get()->name
  216. << " State: " << connecting_network->get()->connection_state;
  217. default_network_ =
  218. GetConnectingOrConnected(connecting_network, connected_network);
  219. VLOG_IF(2, default_network_)
  220. << __func__ << ": Default network: " << default_network_->name;
  221. active_non_cellular_ =
  222. GetConnectingOrConnected(connecting_non_cellular, connected_non_cellular);
  223. }
  224. void TrayNetworkStateModel::OnGetVirtualNetworks(
  225. std::vector<NetworkStatePropertiesPtr> networks) {
  226. has_vpn_ = !networks.empty();
  227. }
  228. void TrayNetworkStateModel::OnGetGlobalPolicy(
  229. chromeos::network_config::mojom::GlobalPolicyPtr global_policy) {
  230. global_policy_ = std::move(global_policy);
  231. NotifyGlobalPolicyChanged();
  232. }
  233. void TrayNetworkStateModel::NotifyNetworkListChanged() {
  234. if (timer_.IsRunning())
  235. return;
  236. timer_.Start(FROM_HERE, base::Milliseconds(update_frequency_),
  237. base::BindOnce(&TrayNetworkStateModel::SendNetworkListChanged,
  238. base::Unretained(this)));
  239. }
  240. void TrayNetworkStateModel::NotifyGlobalPolicyChanged() {
  241. for (auto& observer : observer_list_)
  242. observer.GlobalPolicyChanged();
  243. }
  244. void TrayNetworkStateModel::NotifyVpnProvidersChanged() {
  245. for (auto& observer : observer_list_)
  246. observer.VpnProvidersChanged();
  247. }
  248. void TrayNetworkStateModel::SendActiveNetworkStateChanged() {
  249. for (auto& observer : observer_list_)
  250. observer.ActiveNetworkStateChanged();
  251. }
  252. void TrayNetworkStateModel::SendNetworkListChanged() {
  253. for (auto& observer : observer_list_)
  254. observer.NetworkListChanged();
  255. }
  256. void TrayNetworkStateModel::SendDeviceStateListChanged() {
  257. for (auto& observer : observer_list_)
  258. observer.DeviceStateListChanged();
  259. }
  260. } // namespace ash