base/i18n/time_formatting.cc

   1 // Copyright 2011 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/i18n/time_formatting.h"
   6
   7 #include <stddef.h>
   8
   9 #include <memory>
  10 #include <string>
  11
  12 #include "base/i18n/unicodestring.h"
  13 #include "base/logging.h"
  14 #include "base/notreached.h"
  15 #include "base/numerics/safe_conversions.h"
  16 #include "base/strings/string_piece.h"
  17 #include "base/strings/utf_string_conversions.h"
  18 #include "base/time/time.h"
  19 #include "build/chromeos_buildflags.h"
  20 #include "third_party/icu/source/common/unicode/locid.h"
  21 #include "third_party/icu/source/common/unicode/utypes.h"
  22 #include "third_party/icu/source/i18n/unicode/datefmt.h"
  23 #include "third_party/icu/source/i18n/unicode/dtitvfmt.h"
  24 #include "third_party/icu/source/i18n/unicode/dtptngen.h"
  25 #include "third_party/icu/source/i18n/unicode/fmtable.h"
  26 #include "third_party/icu/source/i18n/unicode/measfmt.h"
  27 #include "third_party/icu/source/i18n/unicode/smpdtfmt.h"
  28 #include "third_party/icu/source/i18n/unicode/timezone.h"
  29
  30 namespace base {
  31 namespace {
  32
  33 UDate ToUDate(const Time& time) {
  34   // TODO(crbug.com/1392437): Consider using the `...IgnoringNull` variant and
  35   // adding a `CHECK(!time.is_null())`; trying to format a null Time as a string
  36   // is almost certainly an indication that the caller has made a mistake.
  37   return time.InMillisecondsFSinceUnixEpoch();
  38 }
  39
  40 std::u16string TimeFormat(const icu::DateFormat& formatter, const Time& time) {
  41   icu::UnicodeString date_string;
  42
  43   formatter.format(ToUDate(time), date_string);
  44   return i18n::UnicodeStringToString16(date_string);
  45 }
  46
  47 std::u16string TimeFormatWithoutAmPm(const icu::DateFormat* formatter,
  48                                      const Time& time) {
  49   DCHECK(formatter);
  50   icu::UnicodeString time_string;
  51
  52   icu::FieldPosition ampm_field(icu::DateFormat::kAmPmField);
  53   formatter->format(ToUDate(time), time_string, ampm_field);
  54   int ampm_length = ampm_field.getEndIndex() - ampm_field.getBeginIndex();
  55   if (ampm_length) {
  56     int begin = ampm_field.getBeginIndex();
  57     // Doesn't include any spacing before the field.
  58     if (begin)
  59       begin--;
  60     time_string.removeBetween(begin, ampm_field.getEndIndex());
  61   }
  62   return i18n::UnicodeStringToString16(time_string);
  63 }
  64
  65 icu::SimpleDateFormat CreateSimpleDateFormatter(
  66     StringPiece pattern,
  67     bool generate_pattern = true,
  68     const icu::Locale& locale = icu::Locale::getDefault()) {
  69   UErrorCode status = U_ZERO_ERROR;
  70   icu::UnicodeString generated_pattern(pattern.data(), pattern.length());
  71
  72   if (generate_pattern) {
  73     // Generate a locale-dependent format pattern. The generator will take
  74     // care of locale-dependent formatting issues like which separator to
  75     // use (some locales use '.' instead of ':'), and where to put the am/pm
  76     // marker.
  77     std::unique_ptr<icu::DateTimePatternGenerator> generator(
  78         icu::DateTimePatternGenerator::createInstance(status));
  79     DCHECK(U_SUCCESS(status));
  80     generated_pattern = generator->getBestPattern(generated_pattern, status);
  81     DCHECK(U_SUCCESS(status));
  82   }
  83
  84   // Then, format the time using the desired pattern.
  85   icu::SimpleDateFormat formatter(generated_pattern, locale, status);
  86   DCHECK(U_SUCCESS(status));
  87
  88   return formatter;
  89 }
  90
  91 UMeasureFormatWidth DurationWidthToMeasureWidth(DurationFormatWidth width) {
  92   switch (width) {
  93     case DURATION_WIDTH_WIDE: return UMEASFMT_WIDTH_WIDE;
  94     case DURATION_WIDTH_SHORT: return UMEASFMT_WIDTH_SHORT;
  95     case DURATION_WIDTH_NARROW: return UMEASFMT_WIDTH_NARROW;
  96     case DURATION_WIDTH_NUMERIC: return UMEASFMT_WIDTH_NUMERIC;
  97   }
  98   NOTREACHED();
  99   return UMEASFMT_WIDTH_COUNT;
 100 }
 101
 102 const char* DateFormatToString(DateFormat format) {
 103   switch (format) {
 104     case DATE_FORMAT_YEAR_MONTH:
 105       return UDAT_YEAR_MONTH;
 106     case DATE_FORMAT_MONTH_WEEKDAY_DAY:
 107       return UDAT_MONTH_WEEKDAY_DAY;
 108   }
 109   NOTREACHED();
 110   return UDAT_YEAR_MONTH_DAY;
 111 }
 112
 113 }  // namespace
 114
 115 std::u16string TimeFormatTimeOfDay(const Time& time) {
 116   // We can omit the locale parameter because the default should match
 117   // Chrome's application locale.
 118   std::unique_ptr<icu::DateFormat> formatter(
 119       icu::DateFormat::createTimeInstance(icu::DateFormat::kShort));
 120   return TimeFormat(*formatter, time);
 121 }
 122
 123 std::u16string TimeFormatTimeOfDayWithMilliseconds(const Time& time) {
 124   icu::SimpleDateFormat formatter = CreateSimpleDateFormatter("HmsSSS");
 125   return TimeFormatWithoutAmPm(&formatter, time);
 126 }
 127
 128 std::u16string TimeFormatTimeOfDayWithHourClockType(const Time& time,
 129                                                     HourClockType type,
 130                                                     AmPmClockType ampm) {
 131   // Just redirect to the normal function if the default type matches the
 132   // given type.
 133   HourClockType default_type = GetHourClockType();
 134   if (default_type == type && (type == k24HourClock || ampm == kKeepAmPm)) {
 135     return TimeFormatTimeOfDay(time);
 136   }
 137
 138   const char* base_pattern = (type == k12HourClock ? "ahm" : "Hm");
 139   icu::SimpleDateFormat formatter = CreateSimpleDateFormatter(base_pattern);
 140
 141   return (ampm == kKeepAmPm) ? TimeFormat(formatter, time)
 142                              : TimeFormatWithoutAmPm(&formatter, time);
 143 }
 144
 145 std::u16string TimeFormatShortDate(const Time& time) {
 146   std::unique_ptr<icu::DateFormat> formatter(
 147       icu::DateFormat::createDateInstance(icu::DateFormat::kMedium));
 148   return TimeFormat(*formatter, time);
 149 }
 150
 151 std::u16string TimeFormatShortDateNumeric(const Time& time) {
 152   std::unique_ptr<icu::DateFormat> formatter(
 153       icu::DateFormat::createDateInstance(icu::DateFormat::kShort));
 154   return TimeFormat(*formatter, time);
 155 }
 156
 157 std::u16string TimeFormatShortDateAndTime(const Time& time) {
 158   std::unique_ptr<icu::DateFormat> formatter(
 159       icu::DateFormat::createDateTimeInstance(icu::DateFormat::kShort));
 160   return TimeFormat(*formatter, time);
 161 }
 162
 163 std::u16string TimeFormatShortDateAndTimeWithTimeZone(const Time& time) {
 164   std::unique_ptr<icu::DateFormat> formatter(
 165       icu::DateFormat::createDateTimeInstance(icu::DateFormat::kShort,
 166                                               icu::DateFormat::kLong));
 167   return TimeFormat(*formatter, time);
 168 }
 169
 170 #if BUILDFLAG(IS_CHROMEOS_ASH)
 171 std::u16string TimeFormatMonthAndYearForTimeZone(
 172     const Time& time,
 173     const icu::TimeZone* time_zone) {
 174   icu::SimpleDateFormat formatter =
 175       CreateSimpleDateFormatter(DateFormatToString(DATE_FORMAT_YEAR_MONTH));
 176   formatter.setTimeZone(*time_zone);
 177   return TimeFormat(formatter, time);
 178 }
 179 #endif
 180
 181 std::u16string TimeFormatMonthAndYear(const Time& time) {
 182   return TimeFormat(
 183       CreateSimpleDateFormatter(DateFormatToString(DATE_FORMAT_YEAR_MONTH)),
 184       time);
 185 }
 186
 187 std::u16string TimeFormatFriendlyDateAndTime(const Time& time) {
 188   std::unique_ptr<icu::DateFormat> formatter(
 189       icu::DateFormat::createDateTimeInstance(icu::DateFormat::kFull));
 190   return TimeFormat(*formatter, time);
 191 }
 192
 193 std::u16string TimeFormatFriendlyDate(const Time& time) {
 194   std::unique_ptr<icu::DateFormat> formatter(
 195       icu::DateFormat::createDateInstance(icu::DateFormat::kFull));
 196   return TimeFormat(*formatter, time);
 197 }
 198
 199 std::u16string LocalizedTimeFormatWithPattern(const Time& time,
 200                                               StringPiece pattern) {
 201   return TimeFormat(CreateSimpleDateFormatter(std::move(pattern)), time);
 202 }
 203
 204 std::string UnlocalizedTimeFormatWithPattern(const Time& time,
 205                                              StringPiece pattern,
 206                                              const icu::TimeZone* time_zone) {
 207   icu::SimpleDateFormat formatter =
 208       CreateSimpleDateFormatter({}, false, icu::Locale("en_US"));
 209   if (time_zone) {
 210     formatter.setTimeZone(*time_zone);
 211   }
 212
 213   // Formats `time` according to `pattern`.
 214   const auto format_time = [&formatter](const Time& time, StringPiece pattern) {
 215     formatter.applyPattern(
 216         icu::UnicodeString(pattern.data(), pattern.length()));
 217     return base::UTF16ToUTF8(TimeFormat(formatter, time));
 218   };
 219
 220   // If `time` has nonzero microseconds, check if the caller requested
 221   // microsecond-precision output; this must be handled internally since
 222   // `SimpleDateFormat` won't do it.
 223   std::string output;
 224   if (const int64_t microseconds =
 225           time.ToDeltaSinceWindowsEpoch().InMicroseconds() %
 226           Time::kMicrosecondsPerMillisecond) {
 227     // Adds digits to `output` for each 'S' at the start of `pattern`.
 228     const auto format_microseconds = [&output](int64_t mutable_micros,
 229                                                StringPiece pattern) {
 230       size_t i = 0;
 231       for (; i < pattern.length() && pattern[i] == 'S'; ++i) {
 232         output += static_cast<char>('0' + mutable_micros / 100);
 233         mutable_micros = (mutable_micros % 100) * 10;
 234       }
 235       return i;
 236     };
 237
 238     // Look for fractional seconds patterns with greater-than-millisecond
 239     // precision.
 240     bool in_quotes = false;
 241     for (size_t i = 0; i < pattern.length();) {
 242       if (pattern[i] == '\'') {
 243         in_quotes = !in_quotes;
 244       } else if (!in_quotes && !pattern.compare(i, 4, "SSSS")) {
 245         // Let ICU format everything up through milliseconds.
 246         const size_t fourth_s = i + 3;
 247         if (i != 0) {
 248           output += format_time(time, pattern.substr(0, fourth_s));
 249         }
 250
 251         // Add microseconds digits, then truncate to the remaining pattern.
 252         pattern = pattern.substr(
 253             fourth_s +
 254             format_microseconds(microseconds, pattern.substr(fourth_s)));
 255         i = 0;
 256         continue;
 257       }
 258       ++i;
 259     }
 260   }
 261
 262   // Format any remaining pattern.
 263   if (!pattern.empty()) {
 264     output += format_time(time, std::move(pattern));
 265   }
 266   return output;
 267 }
 268
 269 std::string TimeFormatAsIso8601(const Time& time) {
 270   return UnlocalizedTimeFormatWithPattern(time, "yyyy-MM-dd'T'HH:mm:ss.SSSX",
 271                                           icu::TimeZone::getGMT());
 272 }
 273
 274 std::string TimeFormatHTTP(const Time& time) {
 275   return UnlocalizedTimeFormatWithPattern(time, "E, dd MMM yyyy HH:mm:ss O",
 276                                           icu::TimeZone::getGMT());
 277 }
 278
 279 bool TimeDurationFormat(TimeDelta time,
 280                         DurationFormatWidth width,
 281                         std::u16string* out) {
 282   DCHECK(out);
 283   UErrorCode status = U_ZERO_ERROR;
 284   const int total_minutes = ClampRound(time / base::Minutes(1));
 285   const int hours = total_minutes / 60;
 286   const int minutes = total_minutes % 60;
 287   UMeasureFormatWidth u_width = DurationWidthToMeasureWidth(width);
 288
 289   // TODO(derat): Delete the |status| checks and LOG(ERROR) calls throughout
 290   // this function once the cause of http://crbug.com/677043 is tracked down.
 291   const icu::Measure measures[] = {
 292       icu::Measure(hours, icu::MeasureUnit::createHour(status), status),
 293       icu::Measure(minutes, icu::MeasureUnit::createMinute(status), status)};
 294   if (U_FAILURE(status)) {
 295     LOG(ERROR) << "Creating MeasureUnit or Measure for " << hours << "h"
 296                << minutes << "m failed: " << u_errorName(status);
 297     return false;
 298   }
 299
 300   icu::MeasureFormat measure_format(icu::Locale::getDefault(), u_width, status);
 301   if (U_FAILURE(status)) {
 302     LOG(ERROR) << "Creating MeasureFormat for "
 303                << icu::Locale::getDefault().getName()
 304                << " failed: " << u_errorName(status);
 305     return false;
 306   }
 307
 308   icu::UnicodeString formatted;
 309   icu::FieldPosition ignore(icu::FieldPosition::DONT_CARE);
 310   measure_format.formatMeasures(measures, 2, formatted, ignore, status);
 311   if (U_FAILURE(status)) {
 312     LOG(ERROR) << "formatMeasures failed: " << u_errorName(status);
 313     return false;
 314   }
 315
 316   *out = i18n::UnicodeStringToString16(formatted);
 317   return true;
 318 }
 319
 320 bool TimeDurationFormatWithSeconds(TimeDelta time,
 321                                    DurationFormatWidth width,
 322                                    std::u16string* out) {
 323   DCHECK(out);
 324   UErrorCode status = U_ZERO_ERROR;
 325   const int64_t total_seconds = ClampRound<int64_t>(time.InSecondsF());
 326   const int64_t hours = total_seconds / base::Time::kSecondsPerHour;
 327   const int64_t minutes =
 328       (total_seconds - hours * base::Time::kSecondsPerHour) /
 329       base::Time::kSecondsPerMinute;
 330   const int64_t seconds = total_seconds % base::Time::kSecondsPerMinute;
 331   UMeasureFormatWidth u_width = DurationWidthToMeasureWidth(width);
 332
 333   const icu::Measure measures[] = {
 334       icu::Measure(hours, icu::MeasureUnit::createHour(status), status),
 335       icu::Measure(minutes, icu::MeasureUnit::createMinute(status), status),
 336       icu::Measure(seconds, icu::MeasureUnit::createSecond(status), status)};
 337   icu::MeasureFormat measure_format(icu::Locale::getDefault(), u_width, status);
 338   icu::UnicodeString formatted;
 339   icu::FieldPosition ignore(icu::FieldPosition::DONT_CARE);
 340   measure_format.formatMeasures(measures, 3, formatted, ignore, status);
 341   *out = i18n::UnicodeStringToString16(formatted);
 342   return U_SUCCESS(status);
 343 }
 344
 345 std::u16string DateIntervalFormat(const Time& begin_time,
 346                                   const Time& end_time,
 347                                   DateFormat format) {
 348   UErrorCode status = U_ZERO_ERROR;
 349
 350   std::unique_ptr<icu::DateIntervalFormat> formatter(
 351       icu::DateIntervalFormat::createInstance(DateFormatToString(format),
 352                                               status));
 353
 354   icu::FieldPosition pos = 0;
 355   UDate start_date = ToUDate(begin_time);
 356   UDate end_date = ToUDate(end_time);
 357   icu::DateInterval interval(start_date, end_date);
 358   icu::UnicodeString formatted;
 359   formatter->format(&interval, formatted, pos, status);
 360   return i18n::UnicodeStringToString16(formatted);
 361 }
 362
 363 HourClockType GetHourClockType() {
 364   // TODO(satorux,jshin): Rework this with ures_getByKeyWithFallback()
 365   // once it becomes public. The short time format can be found at
 366   // "calendar/gregorian/DateTimePatterns/3" in the resources.
 367   std::unique_ptr<icu::SimpleDateFormat> formatter(
 368       static_cast<icu::SimpleDateFormat*>(
 369           icu::DateFormat::createTimeInstance(icu::DateFormat::kShort)));
 370   // Retrieve the short time format.
 371   icu::UnicodeString pattern_unicode;
 372   formatter->toPattern(pattern_unicode);
 373
 374   // Determine what hour clock type the current locale uses, by checking
 375   // "a" (am/pm marker) in the short time format. This is reliable as "a"
 376   // is used by all of 12-hour clock formats, but not any of 24-hour clock
 377   // formats, as shown below.
 378   //
 379   // % grep -A4 DateTimePatterns third_party/icu/source/data/locales/*.txt |
 380   //   grep -B1 -- -- |grep -v -- '--' |
 381   //   perl -nle 'print $1 if /^\S+\s+"(.*)"/' |sort -u
 382   //
 383   // H.mm
 384   // H:mm
 385   // HH.mm
 386   // HH:mm
 387   // a h:mm
 388   // ah:mm
 389   // ahh:mm
 390   // h-mm a
 391   // h:mm a
 392   // hh:mm a
 393   //
 394   // See http://userguide.icu-project.org/formatparse/datetime for details
 395   // about the date/time format syntax.
 396   return pattern_unicode.indexOf('a') == -1 ? k24HourClock : k12HourClock;
 397 }
 398
 399 }  // namespace base