feature_state_manager_impl.h 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142
  1. // Copyright 2018 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #ifndef ASH_SERVICES_MULTIDEVICE_SETUP_FEATURE_STATE_MANAGER_IMPL_H_
  5. #define ASH_SERVICES_MULTIDEVICE_SETUP_FEATURE_STATE_MANAGER_IMPL_H_
  6. #include "ash/services/device_sync/public/cpp/device_sync_client.h"
  7. #include "ash/services/multidevice_setup/feature_state_manager.h"
  8. #include "ash/services/multidevice_setup/global_state_feature_manager.h"
  9. #include "ash/services/multidevice_setup/host_status_provider.h"
  10. #include "ash/services/multidevice_setup/public/cpp/android_sms_pairing_state_tracker.h"
  11. #include "ash/services/multidevice_setup/public/mojom/multidevice_setup.mojom.h"
  12. #include "base/containers/flat_map.h"
  13. #include "base/timer/timer.h"
  14. #include "components/prefs/pref_change_registrar.h"
  15. class PrefService;
  16. namespace ash {
  17. namespace multidevice_setup {
  18. // Concrete FeatureStateManager implementation. This class relies on
  19. // HostStatusProvider and DeviceSyncClient to determine if features are
  20. // available at all (features are not available unless a verified host is set
  21. // which has enabled the features). To track enabled/disabled/policy state, this
  22. // class utilizes per-user preferences.
  23. class FeatureStateManagerImpl : public FeatureStateManager,
  24. public HostStatusProvider::Observer,
  25. public device_sync::DeviceSyncClient::Observer,
  26. public AndroidSmsPairingStateTracker::Observer {
  27. public:
  28. class Factory {
  29. public:
  30. static std::unique_ptr<FeatureStateManager> Create(
  31. PrefService* pref_service,
  32. HostStatusProvider* host_status_provider,
  33. device_sync::DeviceSyncClient* device_sync_client,
  34. AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
  35. const base::flat_map<mojom::Feature, GlobalStateFeatureManager*>&
  36. global_state_feature_managers,
  37. bool is_secondary_user);
  38. static void SetFactoryForTesting(Factory* test_factory);
  39. protected:
  40. virtual ~Factory();
  41. virtual std::unique_ptr<FeatureStateManager> CreateInstance(
  42. PrefService* pref_service,
  43. HostStatusProvider* host_status_provider,
  44. device_sync::DeviceSyncClient* device_sync_client,
  45. AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
  46. const base::flat_map<mojom::Feature, GlobalStateFeatureManager*>&
  47. global_state_feature_managers,
  48. bool is_secondary_user) = 0;
  49. private:
  50. static Factory* test_factory_;
  51. };
  52. FeatureStateManagerImpl(const FeatureStateManagerImpl&) = delete;
  53. FeatureStateManagerImpl& operator=(const FeatureStateManagerImpl&) = delete;
  54. ~FeatureStateManagerImpl() override;
  55. private:
  56. FeatureStateManagerImpl(
  57. PrefService* pref_service,
  58. HostStatusProvider* host_status_provider,
  59. device_sync::DeviceSyncClient* device_sync_client,
  60. AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker,
  61. const base::flat_map<mojom::Feature, GlobalStateFeatureManager*>&
  62. global_state_feature_managers,
  63. bool is_secondary_user);
  64. // FeatureStateManager:
  65. FeatureStatesMap GetFeatureStates() override;
  66. void PerformSetFeatureEnabledState(mojom::Feature feature,
  67. bool enabled) override;
  68. // HostStatusProvider::Observer,
  69. void OnHostStatusChange(const HostStatusProvider::HostStatusWithDevice&
  70. host_status_with_device) override;
  71. // DeviceSyncClient::Observer:
  72. void OnNewDevicesSynced() override;
  73. // AndroidSmsPairingStateTracker::Observer:
  74. void OnPairingStateChanged() override;
  75. void OnPrefValueChanged();
  76. void UpdateFeatureStateCache(bool notify_observers_of_changes);
  77. mojom::FeatureState ComputeFeatureState(mojom::Feature feature);
  78. bool IsAllowedByPolicy(mojom::Feature feature);
  79. bool IsSupportedByChromebook(mojom::Feature feature);
  80. bool HasSufficientSecurity(mojom::Feature feature,
  81. const multidevice::RemoteDeviceRef& host_device);
  82. bool HasBeenActivatedByPhone(mojom::Feature feature,
  83. const multidevice::RemoteDeviceRef& host_device);
  84. bool RequiresFurtherSetup(mojom::Feature feature);
  85. mojom::FeatureState GetEnabledOrDisabledState(mojom::Feature feature);
  86. // Log the feature states in |cached_feature_state_map_|. Called 1) on
  87. // sign-in, 2) when at least one feature state changes, and 3) every 30
  88. // minutes. The latter is necessary to capture users who stay logged in longer
  89. // than UMA aggregation periods and don't change feature state.
  90. void LogFeatureStates() const;
  91. PrefService* pref_service_;
  92. HostStatusProvider* host_status_provider_;
  93. device_sync::DeviceSyncClient* device_sync_client_;
  94. AndroidSmsPairingStateTracker* android_sms_pairing_state_tracker_;
  95. const base::flat_map<mojom::Feature, GlobalStateFeatureManager*>
  96. global_state_feature_managers_;
  97. // Certain features may be unavailable to secondary users logged into a
  98. // Chromebook. Currently, such features include PhoneHub and its subfeatures.
  99. const bool is_secondary_user_;
  100. // Map from feature to the pref name which indicates the enabled/disabled
  101. // boolean state for the feature.
  102. base::flat_map<mojom::Feature, std::string> feature_to_enabled_pref_name_map_;
  103. // Same as above, except that the pref names represent whether the feature is
  104. // allowed by policy or not.
  105. base::flat_map<mojom::Feature, std::string> feature_to_allowed_pref_name_map_;
  106. // Map from feature to state, which is updated each time a feature's state
  107. // changes. This cache is used to determine when a feature's state has changed
  108. // so that observers can be notified.
  109. FeatureStatesMap cached_feature_state_map_;
  110. base::RepeatingTimer feature_state_metric_timer_;
  111. PrefChangeRegistrar registrar_;
  112. };
  113. } // namespace multidevice_setup
  114. } // namespace ash
  115. #endif // ASH_SERVICES_MULTIDEVICE_SETUP_FEATURE_STATE_MANAGER_IMPL_H_