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/WeekPicker.java b/content/public/android/java/src/org/chromium/content/browser/input/WeekPicker.java
new file mode 100644
index 0000000000000000000000000000000000000000..ca1a72eaa4f20db544f7a2a0d6548af2467277e9
--- /dev/null
+++ b/content/public/android/java/src/org/chromium/content/browser/input/WeekPicker.java
@@ -0,0 +1,168 @@
+// Copyright (c) 2012 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.
+
+package org.chromium.content.browser.input;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.widget.NumberPicker;
+import android.widget.NumberPicker.OnValueChangeListener;
+
+import java.util.Calendar;
+
+import org.chromium.content.R;
+
+// This class is heavily based on android.widget.DatePicker.
+public class WeekPicker extends TwoFieldDatePicker {
+
+    public WeekPicker(Context context, long minValue, long maxValue) {
+        super(context);
+
+        LayoutInflater inflater = (LayoutInflater) context
+                .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        inflater.inflate(R.layout.week_picker, this, true);
+
+        OnValueChangeListener onChangeListener = new OnValueChangeListener() {
+            @Override
+            public void onValueChange(NumberPicker picker, int oldVal, int newVal) {
+                // take care of wrapping of weeks to update greater fields
+                if (picker == mPositionInYearSpinner) {
+                    Calendar tempDate = (Calendar) mCurrentDate.clone();
+                    if (oldVal == mPositionInYearSpinner.getMaxValue()
+                            && newVal == mPositionInYearSpinner.getMinValue()) {
+                        tempDate.add(Calendar.WEEK_OF_YEAR, 1);
+                    } else if (oldVal == mPositionInYearSpinner.getMinValue()
+                            && newVal == mPositionInYearSpinner.getMaxValue()) {
+                        tempDate.add(Calendar.WEEK_OF_YEAR, -1);
+                    } else {
+                        tempDate.add(Calendar.WEEK_OF_YEAR, newVal - oldVal);
+                    }
+                    // now set the date to the adjusted one
+                    setCurrentDate(getISOWeekYearForDate(tempDate),
+                            getWeekForDate(tempDate));
+                } else if (picker == mYearSpinner) {
+                    setCurrentDate(newVal, getWeekForDate(mCurrentDate));
+                } else {
+                    throw new IllegalArgumentException();
+                }
+
+                updateSpinners();
+                notifyDateChanged();
+            }
+        };
+
+        // week
+        mPositionInYearSpinner = (NumberPicker) findViewById(R.id.week);
+        mPositionInYearSpinner.setOnLongPressUpdateInterval(200);
+        mPositionInYearSpinner.setOnValueChangedListener(onChangeListener);
+
+        // year
+        mYearSpinner = (NumberPicker) findViewById(R.id.year);
+        mYearSpinner.setOnLongPressUpdateInterval(100);
+        mYearSpinner.setOnValueChangedListener(onChangeListener);
+
+        mMinDate = Calendar.getInstance();
+        mMinDate.setFirstDayOfWeek(Calendar.MONDAY);
+        mMinDate.setMinimalDaysInFirstWeek(4);
+        mMinDate.setTimeInMillis(minValue);
+
+        mMaxDate = Calendar.getInstance();
+        mMaxDate.setFirstDayOfWeek(Calendar.MONDAY);
+        mMaxDate.setMinimalDaysInFirstWeek(4);
+        mMaxDate.setTimeInMillis(maxValue);
+
+        // initialize to current date
+        mCurrentDate.setTimeInMillis(System.currentTimeMillis());
+        init(getISOWeekYearForDate(mCurrentDate), getWeekForDate(mCurrentDate), null);
+    }
+
+    private Calendar createDateFromWeek(int year, int week) {
+        Calendar date = Calendar.getInstance();
+        date.setFirstDayOfWeek(Calendar.MONDAY);
+        date.setMinimalDaysInFirstWeek(4);
+        date.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
+        date.set(Calendar.YEAR, year);
+        date.set(Calendar.WEEK_OF_YEAR, week);
+        return date;
+    }
+
+    public static int getISOWeekYearForDate(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);
+    }
+
+    @Override
+    protected void setCurrentDate(int year, int week) {
+        mCurrentDate = createDateFromWeek(year, week);
+        if (mCurrentDate.before(mMinDate)) {
+            mCurrentDate.setTimeInMillis(mMinDate.getTimeInMillis());
+        } else if (mCurrentDate.after(mMaxDate)) {
+            mCurrentDate.setTimeInMillis(mMaxDate.getTimeInMillis());
+        }
+    }
+
+    private int getNumberOfWeeks() {
+        // Create a date in the middle of the year, where the week year matches the year.
+        Calendar date = createDateFromWeek(getYear(), 20);
+        return date.getActualMaximum(Calendar.WEEK_OF_YEAR);
+    }
+
+    @Override
+    protected void updateSpinners() {
+        // set the spinner ranges respecting the min and max dates
+        if (mCurrentDate.equals(mMinDate)) {
+            mPositionInYearSpinner.setMinValue(getWeekForDate(mCurrentDate));
+            mPositionInYearSpinner.setMaxValue(getNumberOfWeeks());
+            mPositionInYearSpinner.setWrapSelectorWheel(false);
+        } else if (mCurrentDate.equals(mMaxDate)) {
+            mPositionInYearSpinner.setMinValue(getNumberOfWeeks());
+            mPositionInYearSpinner.setMaxValue(getWeekForDate(mCurrentDate));
+            mPositionInYearSpinner.setWrapSelectorWheel(false);
+        } else {
+            mPositionInYearSpinner.setMinValue(1);
+            mPositionInYearSpinner.setMaxValue(getNumberOfWeeks());
+            mPositionInYearSpinner.setWrapSelectorWheel(true);
+        }
+
+        // year spinner range does not change based on the current date
+        mYearSpinner.setMinValue(getISOWeekYearForDate(mMinDate));
+        mYearSpinner.setMaxValue(getISOWeekYearForDate(mMaxDate));
+        mYearSpinner.setWrapSelectorWheel(false);
+
+        // set the spinner values
+        mYearSpinner.setValue(getISOWeekYearForDate(mCurrentDate));
+        mPositionInYearSpinner.setValue(getWeekForDate(mCurrentDate));
+    }
+
+    /**
+     * @return The selected year.
+     */
+    @Override
+    public int getYear() {
+        return getISOWeekYearForDate(mCurrentDate);
+    }
+
+    /**
+     * @return The selected week.
+     */
+    public int getWeek() {
+        return getWeekForDate(mCurrentDate);
+    }
+
+    @Override
+    public int getMonthOrWeek() {
+        return getWeek();
+    }
+}