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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
// Copyright 2021 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_QUICK_PAIR_REPOSITORY_FAST_PAIR_REPOSITORY_H_
#define ASH_QUICK_PAIR_REPOSITORY_FAST_PAIR_REPOSITORY_H_
#include <optional>
#include "ash/quick_pair/common/device.h"
#include "ash/quick_pair/proto/fastpair.pb.h"
#include "ash/quick_pair/repository/fast_pair/device_metadata.h"
#include "ash/quick_pair/repository/fast_pair/pairing_metadata.h"
#include "base/containers/flat_map.h"
#include "base/functional/callback.h"
#include "chromeos/ash/services/bluetooth_config/public/cpp/device_image_info.h"
namespace chromeos {
namespace bluetooth_config {
class DeviceImageInfo;
} // namespace bluetooth_config
} // namespace chromeos
namespace ash {
namespace quick_pair {
class AccountKeyFilter;
using CheckAccountKeysCallback =
base::OnceCallback<void(std::optional<PairingMetadata>)>;
using DeviceMetadataCallback = base::OnceCallback<void(DeviceMetadata*, bool)>;
using ValidModelIdCallback = base::OnceCallback<void(bool)>;
using CheckOptInStatusCallback =
base::OnceCallback<void(nearby::fastpair::OptInStatus)>;
using UpdateOptInStatusCallback = base::OnceCallback<void(bool)>;
using DeleteAssociatedDeviceCallback = base::OnceCallback<void(bool)>;
using DeleteAssociatedDeviceByAccountKeyCallback =
base::OnceCallback<void(bool)>;
using GetSavedDevicesCallback =
base::OnceCallback<void(nearby::fastpair::OptInStatus,
std::vector<nearby::fastpair::FastPairDevice>)>;
using IsDeviceSavedToAccountCallback = base::OnceCallback<void(bool)>;
// The entry point for the Repository component in the Quick Pair system,
// responsible for connecting to back-end services.
class FastPairRepository {
public:
static FastPairRepository* Get();
// Computes and returns the SHA256 of the concatenation of the given
// |account_key| and |mac_address|.
static std::string GenerateSha256OfAccountKeyAndMacAddress(
const std::string& account_key,
const std::string& mac_address);
FastPairRepository();
virtual ~FastPairRepository();
// Returns the DeviceMetadata for a given |hex_model_id| to the provided
// |callback|, if available.
virtual void GetDeviceMetadata(const std::string& hex_model_id,
DeviceMetadataCallback callback) = 0;
// Checks all account keys associated with the user's account against the
// given filter. If a match is found, metadata for the associated device will
// be returned through the callback.
virtual void CheckAccountKeys(const AccountKeyFilter& account_key_filter,
CheckAccountKeysCallback callback) = 0;
// Checks account keys saved to the device registry for a match to
// |account_key|. Return true if a match is found and false otherwise.
virtual bool IsAccountKeyPairedLocally(
const std::vector<uint8_t>& account_key) = 0;
// Stores the given |account_key| for a |device| on the Footprints server.
virtual void WriteAccountAssociationToFootprints(
scoped_refptr<Device> device,
const std::vector<uint8_t>& account_key) = 0;
// Stores the account_key for a |device| locally in the SavedDeviceRegistry,
// skipping the step where we send a request to the server. The account key
// should be stored in the additional data field of the device, fails
// otherwise.
virtual bool WriteAccountAssociationToLocalRegistry(
scoped_refptr<Device> device) = 0;
// Deletes the associated data for device with a given |mac_address|.
// Returns true if a delete will be processed for this device, false
// otherwise.
virtual void DeleteAssociatedDevice(
const std::string& mac_address,
DeleteAssociatedDeviceCallback callback) = 0;
// Updates the display name of the device saved on the Footprints server. The
// function will first check the cache for the device, if the device is not
// found in the cache and |cache_may_be_stale| is set to true, it will trigger
// a server call to refresh the cache.
virtual void UpdateAssociatedDeviceFootprintsName(
const std::string& mac_address,
const std::string& nickname,
bool cache_may_be_stale) = 0;
// Deletes the associated data for a given |account_key|.
// Runs true if a delete is successful for this account key, false
// otherwise on |callback|.
virtual void DeleteAssociatedDeviceByAccountKey(
const std::vector<uint8_t>& account_key,
DeleteAssociatedDeviceByAccountKeyCallback callback) = 0;
// Fetches the |device| images and a record of the device ID -> model ID
// mapping to memory.
virtual void FetchDeviceImages(scoped_refptr<Device> device) = 0;
// Fetches the |device| display_name from the cache, this is only called
// during the subsequent pairing scenario and is called after the account_key
// filter has been matched to an account_key. Therefore the account_key and
// associated display_name should already be in the cache so no need for a
// server call.
virtual std::optional<std::string> GetDeviceDisplayNameFromCache(
std::vector<uint8_t> account_key) = 0;
// Persists the images and device ID belonging to |device| to
// disk, if model ID is not already persisted.
virtual bool PersistDeviceImages(scoped_refptr<Device> device) = 0;
// Evicts the images and mac address record for |mac_address| from
// disk, if model ID is not in use by other mac addresses.
virtual bool EvictDeviceImages(const std::string& mac_address) = 0;
// Returns device images belonging to |mac_address|, if found.
virtual std::optional<bluetooth_config::DeviceImageInfo> GetImagesForDevice(
const std::string& mac_address) = 0;
// Fetches the opt in status from Footprints to determine the status for
// saving a user's devices to their account, which is synced all across a
// user's devices.
virtual void CheckOptInStatus(CheckOptInStatusCallback callback) = 0;
// Updates the opt in status for saving a user's devices to their account,
// synced across all of a user's devices, based on |opt_in_status|.
// If |opt_in_status| reflects the user being opted out, then all devices
// saved to their account are removed. The success or failure of updating
// the opt in status is reflected in running |callback|.
virtual void UpdateOptInStatus(nearby::fastpair::OptInStatus opt_in_status,
UpdateOptInStatusCallback callback) = 0;
// Gets a list of devices saved to the user's account and the user's opt in
// status for saving future devices to their account.
virtual void GetSavedDevices(GetSavedDevicesCallback callback) = 0;
// Checks if a device with an address |mac_address| is already saved to
// the user's account by cross referencing the |mac_address| with any
// associated account keys.
virtual void IsDeviceSavedToAccount(
const std::string& mac_address,
IsDeviceSavedToAccountCallback callback) = 0;
static void SetInstance(FastPairRepository* instance);
static void SetInstanceForTesting(FastPairRepository* instance);
};
} // namespace quick_pair
} // namespace ash
#endif // ASH_QUICK_PAIR_REPOSITORY_FAST_PAIR_REPOSITORY_H_
|
