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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/ash/components/phonehub/multidevice_setup_state_updater.h"
#include "base/functional/callback_helpers.h"
#include "chromeos/ash/components/multidevice/logging/logging.h"
#include "chromeos/ash/components/phonehub/pref_names.h"
#include "chromeos/ash/components/phonehub/util/histogram_util.h"
#include "chromeos/ash/services/multidevice_setup/public/cpp/prefs.h"
#include "components/prefs/pref_registry_simple.h"
#include "components/prefs/pref_service.h"
namespace ash::phonehub {
namespace {
using multidevice_setup::mojom::Feature;
using multidevice_setup::mojom::FeatureState;
using multidevice_setup::mojom::HostStatus;
} // namespace
// static
void MultideviceSetupStateUpdater::RegisterPrefs(PrefRegistrySimple* registry) {
registry->RegisterBooleanPref(prefs::kIsAwaitingVerifiedHost, false);
}
MultideviceSetupStateUpdater::MultideviceSetupStateUpdater(
PrefService* pref_service,
multidevice_setup::MultiDeviceSetupClient* multidevice_setup_client,
MultideviceFeatureAccessManager* multidevice_feature_access_manager)
: pref_service_(pref_service),
multidevice_setup_client_(multidevice_setup_client),
multidevice_feature_access_manager_(multidevice_feature_access_manager) {
multidevice_setup_client_->AddObserver(this);
multidevice_feature_access_manager_->AddObserver(this);
notification_access_status_ =
multidevice_feature_access_manager_->GetNotificationAccessStatus();
camera_roll_access_status_ =
multidevice_feature_access_manager_->GetCameraRollAccessStatus();
}
MultideviceSetupStateUpdater::~MultideviceSetupStateUpdater() {
multidevice_setup_client_->RemoveObserver(this);
multidevice_feature_access_manager_->RemoveObserver(this);
}
void MultideviceSetupStateUpdater::OnNotificationAccessChanged() {
MultideviceFeatureAccessManager::AccessStatus pervious_access_status =
notification_access_status_;
notification_access_status_ =
multidevice_feature_access_manager_->GetNotificationAccessStatus();
switch (notification_access_status_) {
case MultideviceFeatureAccessManager::AccessStatus::kAccessGranted:
if (IsPhoneHubEnabled() &&
pervious_access_status == MultideviceFeatureAccessManager::
AccessStatus::kAvailableButNotGranted) {
PA_LOG(INFO) << "Enabling PhoneHubNotifications when access is changed "
"from kAvailableButNotGranted to kAccessGranted.";
multidevice_setup_client_->SetFeatureEnabledState(
Feature::kPhoneHubNotifications, /*enabled=*/true,
/*auth_token=*/std::nullopt, base::DoNothing());
} else if (IsWaitingForAccessToInitiallyEnableNotifications()) {
PA_LOG(INFO) << "Enabling PhoneHubNotifications for the first time now "
<< "that access has been granted by the phone.";
multidevice_setup_client_->SetFeatureEnabledState(
Feature::kPhoneHubNotifications, /*enabled=*/true,
/*auth_token=*/std::nullopt, base::DoNothing());
}
break;
case MultideviceFeatureAccessManager::AccessStatus::kAvailableButNotGranted:
[[fallthrough]];
case MultideviceFeatureAccessManager::AccessStatus::kProhibited:
// Disable kPhoneHubNotifications if notification access has been revoked
// by the phone.
PA_LOG(INFO) << "Disabling PhoneHubNotifications feature.";
multidevice_setup_client_->SetFeatureEnabledState(
Feature::kPhoneHubNotifications, /*enabled=*/false,
/*auth_token=*/std::nullopt, base::DoNothing());
break;
}
}
void MultideviceSetupStateUpdater::OnCameraRollAccessChanged() {
MultideviceFeatureAccessManager::AccessStatus pervious_access_status =
camera_roll_access_status_;
camera_roll_access_status_ =
multidevice_feature_access_manager_->GetCameraRollAccessStatus();
switch (camera_roll_access_status_) {
case MultideviceFeatureAccessManager::AccessStatus::kAccessGranted:
if (IsPhoneHubEnabled() &&
pervious_access_status == MultideviceFeatureAccessManager::
AccessStatus::kAvailableButNotGranted) {
PA_LOG(INFO) << "Enabling PhoneHubCameraRoll when access is changed "
"from kAvailableButNotGranted to kAccessGranted.";
multidevice_setup_client_->SetFeatureEnabledState(
Feature::kPhoneHubCameraRoll, /*enabled=*/true,
/*auth_token=*/std::nullopt, base::DoNothing());
} else if (IsWaitingForAccessToInitiallyEnableCameraRoll()) {
PA_LOG(INFO) << "Enabling PhoneHubCameraRoll for the first time now "
<< "that access has been granted by the phone.";
multidevice_setup_client_->SetFeatureEnabledState(
Feature::kPhoneHubCameraRoll, /*enabled=*/true,
/*auth_token=*/std::nullopt, base::DoNothing());
}
break;
case MultideviceFeatureAccessManager::AccessStatus::kAvailableButNotGranted:
[[fallthrough]];
case MultideviceFeatureAccessManager::AccessStatus::kProhibited:
// Disable kPhoneHubCameraRoll if camera roll access has been revoked
// by the phone.
PA_LOG(INFO) << "Disabling PhoneHubCameraRoll feature.";
multidevice_setup_client_->SetFeatureEnabledState(
Feature::kPhoneHubCameraRoll, /*enabled=*/false,
/*auth_token=*/std::nullopt, base::DoNothing());
break;
}
}
void MultideviceSetupStateUpdater::OnHostStatusChanged(
const multidevice_setup::MultiDeviceSetupClient::HostStatusWithDevice&
host_device_with_status) {
EnablePhoneHubIfAwaitingVerifiedHost();
}
void MultideviceSetupStateUpdater::OnFeatureStatesChanged(
const multidevice_setup::MultiDeviceSetupClient::FeatureStatesMap&
feature_state_map) {
EnablePhoneHubIfAwaitingVerifiedHost();
}
bool MultideviceSetupStateUpdater::
IsWaitingForAccessToInitiallyEnableNotifications() const {
// If the Phone Hub notifications feature has never been explicitly set, we
// should enable it after
// 1. the top-level Phone Hub feature is enabled, and
// 2. the phone has granted access.
// We do *not* want to automatically enable the feature unless the opt-in flow
// was triggered from this device
return IsPhoneHubEnabled() &&
multidevice_setup::IsDefaultFeatureEnabledValue(
Feature::kPhoneHubNotifications, pref_service_);
}
bool MultideviceSetupStateUpdater::
IsWaitingForAccessToInitiallyEnableCameraRoll() const {
// If the Phone Hub camera roll feature has never been explicitly set, we
// should enable it after
// 1. the top-level Phone Hub feature is enabled, and
// 2. the phone has granted access.
// We do *not* want to automatically enable the feature unless the opt-in flow
// was triggered from this device
return IsPhoneHubEnabled() &&
multidevice_setup::IsDefaultFeatureEnabledValue(
Feature::kPhoneHubCameraRoll, pref_service_);
}
bool MultideviceSetupStateUpdater::IsPhoneHubEnabled() const {
return multidevice_setup_client_->GetFeatureState(Feature::kPhoneHub) ==
FeatureState::kEnabledByUser;
}
void MultideviceSetupStateUpdater::EnablePhoneHubIfAwaitingVerifiedHost() {
bool is_awaiting_verified_host =
pref_service_->GetBoolean(prefs::kIsAwaitingVerifiedHost);
const HostStatus host_status =
multidevice_setup_client_->GetHostStatus().first;
const FeatureState feature_state =
multidevice_setup_client_->GetFeatureState(Feature::kPhoneHub);
// Enable the PhoneHub feature if the phone is verified and there was an
// intent to enable the feature. We also ensure that the feature is currently
// disabled and not in state like kNotSupportedByPhone or kProhibitedByPolicy.
if (is_awaiting_verified_host && host_status == HostStatus::kHostVerified &&
feature_state == FeatureState::kDisabledByUser) {
multidevice_setup_client_->SetFeatureEnabledState(
Feature::kPhoneHub, /*enabled=*/true, /*auth_token=*/std::nullopt,
base::DoNothing());
util::LogFeatureOptInEntryPoint(util::OptInEntryPoint::kSetupFlow);
}
UpdateIsAwaitingVerifiedHost();
}
void MultideviceSetupStateUpdater::UpdateIsAwaitingVerifiedHost() {
// Wait to enable Phone Hub until after host phone is verified. The intent to
// enable Phone Hub must be persisted in the event that this class is
// destroyed before the phone is verified.
const HostStatus host_status =
multidevice_setup_client_->GetHostStatus().first;
if (host_status ==
HostStatus::kHostSetLocallyButWaitingForBackendConfirmation) {
pref_service_->SetBoolean(prefs::kIsAwaitingVerifiedHost, true);
return;
}
// The intent to enable Phone Hub after host verification was fulfilled.
// Note: We don't want to reset the pref if, say, the host status is
// kNoEligibleHosts; that might just be a transient state seen during
// start-up, for instance. It is true that we don't want to enable Phone Hub
// if the user explicitly disabled it in settings, however, that can only
// occur after the host becomes verified and we first enable Phone Hub.
const bool is_awaiting_verified_host =
pref_service_->GetBoolean(prefs::kIsAwaitingVerifiedHost);
const FeatureState feature_state =
multidevice_setup_client_->GetFeatureState(Feature::kPhoneHub);
if (is_awaiting_verified_host && host_status == HostStatus::kHostVerified &&
feature_state == FeatureState::kEnabledByUser) {
pref_service_->SetBoolean(prefs::kIsAwaitingVerifiedHost, false);
return;
}
}
} // namespace ash::phonehub
|
