[Night Light] CL4: Automatic schedule backend.

ash/system/night_light/night_light_controller.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/system/night_light/night_light_controller.h"
 
 #include "ash/public/cpp/ash_pref_names.h"
 #include "ash/session/session_controller.h"
 #include "ash/shell.h"
 #include "base/time/time.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
+#include "device/geolocation/geolocation_provider.h"
+#include "device/geolocation/geoposition.h"
+#include "third_party/icu/source/i18n/astro.h"

[jungshik at Google, 2017/05/26 10:03:48]

You're not supposed to use a non-public/internal API.  All public headers are in
source/i18n/unicode and source/common/unicode. 

I thought I had added a guard against including private headers in
third_party/icu/BUILD.gn.  Yes, I did, but I may not have done the right thing. 

[afakhry, 2017/05/26 21:55:56]

Yes, gn gen --check catches this. Please let's push for making this a public
API. Thanks!

 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 
 namespace ash {
 
 namespace {
 
+// Default start time at 6:00 PM as an offset from 00:00.
+const int kDefaultStartTimeOffsetMinutes = 18 * 60;
+
+// Default end time at 6:00 AM as an offset from 00:00.
+const int kDefaultEndTimeOffsetMinutes = 6 * 60;
+
 constexpr float kDefaultColorTemperature = 0.5f;
 
-// The duration of the temperature change animation when the change is a result
-// of a manual user setting.
-// TODO(afakhry): Add automatic schedule animation duration when you implement
-// that part. It should be large enough (20 seconds as agreed) to give the user
-// a nice smooth transition.
-constexpr int kManualToggleAnimationDurationSec = 2;
+// The duration of the temperature change animation for
+// AnimationDurationType::kShort.
+constexpr int kManualAnimationDurationSec = 2;
+
+// The duration of the temperature change animation for
+// AnimationDurationType::kLong.
+constexpr int kAutomaticAnimationDurationSec = 20;
+
+class NightLightControllerDelegateImpl : public NightLightController::Delegate {
+ public:
+  NightLightControllerDelegateImpl() {
+    // Verify that the active user session has started to make sure that owner
+    // has already gone through OOBE and agreed on the terms of service, so that
+    // we can use the geolocation services. crbug.com/715686.
+    DCHECK(Shell::Get()->session_controller()->IsActiveUserSessionStarted());
+
+    device::GeolocationProvider* geolocation_provider =
+        device::GeolocationProvider::GetInstance();
+
+    // We only need the low-accuracy IP-based geolocation position, which does
+    // not require user consent.
+    geolocation_provider->UserDidOptIntoLocationServices();
+    geolocation_subscription_ = geolocation_provider->AddLocationUpdateCallback(

[mcasas, 2017/05/25 16:52:27]

This will also enable Wifi-based location via [1],
but I'm not sure if consent-wise needs more permissions
or not. The code to retrieve position looks good, I wonder
if you could use a mojo interface though? (Will ease 
servicification down the line).

[1]
https://cs.chromium.org/chromium/src/device/geolocation/network_location_prov...

[afakhry, 2017/05/25 17:49:59]

I believe privacy will have an issue with sending Wifi data to google without
user consent! Is there a way to force it not to? I thought enable_high_accuracy
= false should take care of that.
My understanding is the geoposition mojo interface are not yet ready, are they?
Can you please give an example about how to use them if they are?

[mcasas, 2017/05/26 15:39:17]

I'm afraid |enable_high_accuracy| doesn't do that, and that's
because it maps the equivalent Spec term which leaves
plenty of leeway for the UA to implement it in any it sees fit
(and even we leave that further to the OS in some cases e.g. 
Android). That  said, I could imagine having some way to 
explicitly configure low accuracy sources.
WebKit uses the Geolocation mojo API [1], which acts similarly to 
what you are doing here (albeit using WTF types [2]).  The Geoloc 
service is currently offered by content/browser [3], and in due time
it should be offered by //services/device.


[1]
https://cs.chromium.org/chromium/src/device/geolocation/public/interfaces/geo...
[2]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/modules/geoloc...
[3]
https://cs.chromium.org/chromium/src/content/public/app/mojo/content_browser_...

[afakhry, 2017/05/26 21:55:56]

Since now we know we can't send wifi data without user consent, I uploaded a CL
https://codereview.chromium.org/2901413006 in which I make the
NetworkLocationProvider not send wifi data if it was started with
enable_high_accuracy is set to false. Please take a look. Then I will use the
mojo APIs if that CL is a good enough solution to the problem.

+        base::Bind(&NightLightControllerDelegateImpl::OnGeoPosition,
+                   base::Unretained(this)),
+        false /* enable_high_accuracy */);
+  }
+  ~NightLightControllerDelegateImpl() override = default;
+
+  // ash::NightLightController::Delegate:
+  base::Time GetNow() const override { return base::Time::Now(); }
+  base::Time GetSunsetTime() const override { return GetSunRiseSet(false); }
+  base::Time GetSunriseTime() const override { return GetSunRiseSet(true); }
+
+ private:
+  base::Time GetSunRiseSet(bool sunrise) const {
+    if (!position_.Validate()) {
+      return sunrise ? TimeOfDay(kDefaultEndTimeOffsetMinutes).ToTimeToday()
+                     : TimeOfDay(kDefaultStartTimeOffsetMinutes).ToTimeToday();
+    }
+
+    icu::CalendarAstronomer astro(position_.longitude, position_.latitude);
+    // Note that the icu calendar return milliseconds since epoch, and
+    // base::Time::FromDoubleT() expects seconds.
+    return base::Time::FromDoubleT(astro.getSunRiseSet(sunrise) / 1000.0);

[jungshik at Google, 2017/05/26 10:03:48]

According to the comment in the source file, this method only works well when
the CalendarAstromer's time is near "local" noon. (By 'local', I think it means
local sidereal time, but not sure). 

When you construct CalendarAstronomer with {long, lat}, the time is set to the
current time. So, it may not work well. 

[afakhry, 2017/05/26 21:55:56]

Thanks for catching this. Done. Please take a look.

+  }
+
+  void OnGeoPosition(const device::Geoposition& pos) { position_ = pos; }
+
+  using LocationSubscription = device::GeolocationProvider::Subscription;
+  std::unique_ptr<LocationSubscription> geolocation_subscription_;
+
+  device::Geoposition position_;
+
+  DISALLOW_COPY_AND_ASSIGN(NightLightControllerDelegateImpl);
+};
 
 // Applies the given |layer_temperature| to all the layers of the root windows
 // with the given |animation_duration|.
 // |layer_temperature| is the ui::Layer floating-point value in the range of
 // 0.0f (least warm) to 1.0f (most warm).
 void ApplyColorTemperatureToLayers(float layer_temperature,
                                    base::TimeDelta animation_duration) {
   for (aura::Window* root_window : Shell::GetAllRootWindows()) {
     ui::Layer* layer = root_window->layer();
 
@@ skipping 16 matching lines @@
 
 NightLightController::~NightLightController() {
   session_controller_->RemoveObserver(this);
 }
 
 // static
 void NightLightController::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterBooleanPref(prefs::kNightLightEnabled, false);
   registry->RegisterDoublePref(prefs::kNightLightTemperature,
                                kDefaultColorTemperature);
+  registry->RegisterIntegerPref(prefs::kNightLightScheduleType,
+                                static_cast<int>(ScheduleType::kNone));
+  registry->RegisterIntegerPref(prefs::kNightLightCustomStartTime,
+                                kDefaultStartTimeOffsetMinutes);
+  registry->RegisterIntegerPref(prefs::kNightLightCustomEndTime,
+                                kDefaultEndTimeOffsetMinutes);
 }
 
 void NightLightController::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void NightLightController::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool NightLightController::GetEnabled() const {
   return active_user_pref_service_ &&
          active_user_pref_service_->GetBoolean(prefs::kNightLightEnabled);
 }
 
 float NightLightController::GetColorTemperature() const {
   if (active_user_pref_service_)
     return active_user_pref_service_->GetDouble(prefs::kNightLightTemperature);
 
   return kDefaultColorTemperature;
 }
 
-void NightLightController::SetEnabled(bool enabled) {
-  if (active_user_pref_service_)
+NightLightController::ScheduleType NightLightController::GetScheduleType()
+    const {
+  if (active_user_pref_service_) {
+    return static_cast<ScheduleType>(
+        active_user_pref_service_->GetInteger(prefs::kNightLightScheduleType));
+  }
+
+  return ScheduleType::kNone;
+}
+
+TimeOfDay NightLightController::GetCustomStartTime() const {
+  if (active_user_pref_service_) {
+    return TimeOfDay(active_user_pref_service_->GetInteger(
+        prefs::kNightLightCustomStartTime));
+  }
+
+  return TimeOfDay(kDefaultStartTimeOffsetMinutes);
+}
+
+TimeOfDay NightLightController::GetCustomEndTime() const {
+  if (active_user_pref_service_) {
+    return TimeOfDay(
+        active_user_pref_service_->GetInteger(prefs::kNightLightCustomEndTime));
+  }
+
+  return TimeOfDay(kDefaultEndTimeOffsetMinutes);
+}
+
+void NightLightController::SetEnabled(bool enabled,
+                                      AnimationDurationType animation_type) {
+  if (active_user_pref_service_) {
+    animation_type_ = animation_type;
     active_user_pref_service_->SetBoolean(prefs::kNightLightEnabled, enabled);
+  }
 }
 
 void NightLightController::SetColorTemperature(float temperature) {
   DCHECK_GE(temperature, 0.0f);
   DCHECK_LE(temperature, 1.0f);
   if (active_user_pref_service_) {
     active_user_pref_service_->SetDouble(prefs::kNightLightTemperature,
                                          temperature);
   }
 }
 
+void NightLightController::SetScheduleType(ScheduleType type) {
+  if (active_user_pref_service_) {
+    active_user_pref_service_->SetInteger(prefs::kNightLightScheduleType,
+                                          static_cast<int>(type));
+  }
+}
+
+void NightLightController::SetCustomStartTime(TimeOfDay start_time) {
+  if (active_user_pref_service_) {
+    active_user_pref_service_->SetInteger(
+        prefs::kNightLightCustomStartTime,
+        start_time.offset_minutes_from_zero_hour());
+  }
+}
+
+void NightLightController::SetCustomEndTime(TimeOfDay end_time) {
+  if (active_user_pref_service_) {
+    active_user_pref_service_->SetInteger(
+        prefs::kNightLightCustomEndTime,
+        end_time.offset_minutes_from_zero_hour());
+  }
+}
+
 void NightLightController::Toggle() {
-  SetEnabled(!GetEnabled());
+  SetEnabled(!GetEnabled(), AnimationDurationType::kShort);
 }
 
 void NightLightController::OnActiveUserSessionChanged(
     const AccountId& account_id) {
   // Initial login and user switching in multi profiles.
   pref_change_registrar_.reset();
   active_user_pref_service_ = Shell::Get()->GetActiveUserPrefService();
+  delegate_ = base::MakeUnique<NightLightControllerDelegateImpl>();
   InitFromUserPrefs();
 }
 
-void NightLightController::Refresh() {
+void NightLightController::SetDelegateForTesting(
+    std::unique_ptr<Delegate> delegate) {
+  delegate_ = std::move(delegate);
+}
+
+void NightLightController::RefreshLayersTemperature() {
   // TODO(afakhry): Add here refreshing of start and end times, when you
   // implement the automatic schedule settings.
   ApplyColorTemperatureToLayers(
       GetEnabled() ? GetColorTemperature() : 0.0f,
-      base::TimeDelta::FromSeconds(kManualToggleAnimationDurationSec));
+      base::TimeDelta::FromSeconds(animation_type_ ==
+                                           AnimationDurationType::kShort
+                                       ? kManualAnimationDurationSec
+                                       : kAutomaticAnimationDurationSec));
+
+  // Reset the animation type back to manual to consume any automatically set
+  // animations.
+  last_animation_type_ = animation_type_;
+  animation_type_ = AnimationDurationType::kShort;
 }
 
 void NightLightController::StartWatchingPrefsChanges() {
   DCHECK(active_user_pref_service_);
 
   pref_change_registrar_ = base::MakeUnique<PrefChangeRegistrar>();
   pref_change_registrar_->Init(active_user_pref_service_);
   pref_change_registrar_->Add(
       prefs::kNightLightEnabled,
       base::Bind(&NightLightController::OnEnabledPrefChanged,
                  base::Unretained(this)));
   pref_change_registrar_->Add(
       prefs::kNightLightTemperature,
       base::Bind(&NightLightController::OnColorTemperaturePrefChanged,
                  base::Unretained(this)));
+  pref_change_registrar_->Add(
+      prefs::kNightLightScheduleType,
+      base::Bind(&NightLightController::OnScheduleParamsPrefsChanged,
+                 base::Unretained(this)));
+  pref_change_registrar_->Add(
+      prefs::kNightLightCustomStartTime,
+      base::Bind(&NightLightController::OnScheduleParamsPrefsChanged,
+                 base::Unretained(this)));
+  pref_change_registrar_->Add(
+      prefs::kNightLightCustomEndTime,
+      base::Bind(&NightLightController::OnScheduleParamsPrefsChanged,
+                 base::Unretained(this)));
 }
 
 void NightLightController::InitFromUserPrefs() {
   if (!active_user_pref_service_) {
     // The pref_service can be null in ash_unittests.
     return;
   }
 
   StartWatchingPrefsChanges();
-  Refresh();
+  Refresh(true /* did_schedule_change */);
   NotifyStatusChanged();
 }
 
 void NightLightController::NotifyStatusChanged() {
   for (auto& observer : observers_)
     observer.OnNightLightEnabledChanged(GetEnabled());
 }
 
 void NightLightController::OnEnabledPrefChanged() {
   DCHECK(active_user_pref_service_);
-  Refresh();
+  Refresh(false /* did_schedule_change */);
   NotifyStatusChanged();
 }
 
 void NightLightController::OnColorTemperaturePrefChanged() {
   DCHECK(active_user_pref_service_);
-  Refresh();
+  RefreshLayersTemperature();
+}
+
+void NightLightController::OnScheduleParamsPrefsChanged() {
+  DCHECK(active_user_pref_service_);
+  Refresh(true /* did_schedule_change */);
+}
+
+void NightLightController::Refresh(bool did_schedule_change) {
+  RefreshLayersTemperature();
+
+  const ScheduleType type = GetScheduleType();
+  switch (type) {
+    case ScheduleType::kNone:
+      timer_.Stop();
+      return;
+
+    case ScheduleType::kSunsetToSunrise:
+      RefreshScheduleTimer(delegate_->GetSunsetTime(),
+                           delegate_->GetSunriseTime(), did_schedule_change);
+      return;
+
+    case ScheduleType::kCustom:
+      RefreshScheduleTimer(GetCustomStartTime().ToTimeToday(),
+                           GetCustomEndTime().ToTimeToday(),
+                           did_schedule_change);
+      return;
+  }
+}
+
+void NightLightController::RefreshScheduleTimer(base::Time start_time,
+                                                base::Time end_time,
+                                                bool did_schedule_change) {
+  if (GetScheduleType() == ScheduleType::kNone) {
+    NOTREACHED();
+    timer_.Stop();
+    return;
+  }
+
+  // NOTE: Users can set any weird combinations.
+  if (end_time <= start_time) {
+    // Example:
+    // Start: 9:00 PM, End: 6:00 AM.
+    //
+    //       6:00                21:00
+    // <----- + ------------------ + ----->
+    //        |                    |
+    //       end                 start
+    //
+    // From our perspective, the end time is always a day later.
+    end_time += base::TimeDelta::FromDays(1);
+  }
+
+  DCHECK_GE(end_time, start_time);
+
+  // The target status that we need to set NightLight to now if a change of
+  // status is needed immediately.
+  bool enable_now = false;
+
+  // Where are we now with respect to the start and end times?
+  const base::Time now = delegate_->GetNow();
+  if (now < start_time) {
+    // Example:
+    // Start: 6:00 PM today, End: 6:00 AM tomorrow, Now: 4:00 PM.
+    //
+    // <----- + ----------- + ----------- + ----->
+    //        |             |             |
+    //       now          start          end
+    //
+    // In this case, we need to disable NightLight immediately if it's enabled.
+    enable_now = false;
+  } else if (now >= start_time && now < end_time) {
+    // Example:
+    // Start: 6:00 PM today, End: 6:00 AM tomorrow, Now: 11:00 PM.
+    //
+    // <----- + ----------- + ----------- + ----->
+    //        |             |             |
+    //      start          now           end
+    //
+    // Start NightLight right away. Our future start time is a day later than
+    // its current value.
+    enable_now = true;
+    start_time += base::TimeDelta::FromDays(1);
+  } else {  // now >= end_time.
+    // Example:
+    // Start: 6:00 PM today, End: 10:00 PM today, Now: 11:00 PM.
+    //
+    // <----- + ----------- + ----------- + ----->
+    //        |             |             |
+    //      start          end           now
+    //
+    // In this case, our future start and end times are a day later from their
+    // current values. NightLight needs to be ended immediately if it's already
+    // enabled.
+    enable_now = false;
+    start_time += base::TimeDelta::FromDays(1);
+    end_time += base::TimeDelta::FromDays(1);
+  }
+
+  // After the above processing, the start and end time are all in the future.
+  DCHECK_GE(start_time, now);
+  DCHECK_GE(end_time, now);
+
+  if (did_schedule_change && enable_now != GetEnabled()) {
+    // If the change in the schedule introduces a change in the status, then
+    // calling SetEnabled() is all we need, since it will trigger a change in
+    // the user prefs to which we will respond by calling Refresh(). This will
+    // end up in this function again, adjusting all the needed schedules.
+    SetEnabled(enable_now, AnimationDurationType::kShort);
+    return;
+  }
+
+  // We reach here in one of the following conditions:
+  // 1) If schedule changes don't result in changes in the status, we need to
+  // explicitly update the timer to re-schedule the next toggle to account for
+  // any changes.
+  // 2) The user has just manually toggled the status of NightLight either from
+  // the System Menu or System Settings. In this case, we respect the user
+  // wish and maintain the current status that he desires, but we schedule the
+  // status to be toggled according to the time that corresponds with the
+  // opposite status of the current one.
+  ScheduleNextToggle(GetEnabled() ? end_time - now : start_time - now);
+}
+
+void NightLightController::ScheduleNextToggle(base::TimeDelta delay) {
+  timer_.Start(
+      FROM_HERE, delay,
+      base::Bind(&NightLightController::SetEnabled, base::Unretained(this),
+                 !GetEnabled(), AnimationDurationType::kLong));
 }
 
 }  // namespace ash