ash / system / time / date_helper.cc [blame]

// Copyright 2022 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/time/date_helper.h"

#include "ash/shell.h"
#include "ash/system/locale/locale_update_controller_impl.h"
#include "ash/system/model/clock_model.h"
#include "ash/system/model/system_tray_model.h"
#include "ash/system/time/calendar_utils.h"
#include "base/containers/contains.h"
#include "base/i18n/unicodestring.h"
#include "base/memory/ptr_util.h"
#include "base/time/time.h"
#include "third_party/icu/source/common/unicode/dtintrv.h"
#include "third_party/icu/source/i18n/unicode/dtitvfmt.h"
#include "third_party/icu/source/i18n/unicode/fieldpos.h"
#include "third_party/icu/source/i18n/unicode/gregocal.h"

namespace ash {

namespace {

// Milliseconds per minute.
constexpr int kMillisecondsPerMinute = 60000;

// Default week title for a few special languages that cannot find the start of
// a week. So far the known languages that cannot return their day of week are:
// 'bn', 'fa', 'mr', 'pa-PK'.
const std::vector<std::u16string> kDefaultWeekTitle = {u"S", u"M", u"T", u"W",
                                                       u"T", u"F", u"S"};

UDate TimeToUDate(const base::Time& time) {
  return static_cast<UDate>(time.InSecondsFSinceUnixEpoch() *
                            base::Time::kMillisecondsPerSecond);
}

// Receives an input `unicode_pattern` in the "Hm" format (HH:mm, aK:mm, h:mm a,
// a hh:mm, etc.) and extracts the hours part of the pattern.
icu::UnicodeString getHoursPattern(const icu::UnicodeString& unicode_pattern) {
  std::string pattern;
  unicode_pattern.toUTF8String(pattern);

  if (base::Contains(pattern, "hh")) {
    return icu::UnicodeString("hh");
  }
  if (base::Contains(pattern, "h")) {
    return icu::UnicodeString("h");
  }
  if (base::Contains(pattern, "HH")) {
    return icu::UnicodeString("HH");
  }
  if (base::Contains(pattern, "H")) {
    return icu::UnicodeString("H");
  }
  if (base::Contains(pattern, "KK")) {
    return icu::UnicodeString("KK");
  }
  if (base::Contains(pattern, "K")) {
    return icu::UnicodeString("K");
  }
  if (base::Contains(pattern, "kk")) {
    return icu::UnicodeString("kk");
  }
  if (base::Contains(pattern, "k")) {
    return icu::UnicodeString("k");
  }

  NOTREACHED() << "Hours pattern not found.";
}

}  // namespace

// static
DateHelper* DateHelper::GetInstance() {
  return base::Singleton<DateHelper>::get();
}

icu::SimpleDateFormat DateHelper::CreateSimpleDateFormatter(
    const char* pattern) {
  // Generate a locale-dependent format pattern. The generator will take
  // care of locale-dependent formatting issues like which separator to
  // use (some locales use '.' instead of ':'), and where to put the am/pm
  // marker.
  UErrorCode status = U_ZERO_ERROR;
  DCHECK(U_SUCCESS(status));
  std::unique_ptr<icu::DateTimePatternGenerator> generator(
      icu::DateTimePatternGenerator::createInstance(status));
  DCHECK(U_SUCCESS(status));
  icu::UnicodeString generated_pattern =
      generator->getBestPattern(icu::UnicodeString(pattern), status);
  DCHECK(U_SUCCESS(status));

  // Then, create a formatter object using the generated pattern.
  icu::SimpleDateFormat formatter(generated_pattern, status);
  DCHECK(U_SUCCESS(status));

  return formatter;
}

icu::SimpleDateFormat DateHelper::CreateSimpleDateFormatterWithoutBestPattern(
    const char* pattern) {
  UErrorCode status = U_ZERO_ERROR;
  DCHECK(U_SUCCESS(status));
  icu::SimpleDateFormat formatter(icu::UnicodeString(pattern), status);
  DCHECK(U_SUCCESS(status));
  return formatter;
}

std::unique_ptr<icu::DateIntervalFormat>
DateHelper::CreateDateIntervalFormatter(const char* pattern) {
  UErrorCode status = U_ZERO_ERROR;
  icu::DateIntervalFormat* formatter =
      icu::DateIntervalFormat::createInstance(pattern, status);
  DCHECK(U_SUCCESS(status));
  return base::WrapUnique(formatter);
}

icu::SimpleDateFormat DateHelper::CreateHoursFormatter(const char* pattern) {
  UErrorCode status = U_ZERO_ERROR;
  DCHECK(U_SUCCESS(status));
  std::unique_ptr<icu::DateTimePatternGenerator> generator(
      icu::DateTimePatternGenerator::createInstance(status));
  DCHECK(U_SUCCESS(status));
  icu::UnicodeString generated_pattern =
      generator->getBestPattern(icu::UnicodeString(pattern), status);
  DCHECK(U_SUCCESS(status));
  // Since ICU 74, getBestPattern can return a gibberish pattern ""H
  // ├'Minute': m┤ ├'Dayperiod': a┤"" if the locale resource is missing. Instead
  // of using the gibberish pattern, this should fallback to the proposed
  // pattern.
  std::string gen_string;
  generated_pattern.toUTF8String(gen_string);
  if (base::Contains(gen_string, "├")) {
    // Fallback to the suggested pattern.
    generated_pattern = icu::UnicodeString(pattern);
  }
  // Extract the hours from the generated pattern.
  icu::UnicodeString hours_pattern = getHoursPattern(generated_pattern);
  icu::SimpleDateFormat formatter(hours_pattern, status);
  DCHECK(U_SUCCESS(status));

  return formatter;
}

std::u16string DateHelper::GetFormattedTime(const icu::DateFormat* formatter,
                                            const base::Time& time) {
  DCHECK(formatter);
  icu::UnicodeString date_string;

  formatter->format(TimeToUDate(time), date_string);
  return base::i18n::UnicodeStringToString16(date_string);
}

std::u16string DateHelper::GetFormattedInterval(
    const icu::DateIntervalFormat* formatter,
    const base::Time& start_time,
    const base::Time& end_time) {
  DCHECK(formatter);
  UErrorCode status = U_ZERO_ERROR;
  icu::DateInterval interval(TimeToUDate(start_time), TimeToUDate(end_time));
  icu::FieldPosition position = 0;
  icu::UnicodeString interval_string;
  formatter->format(&interval, interval_string, position, status);
  DCHECK(U_SUCCESS(status));
  return base::i18n::UnicodeStringToString16(interval_string);
}

base::TimeDelta DateHelper::GetTimeDifference(base::Time date) const {
  const icu::TimeZone& time_zone =
      system::TimezoneSettings::GetInstance()->GetTimezone();
  const base::TimeDelta raw_time_diff =
      base::Minutes(time_zone.getRawOffset() / kMillisecondsPerMinute);

  // Calculates the time difference adjust by the possible daylight savings
  // offset. If the status of any step fails, returns the default time
  // difference without considering daylight savings.
  if (!gregorian_calendar_) {
    return raw_time_diff;
  }

  UDate current_date = TimeToUDate(date);
  UErrorCode status = U_ZERO_ERROR;
  gregorian_calendar_->setTime(current_date, status);
  if (U_FAILURE(status)) {
    return raw_time_diff;
  }

  status = U_ZERO_ERROR;
  UBool day_light = gregorian_calendar_->inDaylightTime(status);
  if (U_FAILURE(status)) {
    return raw_time_diff;
  }

  int gmt_offset = time_zone.getRawOffset();
  if (day_light) {
    gmt_offset += time_zone.getDSTSavings();
  }

  return base::Minutes(gmt_offset / kMillisecondsPerMinute);
}

base::Time DateHelper::GetLocalMidnight(base::Time date) {
  base::TimeDelta time_difference = GetTimeDifference(date);
  return (date + time_difference).UTCMidnight() - time_difference;
}

DateHelper::DateHelper()
    : day_of_month_formatter_(CreateSimpleDateFormatter("d")),
      month_day_formatter_(CreateSimpleDateFormatter("MMMMd")),
      month_day_year_formatter_(CreateSimpleDateFormatter("MMMMdyyyy")),
      month_day_year_week_formatter_(
          CreateSimpleDateFormatter("MMMMEEEEdyyyy")),
      month_name_formatter_(CreateSimpleDateFormatter("MMMM")),
      month_name_year_formatter_(CreateSimpleDateFormatter("MMMM yyyy")),
      time_zone_formatter_(CreateSimpleDateFormatter("zzzz")),
      twelve_hour_clock_formatter_(CreateSimpleDateFormatter("h:mm a")),
      twenty_four_hour_clock_formatter_(CreateSimpleDateFormatter("HH:mm")),
      day_of_week_formatter_(CreateSimpleDateFormatter("ee")),
      week_title_formatter_(CreateSimpleDateFormatter("EEEEE")),
      // Note: "yyyy" represents a four-digit calendar year (e.g. "2023"),
      // while "YYYY" represents a so called 'week year' (which might be "2022"
      // if the first day is on the last week of 2022).
      year_formatter_(CreateSimpleDateFormatter("yyyy")),
      twelve_hour_clock_hours_formatter_(CreateHoursFormatter("h:mm a")),
      twenty_four_hour_clock_hours_formatter_(CreateHoursFormatter("HH:mm")),
      minutes_formatter_(CreateSimpleDateFormatterWithoutBestPattern("mm")),
      twelve_hour_clock_interval_formatter_(CreateDateIntervalFormatter("hm")),
      twenty_four_hour_clock_interval_formatter_(
          CreateDateIntervalFormatter("Hm")) {
  const icu::TimeZone& time_zone =
      system::TimezoneSettings::GetInstance()->GetTimezone();

  UErrorCode status = U_ZERO_ERROR;
  gregorian_calendar_ =
      std::make_unique<icu::GregorianCalendar>(time_zone, status);
  DCHECK(U_SUCCESS(status));
  CalculateLocalWeekTitles();
  time_zone_settings_observer_.Observe(system::TimezoneSettings::GetInstance());

  // Not using a scoped observer since the Shell can be destructed before this
  // `DateHelper` instance gets destructed.
  Shell::Get()->locale_update_controller()->AddObserver(this);
}

DateHelper::~DateHelper() {
  if (Shell::HasInstance()) {
    Shell::Get()->locale_update_controller()->RemoveObserver(this);
  }
}

void DateHelper::ResetFormatters() {
  day_of_month_formatter_ = CreateSimpleDateFormatter("d");
  month_day_formatter_ = CreateSimpleDateFormatter("MMMMd");
  month_day_year_formatter_ = CreateSimpleDateFormatter("MMMMdyyyy");
  month_day_year_week_formatter_ = CreateSimpleDateFormatter("MMMMEEEEdyyyy");
  month_name_formatter_ = CreateSimpleDateFormatter("MMMM");
  month_name_year_formatter_ = CreateSimpleDateFormatter("MMMM yyyy");
  time_zone_formatter_ = CreateSimpleDateFormatter("zzzz");
  twelve_hour_clock_formatter_ = CreateSimpleDateFormatter("h:mm a");
  twenty_four_hour_clock_formatter_ = CreateSimpleDateFormatter("HH:mm");
  day_of_week_formatter_ = CreateSimpleDateFormatter("ee");
  week_title_formatter_ = CreateSimpleDateFormatter("EEEEE");
  year_formatter_ = CreateSimpleDateFormatter("yyyy");
  twelve_hour_clock_hours_formatter_ = CreateHoursFormatter("h:mm a");
  twenty_four_hour_clock_hours_formatter_ = CreateHoursFormatter("HH:mm");
  minutes_formatter_ = CreateSimpleDateFormatterWithoutBestPattern("mm");
  twelve_hour_clock_interval_formatter_ = CreateDateIntervalFormatter("hm");
  twenty_four_hour_clock_interval_formatter_ =
      CreateDateIntervalFormatter("Hm");
}

void DateHelper::ResetForTesting() {
  ResetFormatters();
  CalculateLocalWeekTitles();
  gregorian_calendar_->setTimeZone(
      system::TimezoneSettings::GetInstance()->GetTimezone());
}

void DateHelper::CalculateLocalWeekTitles() {
  week_titles_.clear();

  // To avoid the DST difference, use a certain date here to calculate the week
  // titles, since there are no daylight saving starts/ends in June worldwide.
  // If the `DCHECK` fails, use `Now()`.
  base::Time start_date = base::Time::Now();
  bool result = base::Time::FromString("15 Jun 2021 10:00 GMT", &start_date);
  DCHECK(result);
  start_date = GetLocalMidnight(start_date);
  std::u16string day_of_week =
      GetFormattedTime(&day_of_week_formatter_, start_date);

  // For a few special locales the day of week is not in a number. In these
  // cases, use the default week titles.
  int day_int;
  if (!base::StringToInt(day_of_week, &day_int)) {
    week_titles_ = kDefaultWeekTitle;
    return;
  }

  int safe_index = 0;
  // Find a first day of a week.
  while (day_int != 1) {
    start_date += base::Hours(25);
    day_of_week = GetFormattedTime(&day_of_week_formatter_, start_date);
    result = base::StringToInt(day_of_week, &day_int);
    DCHECK(result);
    ++safe_index;
    if (safe_index == calendar_utils::kDateInOneWeek) {
      NOTREACHED() << "Should already find the first day within 7 times, since "
                      "there are only 7 days in a week";
    }
  }

  int day_index = 0;
  while (day_index < calendar_utils::kDateInOneWeek) {
    week_titles_.push_back(
        GetFormattedTime(&week_title_formatter_, start_date));
    start_date += base::Hours(25);
    ++day_index;
  }
}

void DateHelper::TimezoneChanged(const icu::TimeZone& timezone) {
  ResetFormatters();
  gregorian_calendar_->setTimeZone(
      system::TimezoneSettings::GetInstance()->GetTimezone());
  Shell::Get()->system_tray_model()->calendar_model()->RedistributeEvents();
  Shell::Get()->system_tray_model()->clock()->NotifyRefreshClock();
}

void DateHelper::OnLocaleChanged() {
  ResetFormatters();
  CalculateLocalWeekTitles();
}

}  // namespace ash