ash / system / power / peripheral_battery_notifier.cc [blame]

// Copyright 2013 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/power/peripheral_battery_notifier.h"

#include <string>
#include <vector>

#include "ash/constants/ash_features.h"
#include "ash/constants/notifier_catalogs.h"
#include "ash/power/hid_battery_util.h"
#include "ash/public/cpp/notification_utils.h"
#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/system/model/system_tray_model.h"
#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/time.h"
#include "components/device_event_log/device_event_log.h"
#include "device/bluetooth/bluetooth_adapter_factory.h"
#include "device/bluetooth/bluetooth_device.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/events/devices/device_data_manager.h"
#include "ui/events/devices/touchscreen_device.h"
#include "ui/gfx/image/image.h"
#include "ui/message_center/message_center.h"
#include "ui/message_center/public/cpp/notification.h"
#include "ui/message_center/public/cpp/notification_delegate.h"

namespace ash {

namespace {

// When a peripheral device's battery level is <= kLowBatteryLevel, consider
// it to be in low battery condition.
const uint8_t kLowBatteryLevel = 16;

// Don't show 2 low battery notification within |kNotificationInterval|.
constexpr base::TimeDelta kNotificationInterval = base::Seconds(60);

constexpr char kNotifierStylusBattery[] = "ash.stylus-battery";

constexpr char kNotificationOriginUrl[] = "chrome://peripheral-battery";
constexpr char kNotifierNonStylusBattery[] = "power.peripheral-battery";

// Prefix added to the key of a device to generate a unique ID when posting
// a notification to the Message Center.
constexpr char kPeripheralDeviceIdPrefix[] = "battery_notification-";

// Struct containing parameters for the notification which vary between the
// stylus notifications and the non stylus notifications.
struct NotificationParams {
  std::string id;
  std::u16string title;
  std::u16string message;
  std::string notifier_name;
  GURL url;
  raw_ptr<const gfx::VectorIcon> icon;
};

NotificationParams GetNonStylusNotificationParams(const std::string& map_key,
                                                  const std::u16string& name,
                                                  uint8_t battery_level,
                                                  bool is_bluetooth) {
  return NotificationParams{
      kPeripheralDeviceIdPrefix + map_key,
      name,
      l10n_util::GetStringFUTF16Int(
          IDS_ASH_LOW_PERIPHERAL_BATTERY_NOTIFICATION_TEXT, battery_level),
      kNotifierNonStylusBattery,
      GURL(kNotificationOriginUrl),
      is_bluetooth ? &kNotificationBluetoothBatteryWarningIcon
                   : &kNotificationBatteryCriticalIcon};
}

NotificationParams GetStylusNotificationParams() {
  return NotificationParams{
      PeripheralBatteryNotifier::kStylusNotificationId,
      l10n_util::GetStringUTF16(IDS_ASH_LOW_STYLUS_BATTERY_NOTIFICATION_TITLE),
      l10n_util::GetStringUTF16(IDS_ASH_LOW_STYLUS_BATTERY_NOTIFICATION_BODY),
      kNotifierStylusBattery,
      GURL(),
      &kNotificationStylusBatteryWarningIcon};
}

}  // namespace

const char PeripheralBatteryNotifier::kStylusNotificationId[] =
    "stylus-battery";

PeripheralBatteryNotifier::NotificationInfo::NotificationInfo() = default;

PeripheralBatteryNotifier::NotificationInfo::NotificationInfo(
    std::optional<uint8_t> level,
    base::TimeTicks last_notification_timestamp)
    : level(level),
      last_notification_timestamp(last_notification_timestamp),
      ever_notified(false) {}

PeripheralBatteryNotifier::NotificationInfo::~NotificationInfo() = default;

PeripheralBatteryNotifier::NotificationInfo::NotificationInfo(
    const NotificationInfo& info) {
  level = info.level;
  last_notification_timestamp = info.last_notification_timestamp;
  ever_notified = info.ever_notified;
}

PeripheralBatteryNotifier::PeripheralBatteryNotifier(
    PeripheralBatteryListener* listener)
    : peripheral_battery_listener_(listener) {
  peripheral_battery_listener_->AddObserver(this);
}

PeripheralBatteryNotifier::~PeripheralBatteryNotifier() {
  peripheral_battery_listener_->RemoveObserver(this);
}

void PeripheralBatteryNotifier::OnUpdatedBatteryLevel(
    const PeripheralBatteryListener::BatteryInfo& battery_info) {
  // TODO(b/187703348): it is worth listening to charger events if they
  // might remove the notification: we want to clear it as soon as
  // we believe the battery to have been charged, or at least starting
  // charging.
  if (battery_info.type == PeripheralBatteryListener::BatteryInfo::
                               PeripheralType::kStylusViaCharger) {
    return;
  }
  UpdateBattery(battery_info);
}

void PeripheralBatteryNotifier::OnAddingBattery(
    const PeripheralBatteryListener::BatteryInfo& battery) {}

void PeripheralBatteryNotifier::OnRemovingBattery(
    const PeripheralBatteryListener::BatteryInfo& battery_info) {
  const std::string& map_key = battery_info.key;
  CancelNotification(battery_info);
  battery_notifications_.erase(map_key);
  BLUETOOTH_LOG(EVENT)
      << "Battery has been removed, erasing notification, battery key: "
      << map_key;
}

void PeripheralBatteryNotifier::UpdateBattery(
    const PeripheralBatteryListener::BatteryInfo& battery_info) {
  if (!battery_info.level || !battery_info.battery_report_eligible) {
    CancelNotification(battery_info);
    return;
  }

  const std::string& map_key = battery_info.key;
  bool was_old_battery_level_low = false;
  auto it = battery_notifications_.find(map_key);

  if (it == battery_notifications_.end()) {
    NotificationInfo new_notification_info;
    new_notification_info.level = battery_info.level;
    new_notification_info.last_notification_timestamp =
        battery_info.last_update_timestamp;
    new_notification_info.ever_notified = false;
    battery_notifications_[map_key] = new_notification_info;
  } else {
    NotificationInfo& existing_notification_info = it->second;
    std::optional<uint8_t> old_level = existing_notification_info.level;
    was_old_battery_level_low = old_level && *old_level <= kLowBatteryLevel;
    existing_notification_info.level = battery_info.level;

    BLUETOOTH_LOG(EVENT)
        << "Battery level updated, battery key: " << map_key
        << " new battery level: "
        << (battery_info.level.has_value()
                ? base::NumberToString(battery_info.level.value())
                : "empty value")
        << " old battery level: "
        << (old_level.has_value() ? base::NumberToString(old_level.value())
                                  : "empty value")
        << " battery type: " << static_cast<int>(battery_info.type);
  }

  if (*battery_info.level > kLowBatteryLevel) {
    CancelNotification(battery_info);
    return;
  }

  // If low battery was on record, check if there is a notification, otherwise
  // the user dismissed it and we shouldn't create another one.
  if (was_old_battery_level_low)
    UpdateBatteryNotificationIfVisible(battery_info);
  else
    ShowNotification(battery_info);
}

void PeripheralBatteryNotifier::UpdateBatteryNotificationIfVisible(
    const PeripheralBatteryListener::BatteryInfo& battery_info) {
  const std::string& map_key = battery_info.key;
  std::string notification_map_key =
      (battery_info.type ==
       PeripheralBatteryListener::BatteryInfo::PeripheralType::kStylusViaScreen)
          ? kStylusNotificationId
          : (kPeripheralDeviceIdPrefix + map_key);
  message_center::Notification* notification =
      message_center::MessageCenter::Get()->FindVisibleNotificationById(
          notification_map_key);
  if (notification)
    ShowOrUpdateNotification(battery_info);
}

void PeripheralBatteryNotifier::ShowNotification(
    const PeripheralBatteryListener::BatteryInfo& battery_info) {
  const std::string& map_key = battery_info.key;
  NotificationInfo& notification_info = battery_notifications_[map_key];
  base::TimeTicks now = base::TimeTicks::Now();
  if (!notification_info.ever_notified ||
      (now - notification_info.last_notification_timestamp >=
       kNotificationInterval)) {
    ShowOrUpdateNotification(battery_info);
    notification_info.last_notification_timestamp = base::TimeTicks::Now();
    notification_info.ever_notified = true;
  }
}

void PeripheralBatteryNotifier::ShowOrUpdateNotification(
    const PeripheralBatteryListener::BatteryInfo& battery_info) {
  const std::string& map_key = battery_info.key;

  BLUETOOTH_LOG(EVENT)
      << "Battery notification shown or updated, battery key: " << map_key
      << " battery level: "
      << (battery_info.level.has_value()
              ? base::NumberToString(battery_info.level.value())
              : "empty value")
      << " battery type: " << static_cast<int>(battery_info.type);

  // Stylus battery notifications differ slightly.
  NotificationParams params =
      (battery_info.type ==
       PeripheralBatteryListener::BatteryInfo::PeripheralType::kStylusViaScreen)
          ? GetStylusNotificationParams()
          : GetNonStylusNotificationParams(
                map_key, battery_info.name, *battery_info.level,
                !battery_info.bluetooth_address.empty());

  auto delegate = base::MakeRefCounted<
      message_center::HandleNotificationClickDelegate>(base::BindRepeating(
      [](const NotificationParams& params) {
        Shell::Get()->system_tray_model()->client()->ShowBluetoothSettings();
        message_center::MessageCenter::Get()->RemoveNotification(
            params.id, /*by_user=*/false);
      },
      params));

  auto notification = CreateSystemNotificationPtr(
      message_center::NOTIFICATION_TYPE_SIMPLE, params.id, params.title,
      params.message, std::u16string(), params.url,
      message_center::NotifierId(message_center::NotifierType::SYSTEM_COMPONENT,
                                 params.notifier_name,
                                 NotificationCatalogName::kPeripheralBattery),
      message_center::RichNotificationData(), std::move(delegate), *params.icon,
      message_center::SystemNotificationWarningLevel::WARNING);

  message_center::MessageCenter::Get()->AddNotification(
      std::move(notification));
}

void PeripheralBatteryNotifier::CancelNotification(
    const PeripheralBatteryListener::BatteryInfo& battery_info) {
  const std::string& map_key = battery_info.key;
  const auto it = battery_notifications_.find(map_key);

  if (it == battery_notifications_.end()) {
    return;
  }

  BLUETOOTH_LOG(EVENT)
      << "Battery notification canceled, battery key: " << map_key
      << " battery level: "
      << (battery_info.level.has_value()
              ? base::NumberToString(battery_info.level.value())
              : "empty value")
      << " battery type: " << static_cast<int>(battery_info.type);

  std::string notification_map_key =
      (battery_info.type ==
       PeripheralBatteryListener::BatteryInfo::PeripheralType::kStylusViaScreen)
          ? kStylusNotificationId
          : (kPeripheralDeviceIdPrefix + map_key);

  message_center::MessageCenter::Get()->RemoveNotification(notification_map_key,
                                                           /*by_user=*/false);

  // Resetting this value allows a new low battery level to post a
  // notification if the old one was also under the threshold.
  it->second.level.reset();
}

}  // namespace ash