// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/system/network/active_network_icon.h"
#include "ash/public/cpp/network_config_service.h"
#include "ash/resources/vector_icons/vector_icons.h"
#include "ash/shell.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/system/model/system_tray_model.h"
#include "ash/system/network/network_icon.h"
#include "ash/system/network/network_utils.h"
#include "ash/system/network/tray_network_state_model.h"
#include "ash/system/tray/tray_constants.h"
#include "base/functional/bind.h"
#include "base/strings/utf_string_conversions.h"
#include "chromeos/services/network_config/public/cpp/cros_network_config_util.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/color/color_provider.h"
#include "ui/gfx/paint_vector_icon.h"
using chromeos::network_config::mojom::ActivationStateType;
using chromeos::network_config::mojom::ConnectionStateType;
using chromeos::network_config::mojom::DeviceStateProperties;
using chromeos::network_config::mojom::DeviceStateType;
using chromeos::network_config::mojom::FilterType;
using chromeos::network_config::mojom::NetworkFilter;
using chromeos::network_config::mojom::NetworkStateProperties;
using chromeos::network_config::mojom::NetworkType;
namespace ash {
namespace {
const int kPurgeDelayMs = 500;
} // namespace
ActiveNetworkIcon::ActiveNetworkIcon(TrayNetworkStateModel* model)
: model_(model) {
model_->AddObserver(this);
}
ActiveNetworkIcon::~ActiveNetworkIcon() {
model_->RemoveObserver(this);
}
void ActiveNetworkIcon::GetConnectionStatusStrings(Type type,
std::u16string* a11y_name,
std::u16string* a11y_desc,
std::u16string* tooltip) {
const NetworkStateProperties* network = nullptr;
switch (type) {
case Type::kSingle:
network = model_->default_network();
break;
case Type::kPrimary:
// TODO(902409): Provide strings for technology or connecting.
network = model_->default_network();
break;
case Type::kCellular:
network = model_->active_cellular();
break;
}
std::u16string network_name;
if (network) {
network_name = network->type == NetworkType::kEthernet
? l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ETHERNET)
: base::UTF8ToUTF16(network->name);
}
// Check for Activating first since activating networks may be connected.
if (network && network->type == NetworkType::kCellular &&
network->type_state->get_cellular()->activation_state ==
ActivationStateType::kActivating) {
std::u16string activating_string = l10n_util::GetStringFUTF16(
IDS_ASH_STATUS_TRAY_NETWORK_ACTIVATING, network_name);
if (a11y_name)
*a11y_name = activating_string;
if (a11y_desc)
*a11y_desc = std::u16string();
if (tooltip)
*tooltip = activating_string;
} else if (network && chromeos::network_config::StateIsConnected(
network->connection_state)) {
std::u16string connected_string;
if (auto portal_subtext = GetPortalStateSubtext(network->portal_state)) {
connected_string = l10n_util::GetStringFUTF16(
IDS_ASH_STATUS_TRAY_NETWORK_PORTAL, network_name, *portal_subtext);
} else {
connected_string = l10n_util::GetStringFUTF16(
IDS_ASH_STATUS_TRAY_NETWORK_CONNECTED, network_name);
}
std::u16string signal_strength_string;
if (chromeos::network_config::NetworkTypeMatchesType(
network->type, NetworkType::kWireless)) {
// Retrieve the string describing the signal strength, if it is applicable
// to |network|.
int signal_strength =
chromeos::network_config::GetWirelessSignalStrength(network);
switch (network_icon::GetSignalStrength(signal_strength)) {
case network_icon::SignalStrength::NONE:
break;
case network_icon::SignalStrength::WEAK:
signal_strength_string = l10n_util::GetStringUTF16(
IDS_ASH_STATUS_TRAY_NETWORK_SIGNAL_WEAK);
break;
case network_icon::SignalStrength::MEDIUM:
signal_strength_string = l10n_util::GetStringUTF16(
IDS_ASH_STATUS_TRAY_NETWORK_SIGNAL_MEDIUM);
break;
case network_icon::SignalStrength::STRONG:
signal_strength_string = l10n_util::GetStringUTF16(
IDS_ASH_STATUS_TRAY_NETWORK_SIGNAL_STRONG);
break;
}
}
if (a11y_name)
*a11y_name = connected_string;
if (a11y_desc)
*a11y_desc = signal_strength_string;
if (tooltip) {
*tooltip = signal_strength_string.empty()
? connected_string
: l10n_util::GetStringFUTF16(
IDS_ASH_STATUS_TRAY_NETWORK_CONNECTED_TOOLTIP,
connected_string, signal_strength_string);
}
} else if (network &&
network->connection_state == ConnectionStateType::kConnecting) {
std::u16string connecting_string = l10n_util::GetStringFUTF16(
IDS_ASH_STATUS_TRAY_NETWORK_CONNECTING, network_name);
if (a11y_name)
*a11y_name = connecting_string;
if (a11y_desc)
*a11y_desc = std::u16string();
if (tooltip)
*tooltip = connecting_string;
} else {
if (a11y_name) {
*a11y_name = l10n_util::GetStringUTF16(
IDS_ASH_STATUS_TRAY_NETWORK_NOT_CONNECTED_A11Y);
}
if (a11y_desc)
*a11y_desc = std::u16string();
if (tooltip) {
*tooltip = l10n_util::GetStringUTF16(
IDS_ASH_STATUS_TRAY_NETWORK_DISCONNECTED_TOOLTIP);
}
}
}
gfx::ImageSkia ActiveNetworkIcon::GetImage(
const ui::ColorProvider* color_provider,
Type type,
network_icon::IconType icon_type,
bool* animating) {
switch (type) {
case Type::kSingle:
return GetSingleImage(color_provider, icon_type, animating);
case Type::kPrimary:
return GetDualImagePrimary(color_provider, icon_type, animating);
case Type::kCellular:
return GetDualImageCellular(color_provider, icon_type, animating);
}
NOTREACHED();
}
gfx::ImageSkia ActiveNetworkIcon::GetSingleImage(
const ui::ColorProvider* color_provider,
network_icon::IconType icon_type,
bool* animating) {
// If no network, check for cellular initializing.
const NetworkStateProperties* default_network = model_->default_network();
if (!default_network && cellular_uninitialized_msg_ != 0) {
if (animating)
*animating = true;
return network_icon::GetConnectingImageForNetworkType(
color_provider, NetworkType::kCellular, icon_type);
}
return GetDefaultImageImpl(color_provider, default_network, icon_type,
animating);
}
gfx::ImageSkia ActiveNetworkIcon::GetDualImagePrimary(
const ui::ColorProvider* color_provider,
network_icon::IconType icon_type,
bool* animating) {
const NetworkStateProperties* default_network = model_->default_network();
if (default_network && default_network->type == NetworkType::kCellular) {
if (chromeos::network_config::StateIsConnected(
default_network->connection_state)) {
// TODO(902409): Show proper technology badges.
if (animating)
*animating = false;
return gfx::CreateVectorIcon(
kNetworkBadgeTechnologyLteIcon,
network_icon::GetDefaultColorForIconType(color_provider, icon_type));
}
// If Cellular is connecting, use the active non cellular network.
return GetDefaultImageImpl(color_provider, model_->active_non_cellular(),
icon_type, animating);
}
return GetDefaultImageImpl(color_provider, default_network, icon_type,
animating);
}
gfx::ImageSkia ActiveNetworkIcon::GetDualImageCellular(
const ui::ColorProvider* color_provider,
network_icon::IconType icon_type,
bool* animating) {
if (model_->GetDeviceState(NetworkType::kCellular) ==
DeviceStateType::kUnavailable) {
if (animating)
*animating = false;
return gfx::ImageSkia();
}
if (cellular_uninitialized_msg_ != 0) {
if (animating)
*animating = true;
return network_icon::GetConnectingImageForNetworkType(
color_provider, NetworkType::kCellular, icon_type);
}
const NetworkStateProperties* active_cellular = model_->active_cellular();
if (!active_cellular) {
if (animating)
*animating = false;
// For the `kCellular` icon in the `UnifiedSystemTray`: if the tray is
// active, the icon type should be used to get the correct color.
if (icon_type != network_icon::IconType::ICON_TYPE_TRAY_ACTIVE) {
icon_type = network_icon::IconType::ICON_TYPE_LIST;
}
return network_icon::GetDisconnectedImageForNetworkType(
color_provider, NetworkType::kCellular, icon_type);
}
return network_icon::GetImageForNonVirtualNetwork(
color_provider, active_cellular, icon_type, false /* show_vpn_badge */,
animating);
}
gfx::ImageSkia ActiveNetworkIcon::GetDefaultImageImpl(
const ui::ColorProvider* color_provider,
const NetworkStateProperties* network,
network_icon::IconType icon_type,
bool* animating) {
if (!network) {
VLOG(1) << __func__ << ": No network";
return GetDefaultImageForNoNetwork(color_provider, icon_type, animating);
}
const NetworkStateProperties* active_vpn = model_->active_vpn();
// Connected network with a connecting VPN.
if (chromeos::network_config::StateIsConnected(network->connection_state) &&
active_vpn &&
active_vpn->connection_state == ConnectionStateType::kConnecting) {
if (animating)
*animating = true;
VLOG(1) << __func__ << ": Connected with connecting VPN";
return network_icon::GetConnectedNetworkWithConnectingVpnImage(
color_provider, network, icon_type);
}
// Default behavior: connected or connecting network, possibly with VPN badge.
bool show_vpn_badge = !!active_vpn;
VLOG(1) << __func__ << ": Network: " << network->name;
return network_icon::GetImageForNonVirtualNetwork(
color_provider, network, icon_type, show_vpn_badge, animating);
}
gfx::ImageSkia ActiveNetworkIcon::GetDefaultImageForNoNetwork(
const ui::ColorProvider* color_provider,
network_icon::IconType icon_type,
bool* animating) {
if (animating)
*animating = false;
if (model_->GetDeviceState(NetworkType::kWiFi) == DeviceStateType::kEnabled) {
// WiFi is enabled but no connections available.
return network_icon::GetImageForWiFiNoConnections(color_provider,
icon_type);
}
// WiFi is disabled, show a full icon with a strikethrough.
return network_icon::GetImageForWiFiEnabledState(
color_provider, false /* not enabled*/, icon_type);
}
void ActiveNetworkIcon::SetCellularUninitializedMsg() {
const DeviceStateProperties* cellular =
model_->GetDevice(NetworkType::kCellular);
if (cellular && cellular->device_state == DeviceStateType::kUninitialized) {
cellular_uninitialized_msg_ = IDS_ASH_STATUS_TRAY_INITIALIZING_CELLULAR;
uninitialized_state_time_ = base::Time::Now();
return;
}
// If cellular is scanning, we want to show a 'connecting' image. However,
// there may be some cases where cellular's scanning property is true while
// the device is disabling. In this instance, we don't want to show
// 'connecting'. Only set cellular_uninitialized_msg_ to scanning if the
// device is scanning and enabled or enabling.
if (cellular &&
(cellular->device_state == DeviceStateType::kEnabled ||
cellular->device_state == DeviceStateType::kEnabling) &&
cellular->scanning) {
cellular_uninitialized_msg_ = IDS_ASH_STATUS_TRAY_MOBILE_SCANNING;
uninitialized_state_time_ = base::Time::Now();
return;
}
// If cellular is not scanning and cellular device is enabled reset cellular
// initializing state.
if (cellular && !cellular->scanning &&
(cellular->device_state == DeviceStateType::kEnabled ||
cellular->device_state == DeviceStateType::kEnabling)) {
cellular_uninitialized_msg_ = 0;
}
// There can be a delay between leaving the Initializing state and when
// a Cellular device shows up, so keep showing the initializing
// animation for a bit to avoid flashing the disconnect icon.
const int kInitializingDelaySeconds = 1;
base::TimeDelta dtime = base::Time::Now() - uninitialized_state_time_;
if (dtime.InSeconds() >= kInitializingDelaySeconds)
cellular_uninitialized_msg_ = 0;
}
// TrayNetworkStateObserver
void ActiveNetworkIcon::ActiveNetworkStateChanged() {
SetCellularUninitializedMsg();
}
void ActiveNetworkIcon::DeviceStateListChanged() {
SetCellularUninitializedMsg();
}
void ActiveNetworkIcon::NetworkListChanged() {
if (purge_timer_.IsRunning())
return;
purge_timer_.Start(FROM_HERE, base::Milliseconds(kPurgeDelayMs),
base::BindOnce(&ActiveNetworkIcon::PurgeNetworkIconCache,
weak_ptr_factory_.GetWeakPtr()));
}
void ActiveNetworkIcon::PurgeNetworkIconCache() {
model_->cros_network_config()->GetNetworkStateList(
NetworkFilter::New(FilterType::kVisible, NetworkType::kAll,
/*limit=*/0),
base::BindOnce(
[](std::vector<
chromeos::network_config::mojom::NetworkStatePropertiesPtr>
networks) {
std::set<std::string> network_guids;
for (const auto& iter : networks) {
network_guids.insert(iter->guid);
}
network_icon::PurgeNetworkIconCache(network_guids);
}));
}
} // namespace ash
Codebase Browser
chromium