Week picker for android

content/public/android/java/src/org/chromium/content/browser/input/WeekPicker.java

Index: content/public/android/java/src/org/chromium/content/browser/input/WeekPicker.java
diff --git a/content/public/android/java/src/org/chromium/content/browser/input/MonthPicker.java b/content/public/android/java/src/org/chromium/content/browser/input/WeekPicker.java
similarity index 57%
copy from content/public/android/java/src/org/chromium/content/browser/input/MonthPicker.java
copy to content/public/android/java/src/org/chromium/content/browser/input/WeekPicker.java
index 01e636eb10168ed3e9ff3e584d8edb3d94623eb0..283a572b7dd7fd059526cb003e08a2a808116b38 100644
--- a/content/public/android/java/src/org/chromium/content/browser/input/MonthPicker.java
+++ b/content/public/android/java/src/org/chromium/content/browser/input/WeekPicker.java
@@ -27,7 +27,7 @@ import java.util.TimeZone;
 import org.chromium.content.R;
 
 // This class is heavily based on android.widget.DatePicker.
-public class MonthPicker extends FrameLayout {
+public class WeekPicker extends FrameLayout {

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

Would it make sense to do some refactor here for the common functionality and
have MonthPicker and DatePicker extend from the same base class?

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

Done. Added BaseDatePicker.

 
     private static final int DEFAULT_START_YEAR = 1900;
 
@@ -35,17 +35,13 @@ public class MonthPicker extends FrameLayout {
 
     private static final boolean DEFAULT_ENABLED_STATE = true;
 
-    private final NumberPicker mMonthSpinner;
+    private final NumberPicker mWeekSpinner;
 
-    private final NumberPicker mYearSpinner;
+    private final NumberPicker mWeekYearSpinner;
 
     private Locale mCurrentLocale;
 
-    private OnMonthChangedListener mMonthChangedListener;
-
-    private String[] mShortMonths;
-
-    private int mNumberOfMonths;
+    private OnWeekChangedListener mWeekChangedListener;
 
     private Calendar mMinDate;
 
@@ -58,28 +54,27 @@ public class MonthPicker extends FrameLayout {
     /**
      * The callback used to indicate the user changes\d the date.
      */
-    public interface OnMonthChangedListener {
+    public interface OnWeekChangedListener {
 
         /**
          * Called upon a date change.
          *
          * @param view The view associated with this listener.
          * @param year The year that was set.
-         * @param monthOfYear The month that was set (0-11) for compatibility
-         *            with {@link java.util.Calendar}.
+         * @param weekOfYear The week in year.
          */
-        void onMonthChanged(MonthPicker view, int year, int monthOfYear);
+        void onWeekChanged(WeekPicker view, int year, int weekOfYear);
     }
 
-    public MonthPicker(Context context) {
+    public WeekPicker(Context context) {
         this(context, null);
     }
 
-    public MonthPicker(Context context, AttributeSet attrs) {
+    public WeekPicker(Context context, AttributeSet attrs) {
         this(context, attrs, android.R.attr.datePickerStyle);
     }
 
-    public MonthPicker(Context context, AttributeSet attrs, int defStyle) {
+    public WeekPicker(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
 
         // initialization based on locale
@@ -90,59 +85,52 @@ public class MonthPicker extends FrameLayout {
 
         LayoutInflater inflater = (LayoutInflater) context
                 .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
-        inflater.inflate(R.layout.month_picker, this, true);
+        inflater.inflate(R.layout.week_picker, this, true);
 
         OnValueChangeListener onChangeListener = new OnValueChangeListener() {
             @Override
             public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
-                Calendar tempDate = getCalendarForLocale(null, mCurrentLocale);
-                tempDate.setTimeInMillis(mCurrentDate.getTimeInMillis());
-
-                // take care of wrapping of days and months to update greater fields
-                if (picker == mMonthSpinner) {
-                    if (oldVal == 11 && newVal == 0) {
-                        tempDate.add(Calendar.MONTH, 1);
-                    } else if (oldVal == 0 && newVal == 11) {
-                        tempDate.add(Calendar.MONTH, -1);
+                // take care of wrapping of weeks to update greater fields
+                if (picker == mWeekSpinner) {
+                    Calendar tempDate = (Calendar) mCurrentDate.clone();
+                    if (oldVal == mWeekSpinner.getMaxValue()
+                            && newVal == mWeekSpinner.getMinValue()) {
+                        tempDate.add(Calendar.WEEK_OF_YEAR, 1);
+                    } else if (oldVal == mWeekSpinner.getMinValue()
+                            && newVal == mWeekSpinner.getMaxValue()) {
+                        tempDate.add(Calendar.WEEK_OF_YEAR, -1);
                     } else {
-                        tempDate.add(Calendar.MONTH, newVal - oldVal);
+                        tempDate.add(Calendar.WEEK_OF_YEAR, newVal - oldVal);
                     }
-                } else if (picker == mYearSpinner) {
-                    tempDate.set(Calendar.YEAR, newVal);
+                    // now set the date to the adjusted one
+                    setDate(getWeekYearForDate(tempDate), getWeekForDate(tempDate));
+                } else if (picker == mWeekYearSpinner) {
+                    setDate(newVal, getWeekForDate(mCurrentDate));
                 } else {
                     throw new IllegalArgumentException();
                 }
 
-                // now set the date to the adjusted one
-                setDate(tempDate.get(Calendar.YEAR), tempDate.get(Calendar.MONTH));
                 updateSpinners();
                 notifyDateChanged();
             }
         };
 
-        // month
-        mMonthSpinner = (NumberPicker) findViewById(R.id.month);
-        mMonthSpinner.setMinValue(0);
-        mMonthSpinner.setMaxValue(mNumberOfMonths - 1);
-        mMonthSpinner.setDisplayedValues(mShortMonths);
-        mMonthSpinner.setOnLongPressUpdateInterval(200);
-        mMonthSpinner.setOnValueChangedListener(onChangeListener);
+        // week
+        mWeekSpinner = (NumberPicker) findViewById(R.id.week);
+        mWeekSpinner.setOnLongPressUpdateInterval(200);
+        mWeekSpinner.setOnValueChangedListener(onChangeListener);
 
         // year
-        mYearSpinner = (NumberPicker) findViewById(R.id.year);
-        mYearSpinner.setOnLongPressUpdateInterval(100);
-        mYearSpinner.setOnValueChangedListener(onChangeListener);
-
-        Calendar tempDate = getCalendarForLocale(null, mCurrentLocale);
-        tempDate.set(startYear, 0, 1);
+        mWeekYearSpinner = (NumberPicker) findViewById(R.id.year);
+        mWeekYearSpinner.setOnLongPressUpdateInterval(100);
+        mWeekYearSpinner.setOnValueChangedListener(onChangeListener);
 
-        setMinDate(tempDate.getTimeInMillis());
-        tempDate.set(endYear, 11, 31);
-        setMaxDate(tempDate.getTimeInMillis());
+        setMinDate(createDateFromWeek(startYear, 1).getTimeInMillis());
+        setMaxDate(createDateFromWeek(endYear, 1).getTimeInMillis());
 
         // initialize to current date
         mCurrentDate.setTimeInMillis(System.currentTimeMillis());
-        init(mCurrentDate.get(Calendar.YEAR), mCurrentDate.get(Calendar.MONTH), null);
+        init(getWeekYearForDate(mCurrentDate), getWeekForDate(mCurrentDate), null);
     }
 
     /**
@@ -169,13 +157,13 @@ public class MonthPicker extends FrameLayout {
     public void setMinDate(long minDate) {
         Calendar tempDate = getCalendarForLocale(null, mCurrentLocale);
         tempDate.setTimeInMillis(minDate);
-        if (tempDate.get(Calendar.YEAR) == mMinDate.get(Calendar.YEAR)
-                && tempDate.get(Calendar.DAY_OF_YEAR) != mMinDate.get(Calendar.DAY_OF_YEAR)) {
+        if (getWeekYearForDate(tempDate) == getWeekYearForDate(mMinDate)
+                && getWeekForDate(tempDate) != getWeekForDate(mMinDate)) {
             return;
         }
-        mMinDate.setTimeInMillis(minDate);
+        mMinDate = tempDate;
         if (mCurrentDate.before(mMinDate)) {
-            mCurrentDate.setTimeInMillis(mMinDate.getTimeInMillis());
+            mCurrentDate = getCalendarForLocale(mMinDate, mCurrentLocale);
         }
         updateSpinners();
     }
@@ -204,13 +192,13 @@ public class MonthPicker extends FrameLayout {
     public void setMaxDate(long maxDate) {
         Calendar tempDate = getCalendarForLocale(null, mCurrentLocale);
         tempDate.setTimeInMillis(maxDate);
-        if (tempDate.get(Calendar.YEAR) == mMaxDate.get(Calendar.YEAR)
-                && tempDate.get(Calendar.DAY_OF_YEAR) != mMaxDate.get(Calendar.DAY_OF_YEAR)) {
+        if (getWeekYearForDate(tempDate) == getWeekYearForDate(mMaxDate)
+                && getWeekForDate(tempDate) != getWeekForDate(mMaxDate)) {
             return;
         }
-        mMaxDate.setTimeInMillis(maxDate);
-        if (mCurrentDate.after(mMaxDate)) {
-            mCurrentDate.setTimeInMillis(mMaxDate.getTimeInMillis());
+        mMaxDate = tempDate;
+        if (mCurrentDate.before(mMinDate)) {
+            mCurrentDate = getCalendarForLocale(mMaxDate, mCurrentLocale);
         }
         updateSpinners();
     }
@@ -221,8 +209,8 @@ public class MonthPicker extends FrameLayout {
             return;
         }
         super.setEnabled(enabled);
-        mMonthSpinner.setEnabled(enabled);
-        mYearSpinner.setEnabled(enabled);
+        mWeekSpinner.setEnabled(enabled);
+        mWeekYearSpinner.setEnabled(enabled);
         mIsEnabled = enabled;
     }
 
@@ -267,10 +255,6 @@ public class MonthPicker extends FrameLayout {
         mMinDate = getCalendarForLocale(mMinDate, locale);
         mMaxDate = getCalendarForLocale(mMaxDate, locale);
         mCurrentDate = getCalendarForLocale(mCurrentDate, locale);
-
-        mShortMonths =
-                DateFormatSymbols.getInstance(mCurrentLocale).getShortMonths();
-        mNumberOfMonths = mShortMonths.length;
     }
 
     /**
@@ -280,27 +264,29 @@ public class MonthPicker extends FrameLayout {
      * @param locale The locale.
      */
     private Calendar getCalendarForLocale(Calendar oldCalendar, Locale locale) {
-        if (oldCalendar == null) {
-            return Calendar.getInstance(locale);
-        } else {
-            final long currentTimeMillis = oldCalendar.getTimeInMillis();
-            Calendar newCalendar = Calendar.getInstance(locale);
-            newCalendar.setTimeInMillis(currentTimeMillis);
-            return newCalendar;
+        Calendar newCalendar = Calendar.getInstance(locale);
+        newCalendar.setTimeInMillis(0);
+        newCalendar.setFirstDayOfWeek(Calendar.MONDAY);
+        newCalendar.setMinimalDaysInFirstWeek(4);
+        if (oldCalendar != null) {
+            newCalendar.set(Calendar.YEAR, getWeekYearForDate(oldCalendar));
+            newCalendar.set(Calendar.WEEK_OF_YEAR, getWeekForDate(oldCalendar));
+            newCalendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
         }
+        return newCalendar;
     }
 
     /**
      * Updates the current date.
      *
      * @param year The year.
-     * @param month The month which is <strong>starting from zero</strong>.
+     * @param week The week in year.
      */
-    public void updateMonth(int year, int month) {
-        if (!isNewDate(year, month)) {
+    public void updateWeek(int weekYear, int week) {
+        if (!isNewDate(weekYear, week)) {
             return;
         }
-        setDate(year, month);
+        setDate(weekYear, week);
         updateSpinners();
         notifyDateChanged();
     }
@@ -314,14 +300,14 @@ public class MonthPicker extends FrameLayout {
     @Override
     protected Parcelable onSaveInstanceState() {
         Parcelable superState = super.onSaveInstanceState();
-        return new SavedState(superState, getYear(), getMonth());
+        return new SavedState(superState, getWeekYear(), getWeek());
     }
 
     @Override
     protected void onRestoreInstanceState(Parcelable state) {
         SavedState ss = (SavedState) state;
         super.onRestoreInstanceState(ss.getSuperState());
-        setDate(ss.mYear, ss.mMonth);
+        setDate(ss.mWeekYear, ss.mWeek);
         updateSpinners();
     }
 
@@ -329,24 +315,46 @@ public class MonthPicker extends FrameLayout {
      * Initialize the state. If the provided values designate an inconsistent
      * date the values are normalized before updating the spinners.
      *
-     * @param year The initial year.
-     * @param monthOfYear The initial month <strong>starting from zero</strong>.
-     * @param onMonthChangedListener How user is notified date is changed by
+     * @param weekYear The initial week year.
+     * @param weekOfYear The initial week in year.
+     * @param onWeekChangedListener How user is notified date is changed by
      *            user, can be null.
      */
-    public void init(int year, int monthOfYear, OnMonthChangedListener onMonthChangedListener) {
-        setDate(year, monthOfYear);
+    public void init(int weekYear, int weekOfYear, OnWeekChangedListener onWeekChangedListener) {
+        setDate(weekYear, weekOfYear);
         updateSpinners();
-        mMonthChangedListener = onMonthChangedListener;
+        mWeekChangedListener = onWeekChangedListener;
     }
 
-    private boolean isNewDate(int year, int month) {
-        return (mCurrentDate.get(Calendar.YEAR) != year
-                || mCurrentDate.get(Calendar.MONTH) != month);
+    private boolean isNewDate(int weekYear, int week) {
+        return (getWeekYear() != weekYear || getWeek() != week);
     }
 
-    private void setDate(int year, int month) {
-        mCurrentDate.set(year, month, 1);
+    private Calendar createDateFromWeek(int weekYear, int week) {
+        Calendar date = getCalendarForLocale(null, mCurrentLocale);
+        date.set(Calendar.YEAR, weekYear);
+        date.set(Calendar.WEEK_OF_YEAR, week);
+        return date;
+    }
+
+    public static int getWeekYearForDate(Calendar date) {
+        int year = date.get(Calendar.YEAR);
+        int month = date.get(Calendar.MONTH);
+        int week = date.get(Calendar.WEEK_OF_YEAR);
+        if (month == 0 && week > 51) {
+            year--;
+        } else if (month == 11 && week == 1) {
+            year++;
+        }
+        return year;
+    }
+
+    public static int getWeekForDate(Calendar date) {
+        return date.get(Calendar.WEEK_OF_YEAR);
+    }
+
+    private void setDate(int weekYear, int week) {
+        mCurrentDate = createDateFromWeek(weekYear, week);
         if (mCurrentDate.before(mMinDate)) {
             mCurrentDate.setTimeInMillis(mMinDate.getTimeInMillis());
         } else if (mCurrentDate.after(mMaxDate)) {
@@ -354,60 +362,50 @@ public class MonthPicker extends FrameLayout {
         }
     }
 
+    private int getNumberOfWeeks() {
+        // Create a date in the middle of the year, where the week year matches the year.
+        Calendar date = createDateFromWeek(getWeekYear(), 20);
+        return date.getActualMaximum(Calendar.WEEK_OF_YEAR);
+    }
+
     private void updateSpinners() {
         // set the spinner ranges respecting the min and max dates
         if (mCurrentDate.equals(mMinDate)) {
-            mMonthSpinner.setDisplayedValues(null);
-            mMonthSpinner.setMinValue(mCurrentDate.get(Calendar.MONTH));
-            mMonthSpinner.setMaxValue(mCurrentDate.getActualMaximum(Calendar.MONTH));
-            mMonthSpinner.setWrapSelectorWheel(false);
+            mWeekSpinner.setMinValue(getWeekForDate(mCurrentDate));
+            mWeekSpinner.setMaxValue(getNumberOfWeeks());
+            mWeekSpinner.setWrapSelectorWheel(false);
         } else if (mCurrentDate.equals(mMaxDate)) {
-            mMonthSpinner.setDisplayedValues(null);
-            mMonthSpinner.setMinValue(mCurrentDate.getActualMinimum(Calendar.MONTH));
-            mMonthSpinner.setMaxValue(mCurrentDate.get(Calendar.MONTH));
-            mMonthSpinner.setWrapSelectorWheel(false);
+            mWeekSpinner.setMinValue(getNumberOfWeeks());
+            mWeekSpinner.setMaxValue(getWeekForDate(mCurrentDate));
+            mWeekSpinner.setWrapSelectorWheel(false);
         } else {
-            mMonthSpinner.setDisplayedValues(null);
-            mMonthSpinner.setMinValue(0);
-            mMonthSpinner.setMaxValue(11);
-            mMonthSpinner.setWrapSelectorWheel(true);
+            mWeekSpinner.setMinValue(1);
+            mWeekSpinner.setMaxValue(getNumberOfWeeks());
+            mWeekSpinner.setWrapSelectorWheel(true);
         }
 
-        // make sure the month names are a zero based array
-        // with the months in the month spinner
-        String[] displayedValues = Arrays.copyOfRange(mShortMonths,
-                mMonthSpinner.getMinValue(), mMonthSpinner.getMaxValue() + 1);
-        mMonthSpinner.setDisplayedValues(displayedValues);
-
         // year spinner range does not change based on the current date
-        mYearSpinner.setMinValue(mMinDate.get(Calendar.YEAR));
-        mYearSpinner.setMaxValue(mMaxDate.get(Calendar.YEAR));
-        mYearSpinner.setWrapSelectorWheel(false);
+        mWeekYearSpinner.setMinValue(getWeekYearForDate(mMinDate));
+        mWeekYearSpinner.setMaxValue(getWeekYearForDate(mMaxDate));
+        mWeekYearSpinner.setWrapSelectorWheel(false);
 
         // set the spinner values
-        mYearSpinner.setValue(mCurrentDate.get(Calendar.YEAR));
-        mMonthSpinner.setValue(mCurrentDate.get(Calendar.MONTH));
+        mWeekYearSpinner.setValue(getWeekYearForDate(mCurrentDate));
+        mWeekSpinner.setValue(getWeekForDate(mCurrentDate));
     }
 
     /**
      * @return The selected year.
      */
-    public int getYear() {
-        return mCurrentDate.get(Calendar.YEAR);
-    }
-
-    /**
-     * @return The selected month.
-     */
-    public int getMonth() {
-        return mCurrentDate.get(Calendar.MONTH);
+    public int getWeekYear() {
+        return getWeekYearForDate(mCurrentDate);
     }
 
     /**
-     * @return The selected day of month.
+     * @return The selected week.
      */
-    public int getDayOfMonth() {
-        return mCurrentDate.get(Calendar.DAY_OF_MONTH);
+    public int getWeek() {
+        return getWeekForDate(mCurrentDate);
     }
 
     /**
@@ -415,8 +413,8 @@ public class MonthPicker extends FrameLayout {
      */
     private void notifyDateChanged() {
         sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
-        if (mMonthChangedListener != null) {
-            mMonthChangedListener.onMonthChanged(this, getYear(), getMonth());
+        if (mWeekChangedListener != null) {
+            mWeekChangedListener.onWeekChanged(this, getWeekYear(), getWeek());
         }
     }
 
@@ -425,17 +423,17 @@ public class MonthPicker extends FrameLayout {
      */
     private static class SavedState extends BaseSavedState {
 
-        private final int mYear;
+        private final int mWeekYear;
 
-        private final int mMonth;
+        private final int mWeek;
 
         /**
          * Constructor called from {@link DatePicker#onSaveInstanceState()}
          */
-        private SavedState(Parcelable superState, int year, int month) {
+        private SavedState(Parcelable superState, int weekYear, int week) {
             super(superState);
-            mYear = year;
-            mMonth = month;
+            mWeekYear = weekYear;
+            mWeek = week;
         }
 
         /**
@@ -443,15 +441,15 @@ public class MonthPicker extends FrameLayout {
          */
         private SavedState(Parcel in) {
             super(in);
-            mYear = in.readInt();
-            mMonth = in.readInt();
+            mWeekYear = in.readInt();
+            mWeek = in.readInt();
         }
 
         @Override
         public void writeToParcel(Parcel dest, int flags) {
             super.writeToParcel(dest, flags);
-            dest.writeInt(mYear);
-            dest.writeInt(mMonth);
+            dest.writeInt(mWeekYear);
+            dest.writeInt(mWeek);
         }
 
         @SuppressWarnings("all")