Java tutorial
/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.codetroopers.betterpickers.recurrencepicker; import android.app.Activity; import android.content.Context; import android.content.DialogInterface; import android.content.res.Configuration; import android.content.res.Resources; import android.os.Build; import android.os.Bundle; import android.os.Parcel; import android.os.Parcelable; import android.support.annotation.NonNull; import android.support.v4.app.DialogFragment; import android.support.v7.widget.SwitchCompat; import android.text.Editable; import android.text.TextUtils; import android.text.TextWatcher; import android.text.format.DateUtils; import android.text.format.Time; import android.util.DisplayMetrics; import android.util.Log; import android.util.TimeFormatException; import android.view.Display; import android.view.LayoutInflater; import android.view.View; import android.view.View.OnClickListener; import android.view.ViewGroup; import android.view.ViewGroup.LayoutParams; import android.view.Window; import android.widget.AdapterView; import android.widget.AdapterView.OnItemSelectedListener; import android.widget.ArrayAdapter; import android.widget.Button; import android.widget.CompoundButton; import android.widget.CompoundButton.OnCheckedChangeListener; import android.widget.EditText; import android.widget.LinearLayout; import android.widget.RadioButton; import android.widget.RadioGroup; import android.widget.Spinner; import android.widget.TableLayout; import android.widget.TextView; import android.widget.Toast; import android.widget.ToggleButton; import com.codetroopers.betterpickers.OnDialogDismissListener; import com.codetroopers.betterpickers.R; import com.codetroopers.betterpickers.calendardatepicker.CalendarDatePickerDialogFragment; import java.text.DateFormatSymbols; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; public class RecurrencePickerDialogFragment extends DialogFragment implements OnItemSelectedListener, OnCheckedChangeListener, OnClickListener, android.widget.RadioGroup.OnCheckedChangeListener, CalendarDatePickerDialogFragment.OnDateSetListener { private static final String TAG = "RecurrencePickerDialogFragment"; // in dp's private static final int MIN_SCREEN_WIDTH_FOR_SINGLE_ROW_WEEK = 450; // Update android:maxLength in EditText as needed private static final int INTERVAL_MAX = 99; private static final int INTERVAL_DEFAULT = 1; // Update android:maxLength in EditText as needed private static final int COUNT_MAX = 730; private static final int COUNT_DEFAULT = 5; // Special cases in monthlyByNthDayOfWeek private static final int FIFTH_WEEK_IN_A_MONTH = 5; public static final int LAST_NTH_DAY_OF_WEEK = -1; private CalendarDatePickerDialogFragment mDatePickerDialog; private OnDialogDismissListener mDismissCallback; private static class RecurrenceModel implements Parcelable { // Should match EventRecurrence.DAILY, etc static final int FREQ_HOURLY = 0; static final int FREQ_DAILY = 1; static final int FREQ_WEEKLY = 2; static final int FREQ_MONTHLY = 3; static final int FREQ_YEARLY = 4; static final int END_NEVER = 0; static final int END_BY_DATE = 1; static final int END_BY_COUNT = 2; static final int MONTHLY_BY_DATE = 0; static final int MONTHLY_BY_NTH_DAY_OF_WEEK = 1; static final int STATE_NO_RECURRENCE = 0; static final int STATE_RECURRENCE = 1; int recurrenceState; /** * FREQ: Repeat pattern * * @see #FREQ_DAILY * @see #FREQ_WEEKLY * @see #FREQ_MONTHLY * @see #FREQ_YEARLY * @see #FREQ_HOURLY */ int freq = FREQ_WEEKLY; /** * INTERVAL: Every n days/weeks/months/years. n >= 1 */ int interval = INTERVAL_DEFAULT; /** * UNTIL and COUNT: How does the the event end? * * @see #END_NEVER * @see #END_BY_DATE * @see #END_BY_COUNT */ int end; /** * UNTIL: Date of the last recurrence. Used when until == END_BY_DATE */ Time endDate; /** * COUNT: Times to repeat. Use when until == END_BY_COUNT */ int endCount = COUNT_DEFAULT; /** * BYDAY: Days of the week to be repeated. Sun = 0, Mon = 1, etc */ boolean[] weeklyByDayOfWeek = new boolean[7]; /** * BYDAY AND BYMONTHDAY: How to repeat monthly events? Same date of the month or Same nth day of week. * * @see #MONTHLY_BY_DATE * @see #MONTHLY_BY_NTH_DAY_OF_WEEK */ int monthlyRepeat; /** * Day of the month to repeat. Used when monthlyRepeat == MONTHLY_BY_DATE */ int monthlyByMonthDay; /** * Day of the week to repeat. Used when monthlyRepeat == MONTHLY_BY_NTH_DAY_OF_WEEK */ int monthlyByDayOfWeek; /** * Nth day of the week to repeat. Used when monthlyRepeat == MONTHLY_BY_NTH_DAY_OF_WEEK 0=undefined, -1=Last, * 1=1st, 2=2nd, ..., 5=5th * <p/> * We support 5th, just to handle backwards capabilities with old bug, but it gets converted to -1 once edited. */ int monthlyByNthDayOfWeek; /** * Force to hide switch to force user to select a reccurency */ boolean forceHideSwitchButton; /* * (generated method) */ @Override public String toString() { return "Model [freq=" + freq + ", interval=" + interval + ", end=" + end + ", endDate=" + endDate + ", endCount=" + endCount + ", weeklyByDayOfWeek=" + Arrays.toString(weeklyByDayOfWeek) + ", monthlyRepeat=" + monthlyRepeat + ", monthlyByMonthDay=" + monthlyByMonthDay + ", monthlyByDayOfWeek=" + monthlyByDayOfWeek + ", monthlyByNthDayOfWeek=" + monthlyByNthDayOfWeek + "]"; } public RecurrenceModel() { } @Override public int describeContents() { return 0; } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeInt(recurrenceState); dest.writeInt(freq); dest.writeInt(interval); dest.writeInt(end); dest.writeInt(endDate.year); dest.writeInt(endDate.month); dest.writeInt(endDate.monthDay); dest.writeInt(endCount); dest.writeBooleanArray(weeklyByDayOfWeek); dest.writeInt(monthlyRepeat); dest.writeInt(monthlyByMonthDay); dest.writeInt(monthlyByDayOfWeek); dest.writeInt(monthlyByNthDayOfWeek); dest.writeByte((byte) (forceHideSwitchButton ? 1 : 0)); } private RecurrenceModel(Parcel in) { this.recurrenceState = in.readInt(); this.freq = in.readInt(); this.interval = in.readInt(); this.end = in.readInt(); this.endDate = new Time(); this.endDate.year = in.readInt(); this.endDate.month = in.readInt(); this.endDate.monthDay = in.readInt(); this.endCount = in.readInt(); this.weeklyByDayOfWeek = in.createBooleanArray(); this.monthlyRepeat = in.readInt(); this.monthlyByMonthDay = in.readInt(); this.monthlyByDayOfWeek = in.readInt(); this.monthlyByNthDayOfWeek = in.readInt(); this.forceHideSwitchButton = in.readByte() != 0; } public static final Creator<RecurrenceModel> CREATOR = new Creator<RecurrenceModel>() { public RecurrenceModel createFromParcel(Parcel source) { return new RecurrenceModel(source); } public RecurrenceModel[] newArray(int size) { return new RecurrenceModel[size]; } }; } class minMaxTextWatcher implements TextWatcher { private int mMin; private int mMax; private int mDefault; public minMaxTextWatcher(int min, int defaultInt, int max) { mMin = min; mMax = max; mDefault = defaultInt; } @Override public void afterTextChanged(Editable s) { boolean updated = false; int value; try { value = Integer.parseInt(s.toString()); } catch (NumberFormatException e) { value = mDefault; } if (value < mMin) { value = mMin; updated = true; } else if (value > mMax) { updated = true; value = mMax; } // Update UI if (updated) { s.clear(); s.append(Integer.toString(value)); } updateDoneButtonState(); onChange(value); } /** * Override to be called after each key stroke */ void onChange(int value) { } @Override public void beforeTextChanged(CharSequence s, int start, int count, int after) { } @Override public void onTextChanged(CharSequence s, int start, int before, int count) { } } private Resources mResources; private EventRecurrence mRecurrence = new EventRecurrence(); private Time mTime = new Time(); // TODO timezone? private RecurrenceModel mModel = new RecurrenceModel(); private Toast mToast; private final int[] TIME_DAY_TO_CALENDAR_DAY = new int[] { Calendar.SUNDAY, Calendar.MONDAY, Calendar.TUESDAY, Calendar.WEDNESDAY, Calendar.THURSDAY, Calendar.FRIDAY, Calendar.SATURDAY, }; // Call mStringBuilder.setLength(0) before formatting any string or else the // formatted text will accumulate. // private final StringBuilder mStringBuilder = new StringBuilder(); // private Formatter mFormatter = new Formatter(mStringBuilder); private View mView; private Spinner mFreqSpinner; private static final int[] mFreqModelToEventRecurrence = { EventRecurrence.HOURLY, EventRecurrence.DAILY, EventRecurrence.WEEKLY, EventRecurrence.MONTHLY, EventRecurrence.YEARLY }; public static final String BUNDLE_START_TIME_MILLIS = "bundle_event_start_time"; public static final String BUNDLE_TIME_ZONE = "bundle_event_time_zone"; public static final String BUNDLE_RRULE = "bundle_event_rrule"; public static final String BUNDLE_HIDE_SWITCH_BUTTON = "bundle_hide_switch_button"; private static final String BUNDLE_MODEL = "bundle_model"; private static final String BUNDLE_END_COUNT_HAS_FOCUS = "bundle_end_count_has_focus"; private static final String FRAG_TAG_DATE_PICKER = "tag_date_picker_frag"; private SwitchCompat mRepeatSwitch; private EditText mInterval; private TextView mIntervalPreText; private TextView mIntervalPostText; private int mIntervalResId = -1; private Spinner mEndSpinner; private TextView mEndDateTextView; private EditText mEndCount; private TextView mPostEndCount; private boolean mHidePostEndCount; private ArrayList<CharSequence> mEndSpinnerArray = new ArrayList<CharSequence>(3); private EndSpinnerAdapter mEndSpinnerAdapter; private String mEndNeverStr; private String mEndDateLabel; private String mEndCountLabel; /** * Hold toggle buttons in the order per user's first day of week preference */ private LinearLayout mWeekGroup; private LinearLayout mWeekGroup2; // Sun = 0 private ToggleButton[] mWeekByDayButtons = new ToggleButton[7]; /** * A double array of Strings to hold the 7x5 list of possible strings of the form: "on every [Nth] [DAY_OF_WEEK]", * e.g. "on every second Monday", where [Nth] can be [first, second, third, fourth, last] */ private String[][] mMonthRepeatByDayOfWeekStrs; private LinearLayout mMonthGroup; private RadioGroup mMonthRepeatByRadioGroup; private RadioButton mRepeatMonthlyByNthDayOfWeek; private RadioButton mRepeatMonthlyByNthDayOfMonth; private String mMonthRepeatByDayOfWeekStr; private Button mDoneButton; private OnRecurrenceSetListener mRecurrenceSetListener; public RecurrencePickerDialogFragment() { } static public boolean isSupportedMonthlyByNthDayOfWeek(int num) { // We only support monthlyByNthDayOfWeek when it is greater then 0 but less then 5. // Or if -1 when it is the last monthly day of the week. return (num > 0 && num <= FIFTH_WEEK_IN_A_MONTH) || num == LAST_NTH_DAY_OF_WEEK; } static public boolean canHandleRecurrenceRule(EventRecurrence er) { switch (er.freq) { case EventRecurrence.HOURLY: case EventRecurrence.DAILY: case EventRecurrence.MONTHLY: case EventRecurrence.YEARLY: case EventRecurrence.WEEKLY: break; default: return false; } if (er.count > 0 && !TextUtils.isEmpty(er.until)) { return false; } // Weekly: For "repeat by day of week", the day of week to repeat is in // er.byday[] /* * Monthly: For "repeat by nth day of week" the day of week to repeat is * in er.byday[] and the "nth" is stored in er.bydayNum[]. Currently we * can handle only one and only in monthly */ int numOfByDayNum = 0; for (int i = 0; i < er.bydayCount; i++) { if (isSupportedMonthlyByNthDayOfWeek(er.bydayNum[i])) { ++numOfByDayNum; } } if (numOfByDayNum > 1) { return false; } if (numOfByDayNum > 0 && er.freq != EventRecurrence.MONTHLY) { return false; } // The UI only handle repeat by one day of month i.e. not 9th and 10th // of every month if (er.bymonthdayCount > 1) { return false; } if (er.freq == EventRecurrence.MONTHLY) { if (er.bydayCount > 1) { return false; } if (er.bydayCount > 0 && er.bymonthdayCount > 0) { return false; } } return true; } // TODO don't lose data when getting data that our UI can't handle static private void copyEventRecurrenceToModel(final EventRecurrence er, RecurrenceModel model) { // Freq: switch (er.freq) { case EventRecurrence.HOURLY: model.freq = RecurrenceModel.FREQ_HOURLY; break; case EventRecurrence.DAILY: model.freq = RecurrenceModel.FREQ_DAILY; break; case EventRecurrence.MONTHLY: model.freq = RecurrenceModel.FREQ_MONTHLY; break; case EventRecurrence.YEARLY: model.freq = RecurrenceModel.FREQ_YEARLY; break; case EventRecurrence.WEEKLY: model.freq = RecurrenceModel.FREQ_WEEKLY; break; default: throw new IllegalStateException("freq=" + er.freq); } // Interval: if (er.interval > 0) { model.interval = er.interval; } // End: // End by count: model.endCount = er.count; if (model.endCount > 0) { model.end = RecurrenceModel.END_BY_COUNT; } // End by date: if (!TextUtils.isEmpty(er.until)) { if (model.endDate == null) { model.endDate = new Time(); } try { model.endDate.parse(er.until); } catch (TimeFormatException e) { model.endDate = null; } // LIMITATION: The UI can only handle END_BY_DATE or END_BY_COUNT if (model.end == RecurrenceModel.END_BY_COUNT && model.endDate != null) { throw new IllegalStateException("freq=" + er.freq); } model.end = RecurrenceModel.END_BY_DATE; } // Weekly: repeat by day of week or Monthly: repeat by nth day of week // in the month Arrays.fill(model.weeklyByDayOfWeek, false); if (er.bydayCount > 0) { int count = 0; for (int i = 0; i < er.bydayCount; i++) { int dayOfWeek = EventRecurrence.day2TimeDay(er.byday[i]); model.weeklyByDayOfWeek[dayOfWeek] = true; if (model.freq == RecurrenceModel.FREQ_MONTHLY && isSupportedMonthlyByNthDayOfWeek(er.bydayNum[i])) { // LIMITATION: Can handle only (one) weekDayNum in nth or last and only // when // monthly model.monthlyByDayOfWeek = dayOfWeek; model.monthlyByNthDayOfWeek = er.bydayNum[i]; model.monthlyRepeat = RecurrenceModel.MONTHLY_BY_NTH_DAY_OF_WEEK; count++; } } if (model.freq == RecurrenceModel.FREQ_MONTHLY) { if (er.bydayCount != 1) { // Can't handle 1st Monday and 2nd Wed throw new IllegalStateException("Can handle only 1 byDayOfWeek in monthly"); } if (count != 1) { throw new IllegalStateException("Didn't specify which nth day of week to repeat for a monthly"); } } } // Monthly by day of month if (model.freq == RecurrenceModel.FREQ_MONTHLY) { if (er.bymonthdayCount == 1) { if (model.monthlyRepeat == RecurrenceModel.MONTHLY_BY_NTH_DAY_OF_WEEK) { throw new IllegalStateException("Can handle only by monthday or by nth day of week, not both"); } model.monthlyByMonthDay = er.bymonthday[0]; model.monthlyRepeat = RecurrenceModel.MONTHLY_BY_DATE; } else if (er.bymonthCount > 1) { // LIMITATION: Can handle only one month day throw new IllegalStateException("Can handle only one bymonthday"); } } } static private void copyModelToEventRecurrence(final RecurrenceModel model, EventRecurrence eventRecurrence) { if (model.recurrenceState == RecurrenceModel.STATE_NO_RECURRENCE) { throw new IllegalStateException("There's no recurrence"); } // Freq eventRecurrence.freq = mFreqModelToEventRecurrence[model.freq]; // Interval if (model.interval <= 1) { eventRecurrence.interval = 0; } else { eventRecurrence.interval = model.interval; } // End switch (model.end) { case RecurrenceModel.END_BY_DATE: if (model.endDate != null) { model.endDate.switchTimezone(Time.TIMEZONE_UTC); model.endDate.normalize(false); eventRecurrence.until = model.endDate.format2445(); eventRecurrence.count = 0; } else { throw new IllegalStateException("end = END_BY_DATE but endDate is null"); } break; case RecurrenceModel.END_BY_COUNT: eventRecurrence.count = model.endCount; eventRecurrence.until = null; if (eventRecurrence.count <= 0) { throw new IllegalStateException("count is " + eventRecurrence.count); } break; default: eventRecurrence.count = 0; eventRecurrence.until = null; break; } // Weekly && monthly repeat patterns eventRecurrence.bydayCount = 0; eventRecurrence.bymonthdayCount = 0; switch (model.freq) { case RecurrenceModel.FREQ_MONTHLY: if (model.monthlyRepeat == RecurrenceModel.MONTHLY_BY_DATE) { if (model.monthlyByMonthDay > 0) { if (eventRecurrence.bymonthday == null || eventRecurrence.bymonthdayCount < 1) { eventRecurrence.bymonthday = new int[1]; } eventRecurrence.bymonthday[0] = model.monthlyByMonthDay; eventRecurrence.bymonthdayCount = 1; } } else if (model.monthlyRepeat == RecurrenceModel.MONTHLY_BY_NTH_DAY_OF_WEEK) { if (!isSupportedMonthlyByNthDayOfWeek(model.monthlyByNthDayOfWeek)) { throw new IllegalStateException( "month repeat by nth week but n is " + model.monthlyByNthDayOfWeek); } int count = 1; if (eventRecurrence.bydayCount < count || eventRecurrence.byday == null || eventRecurrence.bydayNum == null) { eventRecurrence.byday = new int[count]; eventRecurrence.bydayNum = new int[count]; } eventRecurrence.bydayCount = count; eventRecurrence.byday[0] = EventRecurrence.timeDay2Day(model.monthlyByDayOfWeek); eventRecurrence.bydayNum[0] = model.monthlyByNthDayOfWeek; } break; case RecurrenceModel.FREQ_WEEKLY: int count = 0; for (int i = 0; i < 7; i++) { if (model.weeklyByDayOfWeek[i]) { count++; } } if (eventRecurrence.bydayCount < count || eventRecurrence.byday == null || eventRecurrence.bydayNum == null) { eventRecurrence.byday = new int[count]; eventRecurrence.bydayNum = new int[count]; } eventRecurrence.bydayCount = count; for (int i = 6; i >= 0; i--) { if (model.weeklyByDayOfWeek[i]) { eventRecurrence.bydayNum[--count] = 0; eventRecurrence.byday[count] = EventRecurrence.timeDay2Day(i); } } break; } if (!canHandleRecurrenceRule(eventRecurrence)) { throw new IllegalStateException("UI generated recurrence that it can't handle. ER:" + eventRecurrence.toString() + " Model: " + model.toString()); } } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { mRecurrence.wkst = EventRecurrence.timeDay2Day(Utils.getFirstDayOfWeek(getActivity())); getDialog().getWindow().requestFeature(Window.FEATURE_NO_TITLE); boolean endCountHasFocus = false; if (savedInstanceState != null) { RecurrenceModel m = (RecurrenceModel) savedInstanceState.get(BUNDLE_MODEL); if (m != null) { mModel = m; } endCountHasFocus = savedInstanceState.getBoolean(BUNDLE_END_COUNT_HAS_FOCUS); } else { Bundle bundle = getArguments(); if (bundle != null) { mTime.set(bundle.getLong(BUNDLE_START_TIME_MILLIS)); String tz = bundle.getString(BUNDLE_TIME_ZONE); if (!TextUtils.isEmpty(tz)) { mTime.timezone = tz; } mTime.normalize(false); // Time days of week: Sun=0, Mon=1, etc mModel.weeklyByDayOfWeek[mTime.weekDay] = true; String rrule = bundle.getString(BUNDLE_RRULE); if (!TextUtils.isEmpty(rrule)) { mModel.recurrenceState = RecurrenceModel.STATE_RECURRENCE; mRecurrence.parse(rrule); copyEventRecurrenceToModel(mRecurrence, mModel); // Leave today's day of week as checked by default in weekly view. if (mRecurrence.bydayCount == 0) { mModel.weeklyByDayOfWeek[mTime.weekDay] = true; } } mModel.forceHideSwitchButton = bundle.getBoolean(BUNDLE_HIDE_SWITCH_BUTTON, false); } else { mTime.setToNow(); } } mResources = getResources(); mView = inflater.inflate(R.layout.recurrencepicker, container, true); final Activity activity = getActivity(); final Configuration config = activity.getResources().getConfiguration(); mRepeatSwitch = (SwitchCompat) mView.findViewById(R.id.repeat_switch); if (mModel.forceHideSwitchButton) { mRepeatSwitch.setChecked(true); mRepeatSwitch.setVisibility(View.GONE); mModel.recurrenceState = RecurrenceModel.STATE_RECURRENCE; } else { mRepeatSwitch.setChecked(mModel.recurrenceState == RecurrenceModel.STATE_RECURRENCE); mRepeatSwitch.setOnCheckedChangeListener(new OnCheckedChangeListener() { @Override public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { mModel.recurrenceState = isChecked ? RecurrenceModel.STATE_RECURRENCE : RecurrenceModel.STATE_NO_RECURRENCE; togglePickerOptions(); } }); } mFreqSpinner = (Spinner) mView.findViewById(R.id.freqSpinner); mFreqSpinner.setOnItemSelectedListener(this); ArrayAdapter<CharSequence> freqAdapter = ArrayAdapter.createFromResource(getActivity(), R.array.recurrence_freq, R.layout.recurrencepicker_freq_item); freqAdapter.setDropDownViewResource(R.layout.recurrencepicker_freq_item); mFreqSpinner.setAdapter(freqAdapter); mInterval = (EditText) mView.findViewById(R.id.interval); mInterval.addTextChangedListener(new minMaxTextWatcher(1, INTERVAL_DEFAULT, INTERVAL_MAX) { @Override void onChange(int v) { if (mIntervalResId != -1 && mInterval.getText().toString().length() > 0) { mModel.interval = v; updateIntervalText(); mInterval.requestLayout(); } } }); mIntervalPreText = (TextView) mView.findViewById(R.id.intervalPreText); mIntervalPostText = (TextView) mView.findViewById(R.id.intervalPostText); mEndNeverStr = mResources.getString(R.string.recurrence_end_continously); mEndDateLabel = mResources.getString(R.string.recurrence_end_date_label); mEndCountLabel = mResources.getString(R.string.recurrence_end_count_label); mEndSpinnerArray.add(mEndNeverStr); mEndSpinnerArray.add(mEndDateLabel); mEndSpinnerArray.add(mEndCountLabel); mEndSpinner = (Spinner) mView.findViewById(R.id.endSpinner); mEndSpinner.setOnItemSelectedListener(this); mEndSpinnerAdapter = new EndSpinnerAdapter(getActivity(), mEndSpinnerArray, R.layout.recurrencepicker_freq_item, R.layout.recurrencepicker_end_text); mEndSpinnerAdapter.setDropDownViewResource(R.layout.recurrencepicker_freq_item); mEndSpinner.setAdapter(mEndSpinnerAdapter); mEndCount = (EditText) mView.findViewById(R.id.endCount); mEndCount.addTextChangedListener(new minMaxTextWatcher(1, COUNT_DEFAULT, COUNT_MAX) { @Override void onChange(int v) { if (mModel.endCount != v) { mModel.endCount = v; updateEndCountText(); mEndCount.requestLayout(); } } }); mPostEndCount = (TextView) mView.findViewById(R.id.postEndCount); mEndDateTextView = (TextView) mView.findViewById(R.id.endDate); mEndDateTextView.setOnClickListener(this); if (mModel.endDate == null) { mModel.endDate = new Time(mTime); switch (mModel.freq) { case RecurrenceModel.FREQ_HOURLY: case RecurrenceModel.FREQ_DAILY: case RecurrenceModel.FREQ_WEEKLY: mModel.endDate.month += 1; break; case RecurrenceModel.FREQ_MONTHLY: mModel.endDate.month += 3; break; case RecurrenceModel.FREQ_YEARLY: mModel.endDate.year += 3; break; } mModel.endDate.normalize(false); } mWeekGroup = (LinearLayout) mView.findViewById(R.id.weekGroup); mWeekGroup2 = (LinearLayout) mView.findViewById(R.id.weekGroup2); // In Calendar.java day of week order e.g Sun = 1 ... Sat = 7 String[] dayOfWeekString = new DateFormatSymbols().getWeekdays(); mMonthRepeatByDayOfWeekStrs = new String[7][]; // from Time.SUNDAY as 0 through Time.SATURDAY as 6 mMonthRepeatByDayOfWeekStrs[0] = mResources.getStringArray(R.array.repeat_by_nth_sun); mMonthRepeatByDayOfWeekStrs[1] = mResources.getStringArray(R.array.repeat_by_nth_mon); mMonthRepeatByDayOfWeekStrs[2] = mResources.getStringArray(R.array.repeat_by_nth_tues); mMonthRepeatByDayOfWeekStrs[3] = mResources.getStringArray(R.array.repeat_by_nth_wed); mMonthRepeatByDayOfWeekStrs[4] = mResources.getStringArray(R.array.repeat_by_nth_thurs); mMonthRepeatByDayOfWeekStrs[5] = mResources.getStringArray(R.array.repeat_by_nth_fri); mMonthRepeatByDayOfWeekStrs[6] = mResources.getStringArray(R.array.repeat_by_nth_sat); // In Time.java day of week order e.g. Sun = 0 int idx = Utils.getFirstDayOfWeek(getActivity()); // In Calendar.java day of week order e.g Sun = 1 ... Sat = 7 dayOfWeekString = new DateFormatSymbols().getShortWeekdays(); int numOfButtonsInRow1; int numOfButtonsInRow2; if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR2) { // Get screen width in dp first Display display = getActivity().getWindowManager().getDefaultDisplay(); DisplayMetrics outMetrics = new DisplayMetrics(); display.getMetrics(outMetrics); float density = getResources().getDisplayMetrics().density; float dpWidth = outMetrics.widthPixels / density; if (dpWidth > MIN_SCREEN_WIDTH_FOR_SINGLE_ROW_WEEK) { numOfButtonsInRow1 = 7; numOfButtonsInRow2 = 0; mWeekGroup2.setVisibility(View.GONE); mWeekGroup2.getChildAt(3).setVisibility(View.GONE); } else { numOfButtonsInRow1 = 4; numOfButtonsInRow2 = 3; mWeekGroup2.setVisibility(View.VISIBLE); // Set rightmost button on the second row invisible so it takes up // space and everything centers properly mWeekGroup2.getChildAt(3).setVisibility(View.INVISIBLE); } } else if (mResources.getConfiguration().screenWidthDp > MIN_SCREEN_WIDTH_FOR_SINGLE_ROW_WEEK) { numOfButtonsInRow1 = 7; numOfButtonsInRow2 = 0; mWeekGroup2.setVisibility(View.GONE); mWeekGroup2.getChildAt(3).setVisibility(View.GONE); } else { numOfButtonsInRow1 = 4; numOfButtonsInRow2 = 3; mWeekGroup2.setVisibility(View.VISIBLE); // Set rightmost button on the second row invisible so it takes up // space and everything centers properly mWeekGroup2.getChildAt(3).setVisibility(View.INVISIBLE); } /* First row */ for (int i = 0; i < 7; i++) { if (i >= numOfButtonsInRow1) { mWeekGroup.getChildAt(i).setVisibility(View.GONE); continue; } mWeekByDayButtons[idx] = (ToggleButton) mWeekGroup.getChildAt(i); mWeekByDayButtons[idx].setTextOff(dayOfWeekString[TIME_DAY_TO_CALENDAR_DAY[idx]]); mWeekByDayButtons[idx].setTextOn(dayOfWeekString[TIME_DAY_TO_CALENDAR_DAY[idx]]); mWeekByDayButtons[idx].setOnCheckedChangeListener(this); if (++idx >= 7) { idx = 0; } } /* 2nd Row */ for (int i = 0; i < 3; i++) { if (i >= numOfButtonsInRow2) { mWeekGroup2.getChildAt(i).setVisibility(View.GONE); continue; } mWeekByDayButtons[idx] = (ToggleButton) mWeekGroup2.getChildAt(i); mWeekByDayButtons[idx].setTextOff(dayOfWeekString[TIME_DAY_TO_CALENDAR_DAY[idx]]); mWeekByDayButtons[idx].setTextOn(dayOfWeekString[TIME_DAY_TO_CALENDAR_DAY[idx]]); mWeekByDayButtons[idx].setOnCheckedChangeListener(this); if (++idx >= 7) { idx = 0; } } mMonthGroup = (LinearLayout) mView.findViewById(R.id.monthGroup); mMonthRepeatByRadioGroup = (RadioGroup) mView.findViewById(R.id.monthGroup); mMonthRepeatByRadioGroup.setOnCheckedChangeListener(this); mRepeatMonthlyByNthDayOfWeek = (RadioButton) mView.findViewById(R.id.repeatMonthlyByNthDayOfTheWeek); mRepeatMonthlyByNthDayOfMonth = (RadioButton) mView.findViewById(R.id.repeatMonthlyByNthDayOfMonth); mDoneButton = (Button) mView.findViewById(R.id.done_button); mDoneButton.setOnClickListener(this); Button cancelButton = (Button) mView.findViewById(R.id.cancel_button); //FIXME no text color for this one ? cancelButton.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { dismiss(); } }); togglePickerOptions(); updateDialog(); if (endCountHasFocus) { mEndCount.requestFocus(); } return mView; } @Override public void onDismiss(DialogInterface dialoginterface) { super.onDismiss(dialoginterface); if (mDismissCallback != null) { mDismissCallback.onDialogDismiss(dialoginterface); } } private void togglePickerOptions() { if (mModel.recurrenceState == RecurrenceModel.STATE_NO_RECURRENCE) { mFreqSpinner.setEnabled(false); mEndSpinner.setEnabled(false); mIntervalPreText.setEnabled(false); mInterval.setEnabled(false); mIntervalPostText.setEnabled(false); mMonthRepeatByRadioGroup.setEnabled(false); mEndCount.setEnabled(false); mPostEndCount.setEnabled(false); mEndDateTextView.setEnabled(false); mRepeatMonthlyByNthDayOfWeek.setEnabled(false); mRepeatMonthlyByNthDayOfMonth.setEnabled(false); for (Button button : mWeekByDayButtons) { button.setEnabled(false); } } else { mView.findViewById(R.id.options).setEnabled(true); mFreqSpinner.setEnabled(true); mEndSpinner.setEnabled(true); mIntervalPreText.setEnabled(true); mInterval.setEnabled(true); mIntervalPostText.setEnabled(true); mMonthRepeatByRadioGroup.setEnabled(true); mEndCount.setEnabled(true); mPostEndCount.setEnabled(true); mEndDateTextView.setEnabled(true); mRepeatMonthlyByNthDayOfWeek.setEnabled(true); mRepeatMonthlyByNthDayOfMonth.setEnabled(true); for (Button button : mWeekByDayButtons) { button.setEnabled(true); } } updateDoneButtonState(); } private void updateDoneButtonState() { if (mModel.recurrenceState == RecurrenceModel.STATE_NO_RECURRENCE) { mDoneButton.setEnabled(true); return; } if (mInterval.getText().toString().length() == 0) { mDoneButton.setEnabled(false); return; } if (mEndCount.getVisibility() == View.VISIBLE && mEndCount.getText().toString().length() == 0) { mDoneButton.setEnabled(false); return; } if (mModel.freq == RecurrenceModel.FREQ_WEEKLY) { for (CompoundButton b : mWeekByDayButtons) { if (b.isChecked()) { mDoneButton.setEnabled(true); return; } } mDoneButton.setEnabled(false); return; } mDoneButton.setEnabled(true); } @Override public void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); outState.putParcelable(BUNDLE_MODEL, mModel); if (mEndCount.hasFocus()) { outState.putBoolean(BUNDLE_END_COUNT_HAS_FOCUS, true); } } public void updateDialog() { // Interval // Checking before setting because this causes infinite recursion // in afterTextWatcher final String intervalStr = Integer.toString(mModel.interval); if (!intervalStr.equals(mInterval.getText().toString())) { mInterval.setText(intervalStr); } mFreqSpinner.setSelection(mModel.freq); mWeekGroup.setVisibility(mModel.freq == RecurrenceModel.FREQ_WEEKLY ? View.VISIBLE : View.GONE); mWeekGroup2.setVisibility(mModel.freq == RecurrenceModel.FREQ_WEEKLY ? View.VISIBLE : View.GONE); mMonthGroup.setVisibility(mModel.freq == RecurrenceModel.FREQ_MONTHLY ? View.VISIBLE : View.GONE); switch (mModel.freq) { case RecurrenceModel.FREQ_HOURLY: mIntervalResId = R.plurals.recurrence_interval_hourly; break; case RecurrenceModel.FREQ_DAILY: mIntervalResId = R.plurals.recurrence_interval_daily; break; case RecurrenceModel.FREQ_WEEKLY: mIntervalResId = R.plurals.recurrence_interval_weekly; for (int i = 0; i < 7; i++) { mWeekByDayButtons[i].setChecked(mModel.weeklyByDayOfWeek[i]); } break; case RecurrenceModel.FREQ_MONTHLY: mIntervalResId = R.plurals.recurrence_interval_monthly; if (mModel.monthlyRepeat == RecurrenceModel.MONTHLY_BY_DATE) { mMonthRepeatByRadioGroup.check(R.id.repeatMonthlyByNthDayOfMonth); } else if (mModel.monthlyRepeat == RecurrenceModel.MONTHLY_BY_NTH_DAY_OF_WEEK) { mMonthRepeatByRadioGroup.check(R.id.repeatMonthlyByNthDayOfTheWeek); } if (mMonthRepeatByDayOfWeekStr == null) { if (mModel.monthlyByNthDayOfWeek == 0) { mModel.monthlyByNthDayOfWeek = (mTime.monthDay + 6) / 7; // Since not all months have 5 weeks, we convert 5th NthDayOfWeek to // -1 for last monthly day of the week if (mModel.monthlyByNthDayOfWeek >= FIFTH_WEEK_IN_A_MONTH) { mModel.monthlyByNthDayOfWeek = LAST_NTH_DAY_OF_WEEK; } mModel.monthlyByDayOfWeek = mTime.weekDay; } String[] monthlyByNthDayOfWeekStrs = mMonthRepeatByDayOfWeekStrs[mModel.monthlyByDayOfWeek]; // TODO(psliwowski): Find a better way handle -1 indexes int msgIndex = mModel.monthlyByNthDayOfWeek < 0 ? FIFTH_WEEK_IN_A_MONTH : mModel.monthlyByNthDayOfWeek; mMonthRepeatByDayOfWeekStr = monthlyByNthDayOfWeekStrs[msgIndex - 1]; mRepeatMonthlyByNthDayOfWeek.setText(mMonthRepeatByDayOfWeekStr); } break; case RecurrenceModel.FREQ_YEARLY: mIntervalResId = R.plurals.recurrence_interval_yearly; break; } updateIntervalText(); updateDoneButtonState(); mEndSpinner.setSelection(mModel.end); if (mModel.end == RecurrenceModel.END_BY_DATE) { final String dateStr = DateUtils.formatDateTime(getActivity(), mModel.endDate.toMillis(false), DateUtils.FORMAT_NUMERIC_DATE); mEndDateTextView.setText(dateStr); } else { if (mModel.end == RecurrenceModel.END_BY_COUNT) { // Checking before setting because this causes infinite // recursion // in afterTextWatcher final String countStr = Integer.toString(mModel.endCount); if (!countStr.equals(mEndCount.getText().toString())) { mEndCount.setText(countStr); } } } } /** * @param endDateString */ private void setEndSpinnerEndDateStr(final String endDateString) { mEndSpinnerArray.set(1, endDateString); mEndSpinnerAdapter.notifyDataSetChanged(); } private void doToast() { Log.e(TAG, "Model = " + mModel.toString()); String rrule; if (mModel.recurrenceState == RecurrenceModel.STATE_NO_RECURRENCE) { rrule = "Not repeating"; } else { copyModelToEventRecurrence(mModel, mRecurrence); rrule = mRecurrence.toString(); } if (mToast != null) { mToast.cancel(); } mToast = Toast.makeText(getActivity(), rrule, Toast.LENGTH_LONG); mToast.show(); } // TODO Test and update for Right-to-Left private void updateIntervalText() { if (mIntervalResId == -1) { return; } final String INTERVAL_COUNT_MARKER = "%d"; String intervalString = mResources.getQuantityString(mIntervalResId, mModel.interval); int markerStart = intervalString.indexOf(INTERVAL_COUNT_MARKER); if (markerStart != -1) { int postTextStart = markerStart + INTERVAL_COUNT_MARKER.length(); mIntervalPostText.setText(intervalString.substring(postTextStart, intervalString.length()).trim()); mIntervalPreText.setText(intervalString.substring(0, markerStart).trim()); } } /** * Update the "Repeat for N events" end option with the proper string values based on the value that has been * entered for N. */ private void updateEndCountText() { final String END_COUNT_MARKER = "%d"; String endString = mResources.getQuantityString(R.plurals.recurrence_end_count, mModel.endCount); int markerStart = endString.indexOf(END_COUNT_MARKER); if (markerStart != -1) { if (markerStart == 0) { Log.e(TAG, "No text to put in to recurrence's end spinner."); } else { int postTextStart = markerStart + END_COUNT_MARKER.length(); mPostEndCount.setText(endString.substring(postTextStart, endString.length()).trim()); } } } // Implements OnItemSelectedListener interface // Freq spinner // End spinner @Override public void onItemSelected(AdapterView<?> parent, View view, int position, long id) { if (parent == mFreqSpinner) { mModel.freq = position; } else if (parent == mEndSpinner) { switch (position) { case RecurrenceModel.END_NEVER: mModel.end = RecurrenceModel.END_NEVER; break; case RecurrenceModel.END_BY_DATE: mModel.end = RecurrenceModel.END_BY_DATE; break; case RecurrenceModel.END_BY_COUNT: mModel.end = RecurrenceModel.END_BY_COUNT; if (mModel.endCount <= 1) { mModel.endCount = 1; } else if (mModel.endCount > COUNT_MAX) { mModel.endCount = COUNT_MAX; } updateEndCountText(); break; } mEndCount.setVisibility(mModel.end == RecurrenceModel.END_BY_COUNT ? View.VISIBLE : View.GONE); mEndDateTextView.setVisibility(mModel.end == RecurrenceModel.END_BY_DATE ? View.VISIBLE : View.GONE); mPostEndCount.setVisibility( mModel.end == RecurrenceModel.END_BY_COUNT && !mHidePostEndCount ? View.VISIBLE : View.GONE); } updateDialog(); } // Implements OnItemSelectedListener interface @Override public void onNothingSelected(AdapterView<?> arg0) { } @Override public void onDateSet(CalendarDatePickerDialogFragment view, int year, int monthOfYear, int dayOfMonth) { if (mModel.endDate == null) { mModel.endDate = new Time(mTime.timezone); mModel.endDate.hour = mModel.endDate.minute = mModel.endDate.second = 0; } mModel.endDate.year = year; mModel.endDate.month = monthOfYear; mModel.endDate.monthDay = dayOfMonth; mModel.endDate.normalize(false); updateDialog(); } // Implements OnCheckedChangeListener interface // Week repeat by day of week @Override public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { int itemIdx = -1; for (int i = 0; i < 7; i++) { if (itemIdx == -1 && buttonView == mWeekByDayButtons[i]) { itemIdx = i; mModel.weeklyByDayOfWeek[i] = isChecked; } } updateDialog(); } // Implements android.widget.RadioGroup.OnCheckedChangeListener interface // Month repeat by radio buttons @Override public void onCheckedChanged(RadioGroup group, int checkedId) { if (checkedId == R.id.repeatMonthlyByNthDayOfMonth) { mModel.monthlyRepeat = RecurrenceModel.MONTHLY_BY_DATE; } else if (checkedId == R.id.repeatMonthlyByNthDayOfTheWeek) { mModel.monthlyRepeat = RecurrenceModel.MONTHLY_BY_NTH_DAY_OF_WEEK; } updateDialog(); } // Implements OnClickListener interface // EndDate button // Done button @Override public void onClick(View v) { if (mEndDateTextView == v) { if (mDatePickerDialog != null) { mDatePickerDialog.dismiss(); } mDatePickerDialog = new CalendarDatePickerDialogFragment(); mDatePickerDialog.setOnDateSetListener(this); mDatePickerDialog.setPreselectedDate(mModel.endDate.year, mModel.endDate.month, mModel.endDate.monthDay); mDatePickerDialog.setFirstDayOfWeek(Utils.getFirstDayOfWeekAsCalendar(getActivity())); mDatePickerDialog.show(getFragmentManager(), FRAG_TAG_DATE_PICKER); } else if (mDoneButton == v) { String rrule; if (mModel.recurrenceState == RecurrenceModel.STATE_NO_RECURRENCE) { rrule = null; } else { copyModelToEventRecurrence(mModel, mRecurrence); rrule = mRecurrence.toString(); } mRecurrenceSetListener.onRecurrenceSet(rrule); dismiss(); } } @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); mDatePickerDialog = (CalendarDatePickerDialogFragment) getFragmentManager() .findFragmentByTag(FRAG_TAG_DATE_PICKER); if (mDatePickerDialog != null) { mDatePickerDialog.setOnDateSetListener(this); } } public interface OnRecurrenceSetListener { void onRecurrenceSet(String rrule); } public void setOnRecurrenceSetListener(OnRecurrenceSetListener l) { mRecurrenceSetListener = l; } private class EndSpinnerAdapter extends ArrayAdapter<CharSequence> { final String END_DATE_MARKER = "%s"; final String END_COUNT_MARKER = "%d"; private LayoutInflater mInflater; private int mItemResourceId; private int mTextResourceId; private ArrayList<CharSequence> mStrings; private String mEndDateString; private boolean mUseFormStrings; /** * @param context * @param strings * @param itemResourceId * @param textResourceId */ public EndSpinnerAdapter(Context context, ArrayList<CharSequence> strings, int itemResourceId, int textResourceId) { super(context, itemResourceId, strings); mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE); mItemResourceId = itemResourceId; mTextResourceId = textResourceId; mStrings = strings; mEndDateString = getResources().getString(R.string.recurrence_end_date); // If either date or count strings don't translate well, such that we aren't assured // to have some text available to be placed in the spinner, then we'll have to use // the more form-like versions of both strings instead. int markerStart = mEndDateString.indexOf(END_DATE_MARKER); if (markerStart <= 0) { // The date string does not have any text before the "%s" so we'll have to use the // more form-like strings instead. mUseFormStrings = true; } else { String countEndStr = getResources().getQuantityString(R.plurals.recurrence_end_count, 1); markerStart = countEndStr.indexOf(END_COUNT_MARKER); if (markerStart <= 0) { // The count string does not have any text before the "%d" so we'll have to use // the more form-like strings instead. mUseFormStrings = true; } } if (mUseFormStrings) { // We'll have to set the layout for the spinner to be weight=0 so it doesn't // take up too much space. mEndSpinner.setLayoutParams(new TableLayout.LayoutParams(0, LayoutParams.WRAP_CONTENT, 1f)); } } @NonNull @Override public View getView(int position, View convertView, @NonNull ViewGroup parent) { View v; // Check if we can recycle the view if (convertView == null) { v = mInflater.inflate(mTextResourceId, parent, false); } else { v = convertView; } TextView item = (TextView) v.findViewById(R.id.spinner_item); int markerStart; switch (position) { case RecurrenceModel.END_NEVER: item.setText(mStrings.get(RecurrenceModel.END_NEVER)); break; case RecurrenceModel.END_BY_DATE: markerStart = mEndDateString.indexOf(END_DATE_MARKER); if (markerStart != -1) { if (mUseFormStrings || markerStart == 0) { // If we get here, the translation of "Until" doesn't work correctly, // so we'll just set the whole "Until a date" string. item.setText(mEndDateLabel); } else { item.setText(mEndDateString.substring(0, markerStart).trim()); } } break; case RecurrenceModel.END_BY_COUNT: String endString = mResources.getQuantityString(R.plurals.recurrence_end_count, mModel.endCount); markerStart = endString.indexOf(END_COUNT_MARKER); if (markerStart != -1) { if (mUseFormStrings || markerStart == 0) { // If we get here, the translation of "For" doesn't work correctly, // so we'll just set the whole "For a number of events" string. item.setText(mEndCountLabel); // Also, we'll hide the " events" that would have been at the end. mPostEndCount.setVisibility(View.GONE); // Use this flag so the onItemSelected knows whether to show it later. mHidePostEndCount = true; } else { int postTextStart = markerStart + END_COUNT_MARKER.length(); mPostEndCount.setText(endString.substring(postTextStart, endString.length()).trim()); // In case it's a recycled view that wasn't visible. if (mModel.end == RecurrenceModel.END_BY_COUNT) { mPostEndCount.setVisibility(View.VISIBLE); } if (endString.charAt(markerStart - 1) == ' ') { markerStart--; } item.setText(endString.substring(0, markerStart).trim()); } } break; default: v = null; break; } return v; } @Override public View getDropDownView(int position, View convertView, @NonNull ViewGroup parent) { View v; // Check if we can recycle the view if (convertView == null) { v = mInflater.inflate(mItemResourceId, parent, false); } else { v = convertView; } TextView item = (TextView) v.findViewById(R.id.spinner_item); item.setText(mStrings.get(position)); return v; } } public RecurrencePickerDialogFragment setOnDismissListener(OnDialogDismissListener ondialogdismisslistener) { mDismissCallback = ondialogdismisslistener; return this; } }