ash/system/bluetooth/bluetooth_detailed_view.cc - chromium/src - Git at Google

 // Copyright 2018 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "ash/system/bluetooth/bluetooth_detailed_view.h"

 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <utility>

 #include "ash/public/cpp/system_tray_client.h"
 #include "ash/resources/vector_icons/vector_icons.h"
 #include "ash/shell.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "ash/style/ash_color_provider.h"
 #include "ash/system/machine_learning/user_settings_event_logger.h"
 #include "ash/system/model/system_tray_model.h"
 #include "ash/system/tray/hover_highlight_view.h"
 #include "ash/system/tray/tray_info_label.h"
 #include "ash/system/tray/tray_popup_utils.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "services/device/public/cpp/bluetooth/bluetooth_utils.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/views/controls/button/toggle_button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/scroll_view.h"
 #include "ui/views/layout/box_layout.h"

 using device::mojom::BluetoothDeviceInfo;
 using device::mojom::BluetoothSystem;

 namespace ash {
 namespace tray {
 namespace {

 const int kDisabledPanelLabelBaselineY = 20;

 // Returns corresponding device type icons for given Bluetooth device types and
 // connection states.
 const gfx::VectorIcon& GetBluetoothDeviceIcon(
     BluetoothDeviceInfo::DeviceType device_type,
     BluetoothDeviceInfo::ConnectionState connection_state) {
   switch (device_type) {
     case BluetoothDeviceInfo::DeviceType::kComputer:
       return ash::kSystemMenuComputerIcon;
     case BluetoothDeviceInfo::DeviceType::kPhone:
       return ash::kSystemMenuPhoneIcon;
     case BluetoothDeviceInfo::DeviceType::kAudio:
     case BluetoothDeviceInfo::DeviceType::kCarAudio:
       return ash::kSystemMenuHeadsetIcon;
     case BluetoothDeviceInfo::DeviceType::kVideo:
       return ash::kSystemMenuVideocamIcon;
     case BluetoothDeviceInfo::DeviceType::kJoystick:
     case BluetoothDeviceInfo::DeviceType::kGamepad:
       return ash::kSystemMenuGamepadIcon;
     case BluetoothDeviceInfo::DeviceType::kKeyboard:
     case BluetoothDeviceInfo::DeviceType::kKeyboardMouseCombo:
       return ash::kSystemMenuKeyboardIcon;
     case BluetoothDeviceInfo::DeviceType::kTablet:
       return ash::kSystemMenuTabletIcon;
     case BluetoothDeviceInfo::DeviceType::kMouse:
       return ash::kSystemMenuMouseIcon;
     case BluetoothDeviceInfo::DeviceType::kModem:
     case BluetoothDeviceInfo::DeviceType::kPeripheral:
       return ash::kSystemMenuBluetoothIcon;
     default:
       return connection_state ==
                      BluetoothDeviceInfo::ConnectionState::kConnected
                  ? ash::kSystemMenuBluetoothConnectedIcon
                  : ash::kSystemMenuBluetoothIcon;
   }
 }

 views::View* CreateDisabledPanel() {
   views::View* container = new views::View;
   auto box_layout = std::make_unique<views::BoxLayout>(
       views::BoxLayout::Orientation::kVertical);
   box_layout->set_main_axis_alignment(
       views::BoxLayout::MainAxisAlignment::kCenter);
   container->SetLayoutManager(std::move(box_layout));

   auto* color_provider = AshColorProvider::Get();
   auto* image_view =
       container->AddChildView(std::make_unique<views::ImageView>());
   image_view->SetImage(gfx::CreateVectorIcon(
       kSystemMenuBluetoothDisabledIcon,
       AshColorProvider::GetDisabledColor(color_provider->GetContentLayerColor(
           AshColorProvider::ContentLayerType::kIconColorPrimary))));
   image_view->SetVerticalAlignment(views::ImageView::Alignment::kTrailing);

   auto* label = container->AddChildView(std::make_unique<views::Label>(
       l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BLUETOOTH_DISABLED)));
   label->SetEnabledColor(
       AshColorProvider::GetDisabledColor(color_provider->GetContentLayerColor(
           AshColorProvider::ContentLayerType::kTextColorPrimary)));
   TrayPopupUtils::SetLabelFontList(
       label, TrayPopupUtils::FontStyle::kDetailedViewLabel);
   label->SetBorder(views::CreateEmptyBorder(
       kDisabledPanelLabelBaselineY - label->GetBaseline(), 0, 0, 0));

   // Make top padding of the icon equal to the height of the label so that the
   // icon is vertically aligned to center of the container.
   image_view->SetBorder(
       views::CreateEmptyBorder(label->GetPreferredSize().height(), 0, 0, 0));
   return container;
 }

 void LogUserBluetoothEvent(const BluetoothAddress& device_address) {
   ml::UserSettingsEventLogger* logger = ml::UserSettingsEventLogger::Get();
   if (logger) {
     logger->LogBluetoothUkmEvent(device_address);
   }
 }

 HoverHighlightView* GetScrollListItemForDevice(
     const std::unordered_map<HoverHighlightView*, BluetoothAddress>& device_map,
     const BluetoothAddress& address) {
   for (const auto& view_and_address : device_map) {
     if (view_and_address.second == address)
       return view_and_address.first;
   }
   return nullptr;
 }

 }  // namespace

 BluetoothDetailedView::BluetoothDetailedView(DetailedViewDelegate* delegate,
                                              LoginStatus login)
     : TrayDetailedView(delegate), login_(login) {
   CreateItems();
 }

 BluetoothDetailedView::~BluetoothDetailedView() = default;

 void BluetoothDetailedView::ShowLoadingIndicator() {
   // Setting a value of -1 gives progress_bar an infinite-loading behavior.
   ShowProgress(-1, true);
 }

 void BluetoothDetailedView::HideLoadingIndicator() {
   ShowProgress(0, false);
 }

 void BluetoothDetailedView::ShowBluetoothDisabledPanel() {
   device_map_.clear();
   paired_devices_heading_ = nullptr;
   unpaired_devices_heading_ = nullptr;
   bluetooth_discovering_label_ = nullptr;
   scroll_content()->RemoveAllChildViews(true);

   DCHECK(scroller());
   if (!disabled_panel_) {
     disabled_panel_ = CreateDisabledPanel();
     // Insert |disabled_panel_| before the scroller, since the scroller will
     // have unnecessary bottom border when it is not the last child.
     AddChildViewAt(disabled_panel_, GetIndexOf(scroller()));
     // |disabled_panel_| need to fill the remaining space below the title row
     // so that the inner contents of |disabled_panel_| are placed properly.
     box_layout()->SetFlexForView(disabled_panel_, 1);
   }

   disabled_panel_->SetVisible(true);
   scroller()->SetVisible(false);

   Layout();
 }

 void BluetoothDetailedView::HideBluetoothDisabledPanel() {
   DCHECK(scroller());
   if (disabled_panel_)
     disabled_panel_->SetVisible(false);
   scroller()->SetVisible(true);

   Layout();
 }

 bool BluetoothDetailedView::IsDeviceScrollListEmpty() const {
   return device_map_.empty();
 }

 void BluetoothDetailedView::UpdateDeviceScrollList(
     const BluetoothDeviceList& connected_devices,
     const BluetoothDeviceList& connecting_devices,
     const BluetoothDeviceList& paired_not_connected_devices,
     const BluetoothDeviceList& discovered_not_paired_devices) {
   connecting_devices_.clear();
   for (const auto& device : connecting_devices)
     connecting_devices_.push_back(device->Clone());

   paired_not_connected_devices_.clear();
   for (const auto& device : paired_not_connected_devices)
     paired_not_connected_devices_.push_back(device->Clone());

   // Keep track of previous device_map_ so that existing scroll list
   // item views can be re-used. This is required for a11y so that
   // keyboard focus and screen-reader call outs are not disrupted
   // by frequent device list updates.
   std::unordered_map<HoverHighlightView*, BluetoothAddress> old_device_map =
       device_map_;
   device_map_.clear();

   // Add paired devices and their section header to the list.
   bool has_paired_devices = !connected_devices.empty() ||
                             !connecting_devices.empty() ||
                             !paired_not_connected_devices.empty();
   int index = 0;
   if (has_paired_devices) {
     paired_devices_heading_ =
         AddSubHeading(IDS_ASH_STATUS_TRAY_BLUETOOTH_PAIRED_DEVICES,
                       paired_devices_heading_, index++);
     index = AddSameTypeDevicesToScrollList(connected_devices, old_device_map,
                                            index, true, true);
     index = AddSameTypeDevicesToScrollList(connecting_devices, old_device_map,
                                            index, true, false);
     index = AddSameTypeDevicesToScrollList(paired_not_connected_devices,
                                            old_device_map, index, false, false);
   } else if (paired_devices_heading_) {
     scroll_content()->RemoveChildView(paired_devices_heading_);
     paired_devices_heading_ = nullptr;
   }

   // Add unpaired devices to the list. If at least one paired device is
   // present, also add a section header above the unpaired devices.
   if (!discovered_not_paired_devices.empty()) {
     if (has_paired_devices) {
       unpaired_devices_heading_ =
           AddSubHeading(IDS_ASH_STATUS_TRAY_BLUETOOTH_UNPAIRED_DEVICES,
                         unpaired_devices_heading_, index++);
     }
     index = AddSameTypeDevicesToScrollList(discovered_not_paired_devices,
                                            old_device_map, index, false, false);
   }

   if (unpaired_devices_heading_ &&
       (discovered_not_paired_devices.empty() || !has_paired_devices)) {
     scroll_content()->RemoveChildView(unpaired_devices_heading_);
     unpaired_devices_heading_ = nullptr;
   }

   // Show user Bluetooth state if there is no bluetooth devices in list.
   if (device_map_.empty()) {
     if (!bluetooth_discovering_label_) {
       bluetooth_discovering_label_ =
           new TrayInfoLabel(IDS_ASH_STATUS_TRAY_BLUETOOTH_DISCOVERING);
       scroll_content()->AddChildViewAt(bluetooth_discovering_label_, index++);
     } else {
       scroll_content()->ReorderChildView(bluetooth_discovering_label_, index++);
     }
   } else if (bluetooth_discovering_label_) {
     scroll_content()->RemoveChildView(bluetooth_discovering_label_);
     bluetooth_discovering_label_ = nullptr;
   }

   // Remove views for devices from old_device_map that are not in device_map_.
   for (auto& view_and_address : old_device_map) {
     if (device_map_.find(view_and_address.first) == device_map_.end()) {
       scroll_content()->RemoveChildView(view_and_address.first);
     }
   }

   scroll_content()->InvalidateLayout();

   Layout();
 }

 void BluetoothDetailedView::SetToggleIsOn(bool is_on) {
   if (toggle_)
     toggle_->AnimateIsOn(is_on);
 }

 const char* BluetoothDetailedView::GetClassName() const {
   return "BluetoothDetailedView";
 }

 void BluetoothDetailedView::CreateItems() {
   CreateScrollableList();
   scroll_content()->SetID(kScrollContentID);
   CreateTitleRow(IDS_ASH_STATUS_TRAY_BLUETOOTH);
 }

 TriView* BluetoothDetailedView::AddSubHeading(int text_id,
                                               TriView* sub_heading_view,
                                               int child_index) {
   if (!sub_heading_view) {
     sub_heading_view = AddScrollListSubHeader(text_id);
   }
   scroll_content()->ReorderChildView(sub_heading_view, child_index);
   return sub_heading_view;
 }

 int BluetoothDetailedView::AddSameTypeDevicesToScrollList(
     const BluetoothDeviceList& list,
     const std::unordered_map<HoverHighlightView*, BluetoothAddress>&
         old_device_list,
     int child_index,
     bool highlight,
     bool checked) {
   for (const auto& device : list) {
     const gfx::VectorIcon& icon =
         GetBluetoothDeviceIcon(device->device_type, device->connection_state);
     std::u16string device_name =
         device::GetBluetoothDeviceNameForDisplay(device);
     HoverHighlightView* container =
         GetScrollListItemForDevice(old_device_list, device->address);
     if (!container) {
       container = AddScrollListItem(icon, device_name);
     } else {
       container->text_label()->SetText(device_name);
       container->left_icon()->SetImage(gfx::CreateVectorIcon(
           icon, AshColorProvider::Get()->GetContentLayerColor(
                     AshColorProvider::ContentLayerType::kIconColorPrimary)));
     }
     container->SetAccessibleName(
         device::GetBluetoothDeviceLabelForAccessibility(device));
     switch (device->connection_state) {
       case BluetoothDeviceInfo::ConnectionState::kNotConnected:
         break;
       case BluetoothDeviceInfo::ConnectionState::kConnecting:
         SetupConnectingScrollListItem(container);
         break;
       case BluetoothDeviceInfo::ConnectionState::kConnected:
         SetupConnectedScrollListItem(
             container, device->battery_info
                            ? base::make_optional<uint8_t>(
                                  device->battery_info->battery_percentage)
                            : base::nullopt);
         break;
     }
     scroll_content()->ReorderChildView(container, child_index++);
     device_map_[container] = device->address;
   }
   return child_index;
 }

 bool BluetoothDetailedView::FoundDevice(
     const BluetoothAddress& device_address,
     const BluetoothDeviceList& device_list) const {
   for (const auto& device : device_list) {
     if (device->address == device_address)
       return true;
   }
   return false;
 }

 void BluetoothDetailedView::UpdateClickedDevice(
     const BluetoothAddress& device_address,
     HoverHighlightView* item_container) {
   if (FoundDevice(device_address, paired_not_connected_devices_)) {
     SetupConnectingScrollListItem(item_container);
     scroll_content()->SizeToPreferredSize();
     scroller()->Layout();
   }
 }

 void BluetoothDetailedView::ToggleButtonPressed() {
   Shell::Get()->tray_bluetooth_helper()->SetBluetoothEnabled(
       toggle_->GetIsOn());
 }

 void BluetoothDetailedView::ShowSettings() {
   if (TrayPopupUtils::CanOpenWebUISettings()) {
     CloseBubble();  // Deletes |this|.
     Shell::Get()->system_tray_model()->client()->ShowBluetoothSettings();
   }
 }

 base::Optional<BluetoothAddress>
 BluetoothDetailedView::GetFocusedDeviceAddress() const {
   for (const auto& view_and_address : device_map_) {
     if (view_and_address.first->HasFocus())
       return view_and_address.second;
   }
   return base::nullopt;
 }

 void BluetoothDetailedView::FocusDeviceByAddress(
     const BluetoothAddress& address) const {
   for (auto& view_and_address : device_map_) {
     if (view_and_address.second == address) {
       view_and_address.first->RequestFocus();
       return;
     }
   }
 }

 void BluetoothDetailedView::HandleViewClicked(views::View* view) {
   TrayBluetoothHelper* helper = Shell::Get()->tray_bluetooth_helper();
   if (helper->GetBluetoothState() != BluetoothSystem::State::kPoweredOn)
     return;

   HoverHighlightView* container = static_cast<HoverHighlightView*>(view);
   std::unordered_map<HoverHighlightView*, BluetoothAddress>::iterator find;
   find = device_map_.find(container);
   if (find == device_map_.end())
     return;

   const BluetoothAddress& device_address = find->second;
   if (FoundDevice(device_address, connecting_devices_))
     return;

   UpdateClickedDevice(device_address, container);
   LogUserBluetoothEvent(device_address);
   helper->ConnectToBluetoothDevice(device_address);
 }

 void BluetoothDetailedView::CreateExtraTitleRowButtons() {
   if (login_ == LoginStatus::LOCKED)
     return;

   DCHECK(!toggle_);
   DCHECK(!settings_);

   tri_view()->SetContainerVisible(TriView::Container::END, true);

   toggle_ = TrayPopupUtils::CreateToggleButton(
       base::BindRepeating(&BluetoothDetailedView::ToggleButtonPressed,
                           base::Unretained(this)),
       IDS_ASH_STATUS_TRAY_BLUETOOTH);
   toggle_->SetIsOn(Shell::Get()->tray_bluetooth_helper()->GetBluetoothState() ==
                    BluetoothSystem::State::kPoweredOn);
   tri_view()->AddView(TriView::Container::END, toggle_);

   settings_ = CreateSettingsButton(
       base::BindRepeating(&BluetoothDetailedView::ShowSettings,
                           base::Unretained(this)),
       IDS_ASH_STATUS_TRAY_BLUETOOTH_SETTINGS);
   tri_view()->AddView(TriView::Container::END, settings_);
 }

 }  // namespace tray
 }  // namespace ash
	// Copyright 2018 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "ash/system/bluetooth/bluetooth_detailed_view.h"

	#include <memory>
	#include <string>
	#include <unordered_map>
	#include <utility>

	#include "ash/public/cpp/system_tray_client.h"
	#include "ash/resources/vector_icons/vector_icons.h"
	#include "ash/shell.h"
	#include "ash/strings/grit/ash_strings.h"
	#include "ash/style/ash_color_provider.h"
	#include "ash/system/machine_learning/user_settings_event_logger.h"
	#include "ash/system/model/system_tray_model.h"
	#include "ash/system/tray/hover_highlight_view.h"
	#include "ash/system/tray/tray_info_label.h"
	#include "ash/system/tray/tray_popup_utils.h"
	#include "base/strings/string16.h"
	#include "base/strings/utf_string_conversions.h"
	#include "services/device/public/cpp/bluetooth/bluetooth_utils.h"
	#include "ui/base/l10n/l10n_util.h"
	#include "ui/gfx/paint_vector_icon.h"
	#include "ui/views/controls/button/toggle_button.h"
	#include "ui/views/controls/image_view.h"
	#include "ui/views/controls/scroll_view.h"
	#include "ui/views/layout/box_layout.h"

	using device::mojom::BluetoothDeviceInfo;
	using device::mojom::BluetoothSystem;

	namespace ash {
	namespace tray {
	namespace {

	const int kDisabledPanelLabelBaselineY = 20;

	// Returns corresponding device type icons for given Bluetooth device types and
	// connection states.
	const gfx::VectorIcon& GetBluetoothDeviceIcon(
	BluetoothDeviceInfo::DeviceType device_type,
	BluetoothDeviceInfo::ConnectionState connection_state) {
	switch (device_type) {
	case BluetoothDeviceInfo::DeviceType::kComputer:
	return ash::kSystemMenuComputerIcon;
	case BluetoothDeviceInfo::DeviceType::kPhone:
	return ash::kSystemMenuPhoneIcon;
	case BluetoothDeviceInfo::DeviceType::kAudio:
	case BluetoothDeviceInfo::DeviceType::kCarAudio:
	return ash::kSystemMenuHeadsetIcon;
	case BluetoothDeviceInfo::DeviceType::kVideo:
	return ash::kSystemMenuVideocamIcon;
	case BluetoothDeviceInfo::DeviceType::kJoystick:
	case BluetoothDeviceInfo::DeviceType::kGamepad:
	return ash::kSystemMenuGamepadIcon;
	case BluetoothDeviceInfo::DeviceType::kKeyboard:
	case BluetoothDeviceInfo::DeviceType::kKeyboardMouseCombo:
	return ash::kSystemMenuKeyboardIcon;
	case BluetoothDeviceInfo::DeviceType::kTablet:
	return ash::kSystemMenuTabletIcon;
	case BluetoothDeviceInfo::DeviceType::kMouse:
	return ash::kSystemMenuMouseIcon;
	case BluetoothDeviceInfo::DeviceType::kModem:
	case BluetoothDeviceInfo::DeviceType::kPeripheral:
	return ash::kSystemMenuBluetoothIcon;
	default:
	return connection_state ==
	BluetoothDeviceInfo::ConnectionState::kConnected
	? ash::kSystemMenuBluetoothConnectedIcon
	: ash::kSystemMenuBluetoothIcon;
	}
	}

	views::View* CreateDisabledPanel() {
	views::View* container = new views::View;
	auto box_layout = std::make_unique<views::BoxLayout>(
	views::BoxLayout::Orientation::kVertical);
	box_layout->set_main_axis_alignment(
	views::BoxLayout::MainAxisAlignment::kCenter);
	container->SetLayoutManager(std::move(box_layout));

	auto* color_provider = AshColorProvider::Get();
	auto* image_view =
	container->AddChildView(std::make_unique<views::ImageView>());
	image_view->SetImage(gfx::CreateVectorIcon(
	kSystemMenuBluetoothDisabledIcon,
	AshColorProvider::GetDisabledColor(color_provider->GetContentLayerColor(
	AshColorProvider::ContentLayerType::kIconColorPrimary))));
	image_view->SetVerticalAlignment(views::ImageView::Alignment::kTrailing);

	auto* label = container->AddChildView(std::make_unique<views::Label>(
	l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_BLUETOOTH_DISABLED)));
	label->SetEnabledColor(
	AshColorProvider::GetDisabledColor(color_provider->GetContentLayerColor(
	AshColorProvider::ContentLayerType::kTextColorPrimary)));
	TrayPopupUtils::SetLabelFontList(
	label, TrayPopupUtils::FontStyle::kDetailedViewLabel);
	label->SetBorder(views::CreateEmptyBorder(
	kDisabledPanelLabelBaselineY - label->GetBaseline(), 0, 0, 0));

	// Make top padding of the icon equal to the height of the label so that the
	// icon is vertically aligned to center of the container.
	image_view->SetBorder(
	views::CreateEmptyBorder(label->GetPreferredSize().height(), 0, 0, 0));
	return container;
	}

	void LogUserBluetoothEvent(const BluetoothAddress& device_address) {
	ml::UserSettingsEventLogger* logger = ml::UserSettingsEventLogger::Get();
	if (logger) {
	logger->LogBluetoothUkmEvent(device_address);
	}
	}

	HoverHighlightView* GetScrollListItemForDevice(
	const std::unordered_map<HoverHighlightView*, BluetoothAddress>& device_map,
	const BluetoothAddress& address) {
	for (const auto& view_and_address : device_map) {
	if (view_and_address.second == address)
	return view_and_address.first;
	}
	return nullptr;
	}

	} // namespace

	BluetoothDetailedView::BluetoothDetailedView(DetailedViewDelegate* delegate,
	LoginStatus login)
	: TrayDetailedView(delegate), login_(login) {
	CreateItems();
	}

	BluetoothDetailedView::~BluetoothDetailedView() = default;

	void BluetoothDetailedView::ShowLoadingIndicator() {
	// Setting a value of -1 gives progress_bar an infinite-loading behavior.
	ShowProgress(-1, true);
	}

	void BluetoothDetailedView::HideLoadingIndicator() {
	ShowProgress(0, false);
	}

	void BluetoothDetailedView::ShowBluetoothDisabledPanel() {
	device_map_.clear();
	paired_devices_heading_ = nullptr;
	unpaired_devices_heading_ = nullptr;
	bluetooth_discovering_label_ = nullptr;
	scroll_content()->RemoveAllChildViews(true);

	DCHECK(scroller());
	if (!disabled_panel_) {
	disabled_panel_ = CreateDisabledPanel();
	// Insert \|disabled_panel_\| before the scroller, since the scroller will
	// have unnecessary bottom border when it is not the last child.
	AddChildViewAt(disabled_panel_, GetIndexOf(scroller()));
	// \|disabled_panel_\| need to fill the remaining space below the title row
	// so that the inner contents of \|disabled_panel_\| are placed properly.
	box_layout()->SetFlexForView(disabled_panel_, 1);
	}

	disabled_panel_->SetVisible(true);
	scroller()->SetVisible(false);

	Layout();
	}

	void BluetoothDetailedView::HideBluetoothDisabledPanel() {
	DCHECK(scroller());
	if (disabled_panel_)
	disabled_panel_->SetVisible(false);
	scroller()->SetVisible(true);

	Layout();
	}

	bool BluetoothDetailedView::IsDeviceScrollListEmpty() const {
	return device_map_.empty();
	}

	void BluetoothDetailedView::UpdateDeviceScrollList(
	const BluetoothDeviceList& connected_devices,
	const BluetoothDeviceList& connecting_devices,
	const BluetoothDeviceList& paired_not_connected_devices,
	const BluetoothDeviceList& discovered_not_paired_devices) {
	connecting_devices_.clear();
	for (const auto& device : connecting_devices)
	connecting_devices_.push_back(device->Clone());

	paired_not_connected_devices_.clear();
	for (const auto& device : paired_not_connected_devices)
	paired_not_connected_devices_.push_back(device->Clone());

	// Keep track of previous device_map_ so that existing scroll list
	// item views can be re-used. This is required for a11y so that
	// keyboard focus and screen-reader call outs are not disrupted
	// by frequent device list updates.
	std::unordered_map<HoverHighlightView*, BluetoothAddress> old_device_map =
	device_map_;
	device_map_.clear();

	// Add paired devices and their section header to the list.
	bool has_paired_devices = !connected_devices.empty() \|\|
	!connecting_devices.empty() \|\|
	!paired_not_connected_devices.empty();
	int index = 0;
	if (has_paired_devices) {
	paired_devices_heading_ =
	AddSubHeading(IDS_ASH_STATUS_TRAY_BLUETOOTH_PAIRED_DEVICES,
	paired_devices_heading_, index++);
	index = AddSameTypeDevicesToScrollList(connected_devices, old_device_map,
	index, true, true);
	index = AddSameTypeDevicesToScrollList(connecting_devices, old_device_map,
	index, true, false);
	index = AddSameTypeDevicesToScrollList(paired_not_connected_devices,
	old_device_map, index, false, false);
	} else if (paired_devices_heading_) {
	scroll_content()->RemoveChildView(paired_devices_heading_);
	paired_devices_heading_ = nullptr;
	}

	// Add unpaired devices to the list. If at least one paired device is
	// present, also add a section header above the unpaired devices.
	if (!discovered_not_paired_devices.empty()) {
	if (has_paired_devices) {
	unpaired_devices_heading_ =
	AddSubHeading(IDS_ASH_STATUS_TRAY_BLUETOOTH_UNPAIRED_DEVICES,
	unpaired_devices_heading_, index++);
	}
	index = AddSameTypeDevicesToScrollList(discovered_not_paired_devices,
	old_device_map, index, false, false);
	}

	if (unpaired_devices_heading_ &&
	(discovered_not_paired_devices.empty() \|\| !has_paired_devices)) {
	scroll_content()->RemoveChildView(unpaired_devices_heading_);
	unpaired_devices_heading_ = nullptr;
	}

	// Show user Bluetooth state if there is no bluetooth devices in list.
	if (device_map_.empty()) {
	if (!bluetooth_discovering_label_) {
	bluetooth_discovering_label_ =
	new TrayInfoLabel(IDS_ASH_STATUS_TRAY_BLUETOOTH_DISCOVERING);
	scroll_content()->AddChildViewAt(bluetooth_discovering_label_, index++);
	} else {
	scroll_content()->ReorderChildView(bluetooth_discovering_label_, index++);
	}
	} else if (bluetooth_discovering_label_) {
	scroll_content()->RemoveChildView(bluetooth_discovering_label_);
	bluetooth_discovering_label_ = nullptr;
	}

	// Remove views for devices from old_device_map that are not in device_map_.
	for (auto& view_and_address : old_device_map) {
	if (device_map_.find(view_and_address.first) == device_map_.end()) {
	scroll_content()->RemoveChildView(view_and_address.first);
	}
	}

	scroll_content()->InvalidateLayout();

	Layout();
	}

	void BluetoothDetailedView::SetToggleIsOn(bool is_on) {
	if (toggle_)
	toggle_->AnimateIsOn(is_on);
	}

	const char* BluetoothDetailedView::GetClassName() const {
	return "BluetoothDetailedView";
	}

	void BluetoothDetailedView::CreateItems() {
	CreateScrollableList();
	scroll_content()->SetID(kScrollContentID);
	CreateTitleRow(IDS_ASH_STATUS_TRAY_BLUETOOTH);
	}

	TriView* BluetoothDetailedView::AddSubHeading(int text_id,
	TriView* sub_heading_view,
	int child_index) {
	if (!sub_heading_view) {
	sub_heading_view = AddScrollListSubHeader(text_id);
	}
	scroll_content()->ReorderChildView(sub_heading_view, child_index);
	return sub_heading_view;
	}

	int BluetoothDetailedView::AddSameTypeDevicesToScrollList(
	const BluetoothDeviceList& list,
	const std::unordered_map<HoverHighlightView*, BluetoothAddress>&
	old_device_list,
	int child_index,
	bool highlight,
	bool checked) {
	for (const auto& device : list) {
	const gfx::VectorIcon& icon =
	GetBluetoothDeviceIcon(device->device_type, device->connection_state);
	std::u16string device_name =
	device::GetBluetoothDeviceNameForDisplay(device);
	HoverHighlightView* container =
	GetScrollListItemForDevice(old_device_list, device->address);
	if (!container) {
	container = AddScrollListItem(icon, device_name);
	} else {
	container->text_label()->SetText(device_name);
	container->left_icon()->SetImage(gfx::CreateVectorIcon(
	icon, AshColorProvider::Get()->GetContentLayerColor(
	AshColorProvider::ContentLayerType::kIconColorPrimary)));
	}
	container->SetAccessibleName(
	device::GetBluetoothDeviceLabelForAccessibility(device));
	switch (device->connection_state) {
	case BluetoothDeviceInfo::ConnectionState::kNotConnected:
	break;
	case BluetoothDeviceInfo::ConnectionState::kConnecting:
	SetupConnectingScrollListItem(container);
	break;
	case BluetoothDeviceInfo::ConnectionState::kConnected:
	SetupConnectedScrollListItem(
	container, device->battery_info
	? base::make_optional<uint8_t>(
	device->battery_info->battery_percentage)
	: base::nullopt);
	break;
	}
	scroll_content()->ReorderChildView(container, child_index++);
	device_map_[container] = device->address;
	}
	return child_index;
	}

	bool BluetoothDetailedView::FoundDevice(
	const BluetoothAddress& device_address,
	const BluetoothDeviceList& device_list) const {
	for (const auto& device : device_list) {
	if (device->address == device_address)
	return true;
	}
	return false;
	}

	void BluetoothDetailedView::UpdateClickedDevice(
	const BluetoothAddress& device_address,
	HoverHighlightView* item_container) {
	if (FoundDevice(device_address, paired_not_connected_devices_)) {
	SetupConnectingScrollListItem(item_container);
	scroll_content()->SizeToPreferredSize();
	scroller()->Layout();
	}
	}

	void BluetoothDetailedView::ToggleButtonPressed() {
	Shell::Get()->tray_bluetooth_helper()->SetBluetoothEnabled(
	toggle_->GetIsOn());
	}

	void BluetoothDetailedView::ShowSettings() {
	if (TrayPopupUtils::CanOpenWebUISettings()) {
	CloseBubble(); // Deletes \|this\|.
	Shell::Get()->system_tray_model()->client()->ShowBluetoothSettings();
	}
	}

	base::Optional<BluetoothAddress>
	BluetoothDetailedView::GetFocusedDeviceAddress() const {
	for (const auto& view_and_address : device_map_) {
	if (view_and_address.first->HasFocus())
	return view_and_address.second;
	}
	return base::nullopt;
	}

	void BluetoothDetailedView::FocusDeviceByAddress(
	const BluetoothAddress& address) const {
	for (auto& view_and_address : device_map_) {
	if (view_and_address.second == address) {
	view_and_address.first->RequestFocus();
	return;
	}
	}
	}

	void BluetoothDetailedView::HandleViewClicked(views::View* view) {
	TrayBluetoothHelper* helper = Shell::Get()->tray_bluetooth_helper();
	if (helper->GetBluetoothState() != BluetoothSystem::State::kPoweredOn)
	return;

	HoverHighlightView* container = static_cast<HoverHighlightView*>(view);
	std::unordered_map<HoverHighlightView*, BluetoothAddress>::iterator find;
	find = device_map_.find(container);
	if (find == device_map_.end())
	return;

	const BluetoothAddress& device_address = find->second;
	if (FoundDevice(device_address, connecting_devices_))
	return;

	UpdateClickedDevice(device_address, container);
	LogUserBluetoothEvent(device_address);
	helper->ConnectToBluetoothDevice(device_address);
	}

	void BluetoothDetailedView::CreateExtraTitleRowButtons() {
	if (login_ == LoginStatus::LOCKED)
	return;

	DCHECK(!toggle_);
	DCHECK(!settings_);

	tri_view()->SetContainerVisible(TriView::Container::END, true);

	toggle_ = TrayPopupUtils::CreateToggleButton(
	base::BindRepeating(&BluetoothDetailedView::ToggleButtonPressed,
	base::Unretained(this)),
	IDS_ASH_STATUS_TRAY_BLUETOOTH);
	toggle_->SetIsOn(Shell::Get()->tray_bluetooth_helper()->GetBluetoothState() ==
	BluetoothSystem::State::kPoweredOn);
	tri_view()->AddView(TriView::Container::END, toggle_);

	settings_ = CreateSettingsButton(
	base::BindRepeating(&BluetoothDetailedView::ShowSettings,
	base::Unretained(this)),
	IDS_ASH_STATUS_TRAY_BLUETOOTH_SETTINGS);
	tri_view()->AddView(TriView::Container::END, settings_);
	}

	} // namespace tray
	} // namespace ash