Week picker for android

content/renderer/date_time_formatter.cc

 // Copyright (c) 2013 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 "content/renderer/date_time_formatter.h"
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebCString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDateTimeChooserParams.h"
 #include "third_party/icu/public/i18n/unicode/smpdtfmt.h"
 
 
 namespace content {
 
 void DateTimeFormatter::CreatePatternMap() {
   // Initialize all the UI elements with empty patterns,
   // then fill in the ones that are actually date/time inputs and
   // are implemented.
   for (int i = 0 ; i <= ui::TEXT_INPUT_TYPE_MAX; ++i) {
     patterns_[i] = "";
   }
   patterns_[ui::TEXT_INPUT_TYPE_DATE] = "yyyy-MM-dd";
   patterns_[ui::TEXT_INPUT_TYPE_DATE_TIME] =  "yyyy-MM-dd'T'HH:mm'Z'";
   patterns_[ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL] =  "yyyy-MM-dd'T'HH:mm";
   patterns_[ui::TEXT_INPUT_TYPE_MONTH] = "yyyy-MM";
   patterns_[ui::TEXT_INPUT_TYPE_TIME] = "HH:mm";
+  patterns_[ui::TEXT_INPUT_TYPE_WEEK] = "Y-'W'ww";
 }
 
 DateTimeFormatter::DateTimeFormatter(
     const WebKit::WebDateTimeChooserParams& source)
   : formatted_string_(source.currentValue.utf8()) {
   CreatePatternMap();
   ExtractType(source);
   if (!ParseValues()) {
     type_ = ui::TEXT_INPUT_TYPE_NONE;
     ClearAll();
     LOG(WARNING) << "Problems parsing input <" << formatted_string_ << ">";
   }
 }
 
 DateTimeFormatter::DateTimeFormatter(
     ui::TextInputType type,
-    int year, int month, int day, int hour, int minute, int second)
+    int year, int month, int day, int hour, int minute, int second,
+    int week_year, int week)
   : type_(type),
     year_(year),
     month_(month),
     day_(day),
     hour_(hour),
     minute_(minute),
-    second_(second) {
+    second_(second),
+    week_year_(week_year),
+    week_(week) {
   CreatePatternMap();
   pattern_ = type_ > 0 && type_ <= ui::TEXT_INPUT_TYPE_MAX ?
       &patterns_[type_] : &patterns_[ui::TEXT_INPUT_TYPE_NONE];
 
   formatted_string_ = FormatString();
 }
 
 DateTimeFormatter::~DateTimeFormatter() {
 }
 
@@ skipping 14 matching lines @@
 }
 
 int DateTimeFormatter::GetMinute() const {
   return minute_;
 }
 
 int DateTimeFormatter::GetSecond() const {
   return second_;
 }
 
