ash / system / input_device_settings / pref_handlers / pointing_stick_pref_handler_impl.cc [blame]

// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/system/input_device_settings/pref_handlers/pointing_stick_pref_handler_impl.h"

#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/public/mojom/input_device_settings.mojom-forward.h"
#include "ash/public/mojom/input_device_settings.mojom.h"
#include "ash/shell.h"
#include "ash/system/input_device_settings/input_device_settings_defaults.h"
#include "ash/system/input_device_settings/input_device_settings_pref_names.h"
#include "ash/system/input_device_settings/input_device_settings_utils.h"
#include "ash/system/input_device_settings/input_device_tracker.h"
#include "ash/system/input_device_settings/settings_updated_metrics_info.h"
#include "base/check.h"
#include "base/json/values_util.h"
#include "base/values.h"
#include "components/account_id/account_id.h"
#include "components/prefs/pref_service.h"
#include "components/user_manager/known_user.h"

namespace ash {
namespace {

// Whether or not settings taken during the transition period should be
// persisted to the prefs. Values should only ever be true if the original
// setting was a user-configured value.
struct ForcePointingStickSettingPersistence {
  bool swap_right = false;
  bool sensitivity = false;
  bool acceleration_enabled = false;
};

mojom::PointingStickSettingsPtr GetDefaultPointingStickSettings() {
  mojom::PointingStickSettingsPtr settings =
      mojom::PointingStickSettings::New();
  settings->sensitivity = kDefaultSensitivity;
  settings->swap_right = kDefaultSwapRight;
  settings->acceleration_enabled = kDefaultAccelerationEnabled;
  return settings;
}

// GetPointingStickSettingsFromPrefs returns pointing stick settings based on
// user prefs to be used as settings for new pointing sticks.
mojom::PointingStickSettingsPtr GetPointingStickSettingsFromPrefs(
    PrefService* prefs,
    ForcePointingStickSettingPersistence& force_persistence) {
  mojom::PointingStickSettingsPtr settings =
      mojom::PointingStickSettings::New();

  const auto* swap_right_preference =
      prefs->GetUserPrefValue(prefs::kPrimaryPointingStickButtonRight);
  settings->swap_right = swap_right_preference
                             ? swap_right_preference->GetBool()
                             : kDefaultSwapRight;
  force_persistence.swap_right = swap_right_preference != nullptr;

  const auto* sensitivity_preference =
      prefs->GetUserPrefValue(prefs::kPointingStickSensitivity);
  settings->sensitivity = sensitivity_preference
                              ? sensitivity_preference->GetInt()
                              : kDefaultSensitivity;
  force_persistence.sensitivity = sensitivity_preference != nullptr;

  const auto* acceleration_enabled_preference =
      prefs->GetUserPrefValue(prefs::kPointingStickAcceleration);
  settings->acceleration_enabled =
      acceleration_enabled_preference
          ? acceleration_enabled_preference->GetBool()
          : kDefaultAccelerationEnabled;
  force_persistence.acceleration_enabled =
      acceleration_enabled_preference != nullptr;

  return settings;
}

mojom::PointingStickSettingsPtr RetrievePointingStickSettings(
    const mojom::PointingStick& pointing_stick,
    const base::Value::Dict& settings_dict) {
  mojom::PointingStickSettingsPtr settings =
      mojom::PointingStickSettings::New();
  settings->sensitivity =
      settings_dict.FindInt(prefs::kPointingStickSettingSensitivity)
          .value_or(kDefaultSensitivity);
  settings->swap_right =
      settings_dict.FindBool(prefs::kPointingStickSettingSwapRight)
          .value_or(kDefaultSwapRight);
  settings->acceleration_enabled =
      settings_dict.FindBool(prefs::kPointingStickSettingAcceleration)
          .value_or(kDefaultAccelerationEnabled);
  return settings;
}

base::Value::Dict ConvertSettingsToDict(
    const mojom::PointingStick& pointing_stick,
    const ForcePointingStickSettingPersistence& force_persistence,
    const base::Value::Dict* existing_settings_dict) {
  // Populate `settings_dict` with all settings in `settings`.
  base::Value::Dict settings_dict;

  if (ShouldPersistSetting(prefs::kPointingStickSettingSwapRight,
                           pointing_stick.settings->swap_right,
                           kDefaultSwapRight, force_persistence.swap_right,
                           existing_settings_dict)) {
    settings_dict.Set(prefs::kPointingStickSettingSwapRight,
                      pointing_stick.settings->swap_right);
  }

  if (ShouldPersistSetting(
          prefs::kPointingStickSettingSensitivity,
          static_cast<int>(pointing_stick.settings->sensitivity),
          kDefaultSensitivity, force_persistence.sensitivity,
          existing_settings_dict)) {
    settings_dict.Set(prefs::kPointingStickSettingSensitivity,
                      pointing_stick.settings->sensitivity);
  }

  if (ShouldPersistSetting(prefs::kPointingStickSettingAcceleration,
                           pointing_stick.settings->acceleration_enabled,
                           kDefaultAccelerationEnabled,
                           force_persistence.acceleration_enabled,
                           existing_settings_dict)) {
    settings_dict.Set(prefs::kPointingStickSettingAcceleration,
                      pointing_stick.settings->acceleration_enabled);
  }

  return settings_dict;
}

void UpdateInternalPointingStickImpl(
    PrefService* pref_service,
    const mojom::PointingStick& pointing_stick,
    const ForcePointingStickSettingPersistence& force_persistence) {
  CHECK(pointing_stick.settings);
  CHECK(!pointing_stick.is_external);

  base::Value::Dict existing_settings_dict =
      pref_service->GetDict(prefs::kPointingStickInternalSettings).Clone();
  base::Value::Dict settings_dict = ConvertSettingsToDict(
      pointing_stick, force_persistence, &existing_settings_dict);

  // Merge the new settings into the old settings so that all settings are
  // transferred over.
  existing_settings_dict.Merge(std::move(settings_dict));
  pref_service->SetDict(prefs::kPointingStickInternalSettings,
                        std::move(existing_settings_dict));
}

void UpdatePointingStickSettingsImpl(
    PrefService* pref_service,
    const mojom::PointingStick& pointing_stick,
    const ForcePointingStickSettingPersistence& force_persistence) {
  DCHECK(pointing_stick.settings);

  if (!pointing_stick.is_external) {
    UpdateInternalPointingStickImpl(pref_service, pointing_stick,
                                    force_persistence);
    return;
  }

  base::Value::Dict devices_dict =
      pref_service->GetDict(prefs::kPointingStickDeviceSettingsDictPref)
          .Clone();
  base::Value::Dict* existing_settings_dict =
      devices_dict.FindDict(pointing_stick.device_key);

  base::Value::Dict settings_dict = ConvertSettingsToDict(
      pointing_stick, force_persistence, existing_settings_dict);
  const base::Time time_stamp = base::Time::Now();
  settings_dict.Set(prefs::kLastUpdatedKey, base::TimeToValue(time_stamp));

  // If an old settings dict already exists for the device, merge the updated
  // settings into the old settings. Otherwise, insert the dict at
  // `pointing_stick.device_key`.
  if (existing_settings_dict) {
    existing_settings_dict->Merge(std::move(settings_dict));
  } else {
    devices_dict.Set(pointing_stick.device_key, std::move(settings_dict));
  }

  pref_service->SetDict(
      std::string(prefs::kPointingStickDeviceSettingsDictPref),
      std::move(devices_dict));
}

mojom::PointingStickSettingsPtr GetPointingStickSettingsFromOldLocalStatePrefs(
    PrefService* local_state,
    const AccountId& account_id,
    const mojom::PointingStick& pointing_stick) {
  mojom::PointingStickSettingsPtr settings = GetDefaultPointingStickSettings();
  settings->swap_right =
      user_manager::KnownUser(local_state)
          .FindBoolPath(account_id,
                        prefs::kOwnerPrimaryPointingStickButtonRight)
          .value_or(kDefaultSwapRight);

  return settings;
}

void InitializeSettingsUpdateMetricInfo(
    PrefService* pref_service,
    const mojom::PointingStick& pointing_stick,
    SettingsUpdatedMetricsInfo::Category category) {
  CHECK(pref_service);

  const auto& settings_metric_info =
      pref_service->GetDict(prefs::kPointingStickUpdateSettingsMetricInfo);
  const auto* device_metric_info =
      settings_metric_info.Find(pointing_stick.device_key);
  if (device_metric_info) {
    return;
  }

  auto updated_metric_info = settings_metric_info.Clone();

  const SettingsUpdatedMetricsInfo metrics_info(category, base::Time::Now());
  updated_metric_info.Set(pointing_stick.device_key, metrics_info.ToDict());

  pref_service->SetDict(prefs::kPointingStickUpdateSettingsMetricInfo,
                        std::move(updated_metric_info));
}

}  // namespace

PointingStickPrefHandlerImpl::PointingStickPrefHandlerImpl() = default;
PointingStickPrefHandlerImpl::~PointingStickPrefHandlerImpl() = default;

void PointingStickPrefHandlerImpl::InitializePointingStickSettings(
    PrefService* pref_service,
    mojom::PointingStick* pointing_stick) {
  if (!pref_service) {
    pointing_stick->settings = GetDefaultPointingStickSettings();
    return;
  }

  const base::Value::Dict* settings_dict = nullptr;
  if (!pointing_stick->is_external) {
    settings_dict =
        &pref_service->GetDict(prefs::kPointingStickInternalSettings);
    if (settings_dict->empty()) {
      settings_dict = nullptr;
    }
  } else {
    const auto& devices_dict =
        pref_service->GetDict(prefs::kPointingStickDeviceSettingsDictPref);
    settings_dict = devices_dict.FindDict(pointing_stick->device_key);
  }

  ForcePointingStickSettingPersistence force_persistence;
  SettingsUpdatedMetricsInfo::Category category;
  if (settings_dict) {
    category = SettingsUpdatedMetricsInfo::Category::kSynced;
    pointing_stick->settings =
        RetrievePointingStickSettings(*pointing_stick, *settings_dict);
  } else if (Shell::Get()->input_device_tracker()->WasDevicePreviouslyConnected(
                 InputDeviceTracker::InputDeviceCategory::kPointingStick,
                 pointing_stick->device_key)) {
    category = SettingsUpdatedMetricsInfo::Category::kDefault;
    pointing_stick->settings =
        GetPointingStickSettingsFromPrefs(pref_service, force_persistence);
  } else {
    // Pointing Stick currently does not do syncing defaults like other devices
    // as only internal pointing sticks are supported in the first place.
    category = SettingsUpdatedMetricsInfo::Category::kFirstEver;
    pointing_stick->settings = GetDefaultPointingStickSettings();
  }
  DCHECK(pointing_stick->settings);
  InitializeSettingsUpdateMetricInfo(pref_service, *pointing_stick, category);

  UpdatePointingStickSettingsImpl(pref_service, *pointing_stick,
                                  force_persistence);
}

void PointingStickPrefHandlerImpl::UpdatePointingStickSettings(
    PrefService* pref_service,
    const mojom::PointingStick& pointing_stick) {
  UpdatePointingStickSettingsImpl(pref_service, pointing_stick,
                                  /*force_persistence=*/{});
}

void PointingStickPrefHandlerImpl::InitializeLoginScreenPointingStickSettings(
    PrefService* local_state,
    const AccountId& account_id,
    mojom::PointingStick* pointing_stick) {
  // Verify if the flag is enabled.
  if (!features::IsInputDeviceSettingsSplitEnabled()) {
    return;
  }
  CHECK(local_state);

  const auto* settings_dict = GetLoginScreenSettingsDict(
      local_state, account_id,
      pointing_stick->is_external
          ? prefs::kPointingStickLoginScreenExternalSettingsPref
          : prefs::kPointingStickLoginScreenInternalSettingsPref);
  if (settings_dict) {
    pointing_stick->settings =
        RetrievePointingStickSettings(*pointing_stick, *settings_dict);
  } else {
    pointing_stick->settings = GetPointingStickSettingsFromOldLocalStatePrefs(
        local_state, account_id, *pointing_stick);
  }
}

void PointingStickPrefHandlerImpl::UpdateLoginScreenPointingStickSettings(
    PrefService* local_state,
    const AccountId& account_id,
    const mojom::PointingStick& pointing_stick) {
  CHECK(local_state);
  const auto* pref_name =
      pointing_stick.is_external
          ? prefs::kPointingStickLoginScreenExternalSettingsPref
          : prefs::kPointingStickLoginScreenInternalSettingsPref;
  auto* settings_dict =
      GetLoginScreenSettingsDict(local_state, account_id, pref_name);

  user_manager::KnownUser(local_state)
      .SetPath(account_id, pref_name,
               std::make_optional<base::Value>(ConvertSettingsToDict(
                   pointing_stick, /*force_persistence=*/{}, settings_dict)));
}

void PointingStickPrefHandlerImpl::InitializeWithDefaultPointingStickSettings(
    mojom::PointingStick* pointing_stick) {
  pointing_stick->settings = GetDefaultPointingStickSettings();
}

}  // namespace ash