1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103

ash / system / input_device_settings / input_device_settings_metadata_manager.cc [blame]

// Copyright 2024 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/input_device_settings/input_device_settings_metadata_manager.h"

#include "ash/system/input_device_settings/input_device_settings_metadata.h"
#include "ash/system/input_device_settings/input_device_settings_pref_names.h"
#include "base/containers/contains.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/scoped_user_pref_update.h"

namespace ash {

namespace {

std::string GenerateImageRequestKey(const std::string& key,
                                    DeviceImageDestination destination) {
  return key + "_" + base::NumberToString(static_cast<int>(destination));
}

}  // namespace

InputDeviceSettingsMetadataManager::InputDeviceSettingsMetadataManager(
    std::unique_ptr<DeviceImageDownloader> image_downloader,
    std::unique_ptr<DeviceImageStorage> image_storage)
    : image_downloader_(std::move(image_downloader)),
      device_image_storage_(std::move(image_storage)) {}

InputDeviceSettingsMetadataManager::InputDeviceSettingsMetadataManager()
    : InputDeviceSettingsMetadataManager(
          std::make_unique<DeviceImageDownloader>(),
          std::make_unique<DeviceImageStorage>()) {}

InputDeviceSettingsMetadataManager::~InputDeviceSettingsMetadataManager() =
    default;

// static
void InputDeviceSettingsMetadataManager::RegisterLocalStatePrefs(
    PrefRegistrySimple* registry) {
  registry->RegisterDictionaryPref(prefs::kDeviceImagesDictPref);
}

void InputDeviceSettingsMetadataManager::GetDeviceImage(
    const std::string& device_key,
    const AccountId& account_id,
    DeviceImageDestination destination,
    ImageDownloadCallback callback) {
  GetDeviceImagePreferringCache(device_key, account_id, destination,
                                std::move(callback));
}

void InputDeviceSettingsMetadataManager::OnDeviceImageFetched(
    DeviceImageDestination destination,
    const DeviceImage& device_image) {
  const auto device_key = device_image.device_key();
  // Check if the device image is specifically for settings and is a valid
  // image.
  if (destination == DeviceImageDestination::kSettings &&
      device_image.IsValid()) {
    // Save the device image data (represented as a data URL) to persistent
    // storage, using the device_key as a unique identifier.
    device_image_storage_->PersistDeviceImage(device_key,
                                              device_image.data_url());
  }
  auto it = device_callback_map_.find(
      GenerateImageRequestKey(device_key, destination));

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

  for (auto& callback : it->second) {
    std::move(callback).Run(device_image);
  }
  device_callback_map_.erase(it);
}

std::optional<std::string>
InputDeviceSettingsMetadataManager::GetCachedDeviceImageDataUri(
    const std::string& device_key) {
  return device_image_storage_->GetImage(device_key);
}

void InputDeviceSettingsMetadataManager::GetDeviceImagePreferringCache(
    const std::string& device_key,
    const AccountId& account_id,
    DeviceImageDestination destination,
    ImageDownloadCallback callback) {
  const auto device_image = device_image_storage_->GetImage(device_key);
  if (device_image.has_value()) {
    std::move(callback).Run(DeviceImage(device_key, device_image.value()));
    return;
  }
  device_callback_map_[GenerateImageRequestKey(device_key, destination)]
      .push_back(std::move(callback));
  image_downloader_->DownloadImage(
      device_key, account_id, destination,
      base::BindOnce(&InputDeviceSettingsMetadataManager::OnDeviceImageFetched,
                     weak_ptr_factory_.GetWeakPtr(), destination));
}

}  // namespace ash