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


ash / system / input_device_settings / input_device_settings_metadata_manager.h [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.

#ifndef ASH_SYSTEM_INPUT_DEVICE_SETTINGS_INPUT_DEVICE_SETTINGS_METADATA_MANAGER_H_
#define ASH_SYSTEM_INPUT_DEVICE_SETTINGS_INPUT_DEVICE_SETTINGS_METADATA_MANAGER_H_

#include <memory>
#include <optional>

#include "ash/ash_export.h"
#include "ash/system/input_device_settings/device_image.h"
#include "ash/system/input_device_settings/device_image_downloader.h"
#include "ash/system/input_device_settings/device_image_storage.h"
#include "base/containers/flat_map.h"
#include "base/functional/callback.h"
#include "base/memory/weak_ptr.h"
#include "components/account_id/account_id.h"

class PrefRegistrySimple;

namespace ash {

enum class DeviceImageDestination;

// Handles input device metadata (images, app info) and updates components on
// changes.
class ASH_EXPORT InputDeviceSettingsMetadataManager {
 public:
  using ImageDownloadCallback =
      base::OnceCallback<void(const DeviceImage& image)>;

  InputDeviceSettingsMetadataManager();
  InputDeviceSettingsMetadataManager(
      std::unique_ptr<DeviceImageDownloader> image_downloader,
      std::unique_ptr<DeviceImageStorage> image_storage);
  InputDeviceSettingsMetadataManager(
      const InputDeviceSettingsMetadataManager&) = delete;
  InputDeviceSettingsMetadataManager& operator=(
      const InputDeviceSettingsMetadataManager&) = delete;
  ~InputDeviceSettingsMetadataManager();

  // Gets the image associated with the input device specified by
  // `device_key`. Initiates a download for the image using the
  // ImageDownloader.
  void GetDeviceImage(const std::string& device_key,
                      const AccountId& account_id,
                      DeviceImageDestination destination,
                      ImageDownloadCallback callback);
  // Retrieves the image data URI for the input device if it exists.
  std::optional<std::string> GetCachedDeviceImageDataUri(
      const std::string& device_key);

  const base::flat_map<std::string, std::vector<ImageDownloadCallback>>&
  GetDeviceCallbackMapForTesting() {
    return device_callback_map_;
  }

  static void RegisterLocalStatePrefs(PrefRegistrySimple* registry);

 private:
  // Callback function called when a device image is fetched by the downloader.
  // Handles storing the image and notifying any pending callbacks.
  void OnDeviceImageFetched(DeviceImageDestination destination,
                            const DeviceImage& device_image);
  // Attempts to load the device image from disk before making a network
  // request to download the device image.
  void GetDeviceImagePreferringCache(const std::string& device_key,
                                     const AccountId& account_id,
                                     DeviceImageDestination destination,
                                     ImageDownloadCallback callback);

  std::unique_ptr<DeviceImageDownloader> image_downloader_;
  std::unique_ptr<DeviceImageStorage> device_image_storage_;
  // Tracks image download requests for input devices. Maps a device's unique
  // key to the callback that should be executed when the image is downloaded.
  base::flat_map<std::string, std::vector<ImageDownloadCallback>>
      device_callback_map_;
  base::WeakPtrFactory<InputDeviceSettingsMetadataManager> weak_ptr_factory_{
      this};
};

}  // namespace ash

#endif  // ASH_SYSTEM_INPUT_DEVICE_SETTINGS_INPUT_DEVICE_SETTINGS_METADATA_MANAGER_H_