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
|
// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROMEOS_ASH_COMPONENTS_PROXIMITY_AUTH_PROXIMITY_AUTH_SYSTEM_H_
#define CHROMEOS_ASH_COMPONENTS_PROXIMITY_AUTH_PROXIMITY_AUTH_SYSTEM_H_
#include <memory>
#include <vector>
#include "base/memory/raw_ptr.h"
#include "chromeos/ash/components/multidevice/remote_device_ref.h"
#include "chromeos/ash/components/proximity_auth/screenlock_bridge.h"
#include "components/account_id/account_id.h"
namespace ash {
namespace secure_channel {
class SecureChannelClient;
}
} // namespace ash
namespace proximity_auth {
class ProximityAuthClient;
class RemoteDeviceLifeCycle;
class UnlockManager;
// This is the main entry point to start Proximity Auth, the underlying system
// for the Smart Lock feature. Given a list of remote devices (i.e. a
// phone) for each registered user, the system will handle the connection,
// authentication, and messenging protocol when the screen is locked and the
// registered user is focused.
class ProximityAuthSystem : public ScreenlockBridge::Observer {
public:
ProximityAuthSystem(
ProximityAuthClient* proximity_auth_client,
ash::secure_channel::SecureChannelClient* secure_channel_client);
ProximityAuthSystem(const ProximityAuthSystem&) = delete;
ProximityAuthSystem& operator=(const ProximityAuthSystem&) = delete;
~ProximityAuthSystem() override;
// Starts the system to connect and authenticate when a registered user is
// focused on the lock screen.
void Start();
// Stops the system.
void Stop();
// Registers a list of |remote_devices| for |account_id| that can be used for
// unlock. |local_device| represents this device (i.e. this Chrome OS
// device) for this particular user profile context. If devices were
// previously registered for the user, then they will be replaced.
void SetRemoteDevicesForUser(
const AccountId& account_id,
const ash::multidevice::RemoteDeviceRefList& remote_devices,
std::optional<ash::multidevice::RemoteDeviceRef> local_device);
// Returns the RemoteDevices registered for |account_id|. Returns an empty
// list if no devices are registered for |account_id|.
ash::multidevice::RemoteDeviceRefList GetRemoteDevicesForUser(
const AccountId& account_id) const;
// Called when the user clicks the user pod and attempts to unlock.
void OnAuthAttempted();
// Called when the system suspends.
void OnSuspend();
// Called when the system wakes up from a suspended state.
void OnSuspendDone();
// Called in order to disable attempts to get RemoteStatus from host devices.
void CancelConnectionAttempt();
// The last value emitted to the SmartLock.GetRemoteStatus.Unlock(.Failure)
// metrics. Helps to understand whether/why not Smart Lock was an available
// choice for unlock. Returns the empty string if |unlock_manager_| is
// nullptr.
std::string GetLastRemoteStatusUnlockForLogging();
protected:
// Constructor which allows passing in a custom |unlock_manager_|.
// Exposed for testing.
ProximityAuthSystem(
ash::secure_channel::SecureChannelClient* secure_channel_client,
std::unique_ptr<UnlockManager> unlock_manager);
// Creates the RemoteDeviceLifeCycle for |remote_device| and |local_device|.
// |remote_device| is the host intended to be connected to, and |local_device|
// represents this device (i.e. this Chrome OS device) for this particular
// user profile context.
// Exposed for testing.
virtual std::unique_ptr<RemoteDeviceLifeCycle> CreateRemoteDeviceLifeCycle(
ash::multidevice::RemoteDeviceRef remote_device,
std::optional<ash::multidevice::RemoteDeviceRef> local_device);
// ScreenlockBridge::Observer:
void OnScreenDidLock() override;
void OnScreenDidUnlock() override;
void OnFocusedUserChanged(const AccountId& account_id) override;
private:
// Lists of remote devices, keyed by user account id.
std::map<AccountId, ash::multidevice::RemoteDeviceRefList>
remote_devices_map_;
// A mapping from each profile's account ID to the profile-specific
// representation of this device (i.e. this Chrome OS device) for that
// particular user profile.
std::map<AccountId, ash::multidevice::RemoteDeviceRef> local_device_map_;
// Entry point to the SecureChannel API.
raw_ptr<ash::secure_channel::SecureChannelClient> secure_channel_client_;
// Responsible for the life cycle of connecting and authenticating to
// the RemoteDevice of the currently focused user.
std::unique_ptr<RemoteDeviceLifeCycle> remote_device_life_cycle_;
// Handles the interaction with the lock screen UI.
std::unique_ptr<UnlockManager> unlock_manager_;
// True if the system is suspended.
bool suspended_ = false;
// True if the system is started_.
bool started_ = false;
};
} // namespace proximity_auth
#endif // CHROMEOS_ASH_COMPONENTS_PROXIMITY_AUTH_PROXIMITY_AUTH_SYSTEM_H_
|