+int DateTimeFormatter::GetWeekYear() const {
+  return week_year_;
+}
+
+int DateTimeFormatter::GetWeek() const {
+  return week_;
+}
+
 ui::TextInputType DateTimeFormatter::GetType() const {
   return type_;
 }
 
 const std::string& DateTimeFormatter::GetFormattedValue() const {
   return formatted_string_;
 }
 
 const std::string DateTimeFormatter::FormatString() const {
   UErrorCode success = U_ZERO_ERROR;
   if (year_ == 0 && month_ == 0 && day_ == 0 &&
-      hour_ == 0 && minute_ == 0 && second_ == 0) {
+      hour_ == 0 && minute_ == 0 && second_ == 0 &&
+      week_year_ == 0 && week_ == 0) {
     return std::string();
   }
 
   std::string result;
-  const icu::GregorianCalendar calendar(
-      year_, month_, day_, hour_, minute_, second_, success);
+  icu::GregorianCalendar calendar(success);
+  if (type_ == ui::TEXT_INPUT_TYPE_WEEK) {

[Miguel Garcia, 2013/05/10 15:17:59]

you probably want to check that success is still true right?

[keishi, 2013/05/14 13:47:47]

Done.

+    calendar.setMinimalDaysInFirstWeek(4);

[Miguel Garcia, 2013/05/10 15:17:59]

I think some comment on why this is needed would be important. 

[keishi, 2013/05/14 13:47:47]

Done.

+    calendar.setFirstDayOfWeek(UCAL_MONDAY);

[Miguel Garcia, 2013/05/10 15:17:59]

Doesn't this depend on the locale?

[keishi, 2013/05/14 13:47:47]

ISO weeks always start from Monday regardless of locale.

+    calendar.set(UCAL_YEAR_WOY, week_year_);
+    calendar.set(UCAL_WEEK_OF_YEAR, week_);
+  } else {

[Miguel Garcia, 2013/05/10 15:17:59]

it seems you can anyway set year, month... in all cases (they will be 0
sometimes) and in addition to that set setMinimalDaysInFirstWeek and
setFirstDayOfWeek only if input type is week. I still don't understand why you
need those two things and why could they not be setup in all cases.

[keishi, 2013/05/14 13:47:47]

I may not be understanding you correctly. Are you saying I should set all fields
without checking the type? Like this:

calendar.setMinimalDaysInFirstWeek(4);
calendar.setFirstDayOfWeek(UCAL_MONDAY);
calendar.set(UCAL_YEAR, year_);
calendar.set(UCAL_MONTH, month_);
calendar.set(UCAL_DATE, day_);
calendar.set(UCAL_HOUR_OF_DAY, hour_);
calendar.set(UCAL_MINUTE, minute_);
calendar.set(UCAL_SECOND, second_);
calendar.set(UCAL_YEAR_WOY, week_year_);
calendar.set(UCAL_WEEK_OF_YEAR, week_);

If there is an invalid value in even one of the fields calendar.getTime(success)
will fail, so it won't work.

[Miguel Garcia, 2013/05/17 11:23:38]

I'm still hesitant to special case week here, can we simply check wether the
value returned by calendar.getTime() is > 0 and set it to 0 otherwise? The date
spec does not allow values below 0 for anything

http://www.w3.org/TR/html-markup/datatypes.html#form.data.date

On 2013/05/14 13:47:47, keishi1 wrote:

[keishi, 2013/05/22 07:33:26]

calendar.getTime() will return milliseconds since epoch(1970-01-01) so we can't
check if its greater than 0. According to the spec we need to support dates
between 0001-01-01 and 275760-09-12.

[Miguel Garcia, 2013/05/23 18:38:49]

Ok, I think you've convinced me :)

On 2013/05/22 07:33:26, keishi1 wrote:

+    calendar.set(UCAL_YEAR, year_);
+    calendar.set(UCAL_MONTH, month_);
+    calendar.set(UCAL_DATE, day_);
+    calendar.set(UCAL_HOUR_OF_DAY, hour_);
+    calendar.set(UCAL_MINUTE, minute_);
+    calendar.set(UCAL_SECOND, second_);
+  }
   if (success <= U_ZERO_ERROR) {
     UDate time = calendar.getTime(success);
     icu::SimpleDateFormat formatter(*pattern_, success);
     icu::UnicodeString formatted_time;
     formatter.format(time, formatted_time, success);
     UTF16ToUTF8(formatted_time.getBuffer(),
                 static_cast<size_t>(formatted_time.length()),
                 &result);
     if (success <= U_ZERO_ERROR)
       return result;
@@ skipping 14 matching lines @@
     case WebKit::WebDateTimeInputTypeDateTimeLocal:
       type_ = ui::TEXT_INPUT_TYPE_DATE_TIME_LOCAL;
       break;
     case WebKit::WebDateTimeInputTypeMonth:
       type_ = ui::TEXT_INPUT_TYPE_MONTH;
       break;
     case WebKit::WebDateTimeInputTypeTime:
       type_ = ui::TEXT_INPUT_TYPE_TIME;
       break;
     case WebKit::WebDateTimeInputTypeWeek: // Not implemented
+      type_ = ui::TEXT_INPUT_TYPE_WEEK;
+      break;
     case WebKit::WebDateTimeInputTypeNone:
     default:
       type_ = ui::TEXT_INPUT_TYPE_NONE;
   }
 }
 
 // Not all fields are defined in all configurations and ICU might store
 // garbage if success <= U_ZERO_ERROR so the output is sanitized here.
 int DateTimeFormatter::ExtractValue(
     const icu::Calendar* calendar, UCalendarDateFields value) const {
@@ skipping 21 matching lines @@
     icu::SimpleDateFormat formatter(pattern, success);
     formatter.parse(icu_value, success);
     if (success <= U_ZERO_ERROR) {
       const icu::Calendar* cal = formatter.getCalendar();
       year_ = ExtractValue(cal, UCAL_YEAR);
       month_ = ExtractValue(cal, UCAL_MONTH);
       day_ = ExtractValue(cal, UCAL_DATE);
       hour_ = ExtractValue(cal, UCAL_HOUR_OF_DAY);  // 24h format
       minute_ = ExtractValue(cal, UCAL_MINUTE);
       second_ = ExtractValue(cal, UCAL_SECOND);
+      week_year_ = ExtractValue(cal, UCAL_YEAR_WOY);
+      week_ = ExtractValue(cal, UCAL_WEEK_OF_YEAR);
     }
   }
 
   return (success <= U_ZERO_ERROR);
 }
 
 void DateTimeFormatter::ClearAll() {
   year_ = 0;
   month_ = 0;
   day_ = 0;
   hour_ = 0;
   minute_ = 0;
   second_ = 0;
+  week_year_ = 0;
+  week_ = 0;
 }
 
 }  // namespace content