Automated import from //branches/donutburger/...@141076,141076
[android/platform/packages/apps/Calendar.git] / src / com / android / calendar / EditEvent.java
1 /*
2  * Copyright (C) 2008 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package com.android.calendar;
18
19 import static android.provider.Calendar.EVENT_BEGIN_TIME;
20 import static android.provider.Calendar.EVENT_END_TIME;
21 import android.app.Activity;
22 import android.app.AlertDialog;
23 import android.app.DatePickerDialog;
24 import android.app.ProgressDialog;
25 import android.app.TimePickerDialog;
26 import android.app.DatePickerDialog.OnDateSetListener;
27 import android.app.TimePickerDialog.OnTimeSetListener;
28 import android.content.AsyncQueryHandler;
29 import android.content.ContentResolver;
30 import android.content.ContentUris;
31 import android.content.ContentValues;
32 import android.content.Context;
33 import android.content.DialogInterface;
34 import android.content.Intent;
35 import android.content.SharedPreferences;
36 import android.content.DialogInterface.OnCancelListener;
37 import android.content.DialogInterface.OnClickListener;
38 import android.content.res.Resources;
39 import android.database.Cursor;
40 import android.net.Uri;
41 import android.os.Bundle;
42 import android.pim.EventRecurrence;
43 import android.preference.PreferenceManager;
44 import android.provider.Calendar.Calendars;
45 import android.provider.Calendar.Events;
46 import android.provider.Calendar.Reminders;
47 import android.text.TextUtils;
48 import android.text.format.DateFormat;
49 import android.text.format.DateUtils;
50 import android.text.format.Time;
51 import android.util.Log;
52 import android.view.KeyEvent;
53 import android.view.LayoutInflater;
54 import android.view.Menu;
55 import android.view.MenuItem;
56 import android.view.View;
57 import android.view.Window;
58 import android.widget.ArrayAdapter;
59 import android.widget.Button;
60 import android.widget.CheckBox;
61 import android.widget.CompoundButton;
62 import android.widget.DatePicker;
63 import android.widget.ImageButton;
64 import android.widget.LinearLayout;
65 import android.widget.ResourceCursorAdapter;
66 import android.widget.Spinner;
67 import android.widget.TextView;
68 import android.widget.TimePicker;
69 import android.widget.Toast;
70
71 import java.util.ArrayList;
72 import java.util.Arrays;
73 import java.util.Calendar;
74 import java.util.TimeZone;
75
76 public class EditEvent extends Activity implements View.OnClickListener,
77         DialogInterface.OnCancelListener, DialogInterface.OnClickListener {
78     /**
79      * This is the symbolic name for the key used to pass in the boolean
80      * for creating all-day events that is part of the extra data of the intent.
81      * This is used only for creating new events and is set to true if
82      * the default for the new event should be an all-day event.
83      */
84     public static final String EVENT_ALL_DAY = "allDay";
85
86     private static final int MAX_REMINDERS = 5;
87
88     private static final int MENU_GROUP_REMINDER = 1;
89     private static final int MENU_GROUP_SHOW_OPTIONS = 2;
90     private static final int MENU_GROUP_HIDE_OPTIONS = 3;
91
92     private static final int MENU_ADD_REMINDER = 1;
93     private static final int MENU_SHOW_EXTRA_OPTIONS = 2;
94     private static final int MENU_HIDE_EXTRA_OPTIONS = 3;
95
96     private static final String[] EVENT_PROJECTION = new String[] {
97             Events._ID,             // 0
98             Events.TITLE,           // 1
99             Events.DESCRIPTION,     // 2
100             Events.EVENT_LOCATION,  // 3
101             Events.ALL_DAY,         // 4
102             Events.HAS_ALARM,       // 5
103             Events.CALENDAR_ID,     // 6
104             Events.DTSTART,         // 7
105             Events.DURATION,        // 8
106             Events.EVENT_TIMEZONE,  // 9
107             Events.RRULE,           // 10
108             Events._SYNC_ID,        // 11
109             Events.TRANSPARENCY,    // 12
110             Events.VISIBILITY,      // 13
111     };
112     private static final int EVENT_INDEX_ID = 0;
113     private static final int EVENT_INDEX_TITLE = 1;
114     private static final int EVENT_INDEX_DESCRIPTION = 2;
115     private static final int EVENT_INDEX_EVENT_LOCATION = 3;
116     private static final int EVENT_INDEX_ALL_DAY = 4;
117     private static final int EVENT_INDEX_HAS_ALARM = 5;
118     private static final int EVENT_INDEX_CALENDAR_ID = 6;
119     private static final int EVENT_INDEX_DTSTART = 7;
120     private static final int EVENT_INDEX_DURATION = 8;
121     private static final int EVENT_INDEX_TIMEZONE = 9;
122     private static final int EVENT_INDEX_RRULE = 10;
123     private static final int EVENT_INDEX_SYNC_ID = 11;
124     private static final int EVENT_INDEX_TRANSPARENCY = 12;
125     private static final int EVENT_INDEX_VISIBILITY = 13;
126
127     private static final String[] CALENDARS_PROJECTION = new String[] {
128             Calendars._ID,          // 0
129             Calendars.DISPLAY_NAME, // 1
130             Calendars.TIMEZONE,     // 2
131     };
132     private static final int CALENDARS_INDEX_DISPLAY_NAME = 1;
133     private static final int CALENDARS_INDEX_TIMEZONE = 2;
134     private static final String CALENDARS_WHERE = Calendars.ACCESS_LEVEL + ">=" +
135             Calendars.CONTRIBUTOR_ACCESS + " AND " + Calendars.SYNC_EVENTS + "=1";
136
137     private static final String[] REMINDERS_PROJECTION = new String[] {
138             Reminders._ID,      // 0
139             Reminders.MINUTES,  // 1
140     };
141     private static final int REMINDERS_INDEX_MINUTES = 1;
142     private static final String REMINDERS_WHERE = Reminders.EVENT_ID + "=%d AND (" +
143             Reminders.METHOD + "=" + Reminders.METHOD_ALERT + " OR " + Reminders.METHOD + "=" +
144             Reminders.METHOD_DEFAULT + ")";
145
146     private static final int DOES_NOT_REPEAT = 0;
147     private static final int REPEATS_DAILY = 1;
148     private static final int REPEATS_EVERY_WEEKDAY = 2;
149     private static final int REPEATS_WEEKLY_ON_DAY = 3;
150     private static final int REPEATS_MONTHLY_ON_DAY_COUNT = 4;
151     private static final int REPEATS_MONTHLY_ON_DAY = 5;
152     private static final int REPEATS_YEARLY = 6;
153     private static final int REPEATS_CUSTOM = 7;
154
155     private static final int MODIFY_UNINITIALIZED = 0;
156     private static final int MODIFY_SELECTED = 1;
157     private static final int MODIFY_ALL = 2;
158     private static final int MODIFY_ALL_FOLLOWING = 3;
159     
160     private static final int DAY_IN_SECONDS = 24 * 60 * 60;
161
162     private int mFirstDayOfWeek; // cached in onCreate
163     private Uri mUri;
164     private Cursor mEventCursor;
165     private Cursor mCalendarsCursor;
166
167     private Button mStartDateButton;
168     private Button mEndDateButton;
169     private Button mStartTimeButton;
170     private Button mEndTimeButton;
171     private Button mSaveButton;
172     private Button mDeleteButton;
173     private Button mDiscardButton;
174     private CheckBox mAllDayCheckBox;
175     private Spinner mCalendarsSpinner;
176     private Spinner mRepeatsSpinner;
177     private Spinner mAvailabilitySpinner;
178     private Spinner mVisibilitySpinner;
179     private TextView mTitleTextView;
180     private TextView mLocationTextView;
181     private TextView mDescriptionTextView;
182     private View mRemindersSeparator;
183     private LinearLayout mRemindersContainer;
184     private LinearLayout mExtraOptions;
185     private ArrayList<Integer> mOriginalMinutes = new ArrayList<Integer>();
186     private ArrayList<LinearLayout> mReminderItems = new ArrayList<LinearLayout>(0);
187
188     private EventRecurrence mEventRecurrence = new EventRecurrence();
189     private String mRrule;
190     private boolean mCalendarsQueryComplete;
191     private boolean mSaveAfterQueryComplete;
192     private ProgressDialog mLoadingCalendarsDialog;
193     private AlertDialog mNoCalendarsDialog;
194     private ContentValues mInitialValues;
195
196     /**
197      * If the repeating event is created on the phone and it hasn't been
198      * synced yet to the web server, then there is a bug where you can't
199      * delete or change an instance of the repeating event.  This case
200      * can be detected with mSyncId.  If mSyncId == null, then the repeating
201      * event has not been synced to the phone, in which case we won't allow
202      * the user to change one instance.
203      */
204     private String mSyncId;
205
206     private ArrayList<Integer> mRecurrenceIndexes = new ArrayList<Integer> (0);
207     private ArrayList<Integer> mReminderValues;
208     private ArrayList<String> mReminderLabels;
209
210     private Time mStartTime;
211     private Time mEndTime;
212     private int mModification = MODIFY_UNINITIALIZED;
213     private int mDefaultReminderMinutes;
214
215     private DeleteEventHelper mDeleteEventHelper;
216     private QueryHandler mQueryHandler;
217     
218     /* This class is used to update the time buttons. */
219     private class TimeListener implements OnTimeSetListener {
220         private View mView;
221
222         public TimeListener(View view) {
223             mView = view;
224         }
225
226         public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
227             // Cache the member variables locally to avoid inner class overhead.
228             Time startTime = mStartTime;
229             Time endTime = mEndTime;
230
231             // Cache the start and end millis so that we limit the number
232             // of calls to normalize() and toMillis(), which are fairly
233             // expensive.
234             long startMillis;
235             long endMillis;
236             if (mView == mStartTimeButton) {
237                 // The start time was changed.
238                 int hourDuration = endTime.hour - startTime.hour;
239                 int minuteDuration = endTime.minute - startTime.minute;
240
241                 startTime.hour = hourOfDay;
242                 startTime.minute = minute;
243                 startMillis = startTime.normalize(true);
244
245                 // Also update the end time to keep the duration constant.
246                 endTime.hour = hourOfDay + hourDuration;
247                 endTime.minute = minute + minuteDuration;
248                 endMillis = endTime.normalize(true);
249             } else {
250                 // The end time was changed.
251                 startMillis = startTime.toMillis(true);
252                 endTime.hour = hourOfDay;
253                 endTime.minute = minute;
254                 endMillis = endTime.normalize(true);
255
256                 // Do not allow an event to have an end time before the start time.
257                 if (endTime.before(startTime)) {
258                     endTime.set(startTime);
259                     endMillis = startMillis;
260                 }
261             }
262
263             setDate(mEndDateButton, endMillis);
264             setTime(mStartTimeButton, startMillis);
265             setTime(mEndTimeButton, endMillis);
266         }
267     }
268
269     private class TimeClickListener implements View.OnClickListener {
270         private Time mTime;
271
272         public TimeClickListener(Time time) {
273             mTime = time;
274         }
275
276         public void onClick(View v) {
277             new TimePickerDialog(EditEvent.this, new TimeListener(v),
278                     mTime.hour, mTime.minute,
279                     DateFormat.is24HourFormat(EditEvent.this)).show();
280         }
281     }
282
283     private class DateListener implements OnDateSetListener {
284         View mView;
285
286         public DateListener(View view) {
287             mView = view;
288         }
289
290         public void onDateSet(DatePicker view, int year, int month, int monthDay) {
291             // Cache the member variables locally to avoid inner class overhead.
292             Time startTime = mStartTime;
293             Time endTime = mEndTime;
294
295             // Cache the start and end millis so that we limit the number
296             // of calls to normalize() and toMillis(), which are fairly
297             // expensive.
298             long startMillis;
299             long endMillis;
300             if (mView == mStartDateButton) {
301                 // The start date was changed.
302                 int yearDuration = endTime.year - startTime.year;
303                 int monthDuration = endTime.month - startTime.month;
304                 int monthDayDuration = endTime.monthDay - startTime.monthDay;
305
306                 startTime.year = year;
307                 startTime.month = month;
308                 startTime.monthDay = monthDay;
309                 startMillis = startTime.normalize(true);
310
311                 // Also update the end date to keep the duration constant.
312                 endTime.year = year + yearDuration;
313                 endTime.month = month + monthDuration;
314                 endTime.monthDay = monthDay + monthDayDuration;
315                 endMillis = endTime.normalize(true);
316
317                 // If the start date has changed then update the repeats.
318                 populateRepeats();
319             } else {
320                 // The end date was changed.
321                 startMillis = startTime.toMillis(true);
322                 endTime.year = year;
323                 endTime.month = month;
324                 endTime.monthDay = monthDay;
325                 endMillis = endTime.normalize(true);
326
327                 // Do not allow an event to have an end time before the start time.
328                 if (endTime.before(startTime)) {
329                     endTime.set(startTime);
330                     endMillis = startMillis;
331                 }
332             }
333
334             setDate(mStartDateButton, startMillis);
335             setDate(mEndDateButton, endMillis);
336             setTime(mEndTimeButton, endMillis); // In case end time had to be reset
337         }
338     }
339
340     private class DateClickListener implements View.OnClickListener {
341         private Time mTime;
342
343         public DateClickListener(Time time) {
344             mTime = time;
345         }
346
347         public void onClick(View v) {
348             new DatePickerDialog(EditEvent.this, new DateListener(v), mTime.year,
349                     mTime.month, mTime.monthDay).show();
350         }
351     }
352
353     private class CalendarsAdapter extends ResourceCursorAdapter {
354         public CalendarsAdapter(Context context, Cursor c) {
355             super(context, R.layout.calendars_item, c);
356             setDropDownViewResource(R.layout.calendars_dropdown_item);
357         }
358
359         @Override
360         public void bindView(View view, Context context, Cursor cursor) {
361             TextView name = (TextView) view.findViewById(R.id.calendar_name);
362             name.setText(cursor.getString(CALENDARS_INDEX_DISPLAY_NAME));
363         }
364     }
365
366     // This is called if the user clicks on one of the buttons: "Save",
367     // "Discard", or "Delete".  This is also called if the user clicks
368     // on the "remove reminder" button.
369     public void onClick(View v) {
370         if (v == mSaveButton) {
371             if (save()) {
372                 finish();
373             }
374             return;
375         }
376         
377         if (v == mDeleteButton) {
378             long begin = mStartTime.toMillis(false /* use isDst */);
379             long end = mEndTime.toMillis(false /* use isDst */);
380             int which = -1;
381             switch (mModification) {
382             case MODIFY_SELECTED:
383                 which = DeleteEventHelper.DELETE_SELECTED;
384                 break;
385             case MODIFY_ALL_FOLLOWING:
386                 which = DeleteEventHelper.DELETE_ALL_FOLLOWING;
387                 break;
388             case MODIFY_ALL:
389                 which = DeleteEventHelper.DELETE_ALL;
390                 break;
391             }
392             mDeleteEventHelper.delete(begin, end, mEventCursor, which);
393             return;
394         }
395         
396         if (v == mDiscardButton) {
397             finish();
398             return;
399         }
400         
401         // This must be a click on one of the "remove reminder" buttons
402         LinearLayout reminderItem = (LinearLayout) v.getParent();
403         LinearLayout parent = (LinearLayout) reminderItem.getParent();
404         parent.removeView(reminderItem);
405         mReminderItems.remove(reminderItem);
406         updateRemindersVisibility();
407     }
408
409     // This is called if the user cancels a popup dialog.  There are two
410     // dialogs: the "Loading calendars" dialog, and the "No calendars"
411     // dialog.  The "Loading calendars" dialog is shown if there is a delay
412     // in loading the calendars (needed when creating an event) and the user
413     // tries to save the event before the calendars have finished loading.
414     // The "No calendars" dialog is shown if there are no syncable calendars.
415     public void onCancel(DialogInterface dialog) {
416         if (dialog == mLoadingCalendarsDialog) {
417             mSaveAfterQueryComplete = false;
418         } else if (dialog == mNoCalendarsDialog) {
419             finish();
420         }
421     }
422
423     // This is called if the user clicks on a dialog button.
424     public void onClick(DialogInterface dialog, int which) {
425         if (dialog == mNoCalendarsDialog) {
426             finish();
427         }
428     }
429     
430     private class QueryHandler extends AsyncQueryHandler {
431         public QueryHandler(ContentResolver cr) {
432             super(cr);
433         }
434
435         @Override
436         protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
437             // If the Activity is finishing, then close the cursor.
438             // Otherwise, use the new cursor in the adapter.
439             if (isFinishing()) {
440                 stopManagingCursor(cursor);
441                 cursor.close();
442             } else {
443                 mCalendarsCursor = cursor;
444                 startManagingCursor(cursor);
445                 
446                 // Stop the spinner
447                 getWindow().setFeatureInt(Window.FEATURE_INDETERMINATE_PROGRESS,
448                         Window.PROGRESS_VISIBILITY_OFF);
449
450                 // If there are no syncable calendars, then we cannot allow
451                 // creating a new event.
452                 if (cursor.getCount() == 0) {
453                     // Cancel the "loading calendars" dialog if it exists
454                     if (mSaveAfterQueryComplete) {
455                         mLoadingCalendarsDialog.cancel();
456                     }
457                     
458                     // Create an error message for the user that, when clicked,
459                     // will exit this activity without saving the event.
460                     AlertDialog.Builder builder = new AlertDialog.Builder(EditEvent.this);
461                     builder.setTitle(R.string.no_syncable_calendars)
462                         .setIcon(android.R.drawable.ic_dialog_alert)
463                         .setMessage(R.string.no_calendars_found)
464                         .setPositiveButton(android.R.string.ok, EditEvent.this)
465                         .setOnCancelListener(EditEvent.this);
466                     mNoCalendarsDialog = builder.show();
467                     return;
468                 }
469
470                 // populate the calendars spinner
471                 CalendarsAdapter adapter = new CalendarsAdapter(EditEvent.this, mCalendarsCursor);
472                 mCalendarsSpinner.setAdapter(adapter);
473                 mCalendarsQueryComplete = true;
474                 if (mSaveAfterQueryComplete) {
475                     mLoadingCalendarsDialog.cancel();
476                     save();
477                     finish();
478                 }
479             }
480         }
481     }
482
483     @Override
484     protected void onCreate(Bundle icicle) {
485         super.onCreate(icicle);
486         requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
487         setContentView(R.layout.edit_event);
488
489         mFirstDayOfWeek = Calendar.getInstance().getFirstDayOfWeek();
490
491         mStartTime = new Time();
492         mEndTime = new Time();
493
494         Intent intent = getIntent();
495         mUri = intent.getData();
496
497         if (mUri != null) {
498             mEventCursor = managedQuery(mUri, EVENT_PROJECTION, null, null);
499             if (mEventCursor == null || mEventCursor.getCount() == 0) {
500                 // The cursor is empty. This can happen if the event was deleted.
501                 finish();
502                 return;
503             }
504         }
505
506         long begin = intent.getLongExtra(EVENT_BEGIN_TIME, 0);
507         long end = intent.getLongExtra(EVENT_END_TIME, 0);
508
509         boolean allDay = false;
510         if (mEventCursor != null) {
511             // The event already exists so fetch the all-day status
512             mEventCursor.moveToFirst();
513             allDay = mEventCursor.getInt(EVENT_INDEX_ALL_DAY) != 0;
514             String rrule = mEventCursor.getString(EVENT_INDEX_RRULE);
515             String timezone = mEventCursor.getString(EVENT_INDEX_TIMEZONE);
516             long calendarId = mEventCursor.getInt(EVENT_INDEX_CALENDAR_ID);
517             
518             // Remember the initial values
519             mInitialValues = new ContentValues();
520             mInitialValues.put(EVENT_BEGIN_TIME, begin);
521             mInitialValues.put(EVENT_END_TIME, end);
522             mInitialValues.put(Events.ALL_DAY, allDay ? 1 : 0);
523             mInitialValues.put(Events.RRULE, rrule);
524             mInitialValues.put(Events.EVENT_TIMEZONE, timezone);
525             mInitialValues.put(Events.CALENDAR_ID, calendarId);
526         } else {
527             // We are creating a new event, so set the default from the
528             // intent (if specified).
529             allDay = intent.getBooleanExtra(EVENT_ALL_DAY, false);
530             
531             // Start the spinner
532             getWindow().setFeatureInt(Window.FEATURE_INDETERMINATE_PROGRESS,
533                     Window.PROGRESS_VISIBILITY_ON);
534
535             // Start a query in the background to read the list of calendars
536             mQueryHandler = new QueryHandler(getContentResolver());
537             mQueryHandler.startQuery(0, null, Calendars.CONTENT_URI, CALENDARS_PROJECTION,
538                     CALENDARS_WHERE, null /* selection args */, null /* sort order */);
539         }
540
541         // If the event is all-day, read the times in UTC timezone
542         if (begin != 0) {
543             if (allDay) {
544                 String tz = mStartTime.timezone;
545                 mStartTime.timezone = Time.TIMEZONE_UTC;
546                 mStartTime.set(begin);
547                 mStartTime.timezone = tz;
548
549                 // Calling normalize to calculate isDst
550                 mStartTime.normalize(true);
551             } else {
552                 mStartTime.set(begin);
553             }
554         }
555
556         if (end != 0) {
557             if (allDay) {
558                 String tz = mStartTime.timezone;
559                 mEndTime.timezone = Time.TIMEZONE_UTC;
560                 mEndTime.set(end);
561                 mEndTime.timezone = tz;
562
563                 // Calling normalize to calculate isDst
564                 mEndTime.normalize(true);
565             } else {
566                 mEndTime.set(end);
567             }
568         }
569
570         // cache all the widgets
571         mTitleTextView = (TextView) findViewById(R.id.title);
572         mLocationTextView = (TextView) findViewById(R.id.location);
573         mDescriptionTextView = (TextView) findViewById(R.id.description);
574         mStartDateButton = (Button) findViewById(R.id.start_date);
575         mEndDateButton = (Button) findViewById(R.id.end_date);
576         mStartTimeButton = (Button) findViewById(R.id.start_time);
577         mEndTimeButton = (Button) findViewById(R.id.end_time);
578         mAllDayCheckBox = (CheckBox) findViewById(R.id.is_all_day);
579         mCalendarsSpinner = (Spinner) findViewById(R.id.calendars);
580         mRepeatsSpinner = (Spinner) findViewById(R.id.repeats);
581         mAvailabilitySpinner = (Spinner) findViewById(R.id.availability);
582         mVisibilitySpinner = (Spinner) findViewById(R.id.visibility);
583         mRemindersSeparator = findViewById(R.id.reminders_separator);
584         mRemindersContainer = (LinearLayout) findViewById(R.id.reminder_items_container);
585         mExtraOptions = (LinearLayout) findViewById(R.id.extra_options_container);
586
587         mAllDayCheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
588             public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
589                 if (isChecked) {
590                     if (mEndTime.hour == 0 && mEndTime.minute == 0) {
591                         mEndTime.monthDay--;
592                         long endMillis = mEndTime.normalize(true);
593
594                         // Do not allow an event to have an end time before the start time.
595                         if (mEndTime.before(mStartTime)) {
596                             mEndTime.set(mStartTime);
597                             endMillis = mEndTime.normalize(true);
598                         }
599                         setDate(mEndDateButton, endMillis);
600                         setTime(mEndTimeButton, endMillis);
601                     }
602
603                     mStartTimeButton.setVisibility(View.GONE);
604                     mEndTimeButton.setVisibility(View.GONE);
605                 } else {
606                     if (mEndTime.hour == 0 && mEndTime.minute == 0) {
607                         mEndTime.monthDay++;
608                         long endMillis = mEndTime.normalize(true);
609                         setDate(mEndDateButton, endMillis);
610                         setTime(mEndTimeButton, endMillis);
611                     }
612
613                     mStartTimeButton.setVisibility(View.VISIBLE);
614                     mEndTimeButton.setVisibility(View.VISIBLE);
615                 }
616             }
617         });
618
619         if (allDay) {
620             mAllDayCheckBox.setChecked(true);
621         } else {
622             mAllDayCheckBox.setChecked(false);
623         }
624
625         mSaveButton = (Button) findViewById(R.id.save);
626         mSaveButton.setOnClickListener(this);
627
628         mDeleteButton = (Button) findViewById(R.id.delete);
629         mDeleteButton.setOnClickListener(this);
630
631         mDiscardButton = (Button) findViewById(R.id.discard);
632         mDiscardButton.setOnClickListener(this);
633
634         // Initialize the reminder values array.
635         Resources r = getResources();
636         String[] strings = r.getStringArray(R.array.reminder_minutes_values);
637         int size = strings.length;
638         ArrayList<Integer> list = new ArrayList<Integer>(size);
639         for (int i = 0 ; i < size ; i++) {
640             list.add(Integer.parseInt(strings[i]));
641         }
642         mReminderValues = list;
643         String[] labels = r.getStringArray(R.array.reminder_minutes_labels);
644         mReminderLabels = new ArrayList<String>(Arrays.asList(labels));
645
646         SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
647         String durationString =
648                 prefs.getString(CalendarPreferenceActivity.KEY_DEFAULT_REMINDER, "0");
649         mDefaultReminderMinutes = Integer.parseInt(durationString);
650
651         // Reminders cursor
652         boolean hasAlarm = (mEventCursor != null)
653                 && (mEventCursor.getInt(EVENT_INDEX_HAS_ALARM) != 0);
654         if (hasAlarm) {
655             Uri uri = Reminders.CONTENT_URI;
656             long eventId = mEventCursor.getLong(EVENT_INDEX_ID);
657             String where = String.format(REMINDERS_WHERE, eventId);
658             ContentResolver cr = getContentResolver();
659             Cursor reminderCursor = cr.query(uri, REMINDERS_PROJECTION, where, null, null);
660             try {
661                 // First pass: collect all the custom reminder minutes (e.g.,
662                 // a reminder of 8 minutes) into a global list.
663                 while (reminderCursor.moveToNext()) {
664                     int minutes = reminderCursor.getInt(REMINDERS_INDEX_MINUTES);
665                     EditEvent.addMinutesToList(this, mReminderValues, mReminderLabels, minutes);
666                 }
667                 
668                 // Second pass: create the reminder spinners
669                 reminderCursor.moveToPosition(-1);
670                 while (reminderCursor.moveToNext()) {
671                     int minutes = reminderCursor.getInt(REMINDERS_INDEX_MINUTES);
672                     mOriginalMinutes.add(minutes);
673                     EditEvent.addReminder(this, this, mReminderItems, mReminderValues,
674                             mReminderLabels, minutes);
675                 }
676             } finally {
677                 reminderCursor.close();
678             }
679         }
680         updateRemindersVisibility();
681
682         // Setup the + Add Reminder Button
683         View.OnClickListener addReminderOnClickListener = new View.OnClickListener() {
684             public void onClick(View v) {
685                 addReminder();
686             }
687         };        
688         ImageButton reminderRemoveButton = (ImageButton) findViewById(R.id.reminder_add);
689         reminderRemoveButton.setOnClickListener(addReminderOnClickListener);
690
691         mDeleteEventHelper = new DeleteEventHelper(this, true /* exit when done */);
692
693         if (mEventCursor == null) {
694             // Allow the intent to specify the fields in the event.
695             // This will allow other apps to create events easily.
696             initFromIntent(intent);
697         }
698     }
699     
700     private void initFromIntent(Intent intent) {
701         String title = intent.getStringExtra(Events.TITLE);
702         if (title != null) {
703             mTitleTextView.setText(title);
704         }
705         
706         String location = intent.getStringExtra(Events.EVENT_LOCATION);
707         if (location != null) {
708             mLocationTextView.setText(location);
709         }
710         
711         String description = intent.getStringExtra(Events.DESCRIPTION);
712         if (description != null) {
713             mDescriptionTextView.setText(description);
714         }
715         
716         int availability = intent.getIntExtra(Events.TRANSPARENCY, -1);
717         if (availability != -1) {
718             mAvailabilitySpinner.setSelection(availability);
719         }
720         
721         int visibility = intent.getIntExtra(Events.VISIBILITY, -1);
722         if (visibility != -1) {
723             mVisibilitySpinner.setSelection(visibility);
724         }
725         
726         String rrule = intent.getStringExtra(Events.RRULE);
727         if (rrule != null) {
728             mRrule = rrule;
729             mEventRecurrence.parse(rrule);
730         }
731     }
732
733     @Override
734     protected void onResume() {
735         super.onResume();
736
737         if (mUri != null) {
738             if (mEventCursor == null || mEventCursor.getCount() == 0) {
739                 // The cursor is empty. This can happen if the event was deleted.
740                 finish();
741                 return;
742             }
743         }
744         
745         if (mEventCursor != null) {
746             Cursor cursor = mEventCursor;
747             cursor.moveToFirst();
748
749             mRrule = cursor.getString(EVENT_INDEX_RRULE);
750             String title = cursor.getString(EVENT_INDEX_TITLE);
751             String description = cursor.getString(EVENT_INDEX_DESCRIPTION);
752             String location = cursor.getString(EVENT_INDEX_EVENT_LOCATION);
753             int availability = cursor.getInt(EVENT_INDEX_TRANSPARENCY);
754             int visibility = cursor.getInt(EVENT_INDEX_VISIBILITY);
755             if (visibility > 0) {
756                 // For now we the array contains the values 0, 2, and 3. We subtract one to match.
757                 visibility--;
758             }
759
760             if (!TextUtils.isEmpty(mRrule) && mModification == MODIFY_UNINITIALIZED) {
761                 // If this event has not been synced, then don't allow deleting
762                 // or changing a single instance.
763                 mSyncId = cursor.getString(EVENT_INDEX_SYNC_ID);
764                 mEventRecurrence.parse(mRrule);
765
766                 // If we haven't synced this repeating event yet, then don't
767                 // allow the user to change just one instance.
768                 int itemIndex = 0;
769                 CharSequence[] items;
770                 if (mSyncId == null) {
771                     items = new CharSequence[2];
772                 } else {
773                     items = new CharSequence[3];
774                     items[itemIndex++] = getText(R.string.modify_event);
775                 }
776                 items[itemIndex++] = getText(R.string.modify_all);
777                 items[itemIndex++] = getText(R.string.modify_all_following);
778
779                 // Display the modification dialog.
780                 new AlertDialog.Builder(this)
781                         .setOnCancelListener(new OnCancelListener() {
782                             public void onCancel(DialogInterface dialog) {
783                                 finish();
784                             }
785                         })
786                         .setTitle(R.string.edit_event_label)
787                         .setItems(items, new OnClickListener() {
788                             public void onClick(DialogInterface dialog, int which) {
789                                 if (which == 0) {
790                                     mModification =
791                                             (mSyncId == null) ? MODIFY_ALL : MODIFY_SELECTED;
792                                 } else if (which == 1) {
793                                     mModification =
794                                         (mSyncId == null) ? MODIFY_ALL_FOLLOWING : MODIFY_ALL;
795                                 } else if (which == 2) {
796                                     mModification = MODIFY_ALL_FOLLOWING;
797                                 }
798                                 
799                                 // If we are modifying all the events in a
800                                 // series then disable and ignore the date.
801                                 if (mModification == MODIFY_ALL) {
802                                     mStartDateButton.setEnabled(false);
803                                     mEndDateButton.setEnabled(false);
804                                 } else if (mModification == MODIFY_SELECTED) {
805                                     mRepeatsSpinner.setEnabled(false);
806                                 }
807                             }
808                         })
809                         .show();
810             }
811
812             mTitleTextView.setText(title);
813             mLocationTextView.setText(location);
814             mDescriptionTextView.setText(description);
815             mAvailabilitySpinner.setSelection(availability);
816             mVisibilitySpinner.setSelection(visibility);
817
818             // This is an existing event so hide the calendar spinner
819             // since we can't change the calendar.
820             View calendarGroup = findViewById(R.id.calendar_group);
821             calendarGroup.setVisibility(View.GONE);
822         } else if (Time.isEpoch(mStartTime) && Time.isEpoch(mEndTime)) {
823             mStartTime.setToNow();
824
825             // Round the time to the nearest half hour.
826             mStartTime.second = 0;
827             int minute = mStartTime.minute;
828             if (minute > 0 && minute <= 30) {
829                 mStartTime.minute = 30;
830             } else {
831                 mStartTime.minute = 0;
832                 mStartTime.hour += 1;
833             }
834
835             long startMillis = mStartTime.normalize(true /* ignore isDst */);
836             mEndTime.set(startMillis + DateUtils.HOUR_IN_MILLIS);
837         } else {
838             // New event - set the default reminder
839             if (mDefaultReminderMinutes != 0) {
840                 addReminder(this, this, mReminderItems, mReminderValues,
841                         mReminderLabels, mDefaultReminderMinutes);
842             }
843
844             // Hide delete button
845             mDeleteButton.setVisibility(View.GONE);
846         }
847
848         updateRemindersVisibility();
849         populateWhen();
850         populateRepeats();
851     }
852
853     @Override
854     public boolean onCreateOptionsMenu(Menu menu) {
855         MenuItem item;
856         item = menu.add(MENU_GROUP_REMINDER, MENU_ADD_REMINDER, 0,
857                 R.string.add_new_reminder);
858         item.setIcon(R.drawable.ic_menu_reminder);
859         item.setAlphabeticShortcut('r');
860
861         item = menu.add(MENU_GROUP_SHOW_OPTIONS, MENU_SHOW_EXTRA_OPTIONS, 0,
862                 R.string.edit_event_show_extra_options);
863         item.setIcon(R.drawable.ic_menu_show_list);
864         item = menu.add(MENU_GROUP_HIDE_OPTIONS, MENU_HIDE_EXTRA_OPTIONS, 0,
865                 R.string.edit_event_hide_extra_options);
866         item.setIcon(R.drawable.ic_menu_show_list);
867
868         return super.onCreateOptionsMenu(menu);
869     }
870
871     @Override
872     public boolean onPrepareOptionsMenu(Menu menu) {
873         if (mReminderItems.size() < MAX_REMINDERS) {
874             menu.setGroupVisible(MENU_GROUP_REMINDER, true);
875             menu.setGroupEnabled(MENU_GROUP_REMINDER, true);
876         } else {
877             menu.setGroupVisible(MENU_GROUP_REMINDER, false);
878             menu.setGroupEnabled(MENU_GROUP_REMINDER, false);
879         }
880
881         if (mExtraOptions.getVisibility() == View.VISIBLE) {
882             menu.setGroupVisible(MENU_GROUP_SHOW_OPTIONS, false);
883             menu.setGroupVisible(MENU_GROUP_HIDE_OPTIONS, true);
884         } else {
885             menu.setGroupVisible(MENU_GROUP_SHOW_OPTIONS, true);
886             menu.setGroupVisible(MENU_GROUP_HIDE_OPTIONS, false);
887         }
888
889         return super.onPrepareOptionsMenu(menu);
890     }
891
892     private void addReminder() {
893         // TODO: when adding a new reminder, make it different from the
894         // last one in the list (if any).
895         if (mDefaultReminderMinutes == 0) {
896             addReminder(this, this, mReminderItems, mReminderValues,
897                     mReminderLabels, 10 /* minutes */);
898         } else {
899             addReminder(this, this, mReminderItems, mReminderValues,
900                     mReminderLabels, mDefaultReminderMinutes);
901         }
902         updateRemindersVisibility();
903     }
904
905     @Override
906     public boolean onOptionsItemSelected(MenuItem item) {
907         switch (item.getItemId()) {
908         case MENU_ADD_REMINDER:
909             addReminder();
910             return true;
911         case MENU_SHOW_EXTRA_OPTIONS:
912             mExtraOptions.setVisibility(View.VISIBLE);
913             return true;
914         case MENU_HIDE_EXTRA_OPTIONS:
915             mExtraOptions.setVisibility(View.GONE);
916             return true;
917         }
918         return super.onOptionsItemSelected(item);
919     }
920
921     @Override
922     public boolean onKeyDown(int keyCode, KeyEvent event) {
923         switch (keyCode) {
924             case KeyEvent.KEYCODE_BACK:
925                 // If we are creating a new event, do not create it if the
926                 // title, location and description are all empty, in order to
927                 // prevent accidental "no subject" event creations.
928                 if (mUri != null || !isEmpty()) {
929                     if (!save()) {
930                         // We cannot exit this activity because the calendars
931                         // are still loading.
932                         return true;
933                     }
934                 }
935                 break;
936         }
937
938         return super.onKeyDown(keyCode, event);
939     }
940
941     private void populateWhen() {
942         long startMillis = mStartTime.toMillis(false /* use isDst */);
943         long endMillis = mEndTime.toMillis(false /* use isDst */);
944         setDate(mStartDateButton, startMillis);
945         setDate(mEndDateButton, endMillis);
946
947         setTime(mStartTimeButton, startMillis);
948         setTime(mEndTimeButton, endMillis);
949
950         mStartDateButton.setOnClickListener(new DateClickListener(mStartTime));
951         mEndDateButton.setOnClickListener(new DateClickListener(mEndTime));
952
953         mStartTimeButton.setOnClickListener(new TimeClickListener(mStartTime));
954         mEndTimeButton.setOnClickListener(new TimeClickListener(mEndTime));
955     }
956
957     private void populateRepeats() {
958         Time time = mStartTime;
959         Resources r = getResources();
960         int resource = android.R.layout.simple_spinner_item;
961
962         String[] days = r.getStringArray(R.array.day_labels);
963         String[] ordinals = r.getStringArray(R.array.ordinal_labels);
964
965         // Only display "Custom" in the spinner if the device does not support the
966         // recurrence functionality of the event. Only display every weekday if
967         // the event starts on a weekday.
968         boolean isCustomRecurrence = isCustomRecurrence();
969         boolean isWeekdayEvent = isWeekdayEvent();
970
971         ArrayList<String> repeatArray = new ArrayList<String>(0);
972         ArrayList<Integer> recurrenceIndexes = new ArrayList<Integer>(0);
973
974         repeatArray.add(r.getString(R.string.does_not_repeat));
975         recurrenceIndexes.add(DOES_NOT_REPEAT);
976
977         repeatArray.add(r.getString(R.string.daily));
978         recurrenceIndexes.add(REPEATS_DAILY);
979
980         if (isWeekdayEvent) {
981             repeatArray.add(r.getString(R.string.every_weekday));
982             recurrenceIndexes.add(REPEATS_EVERY_WEEKDAY);
983         }
984
985         String format = r.getString(R.string.weekly);
986         repeatArray.add(String.format(format, time.format("%A")));
987         recurrenceIndexes.add(REPEATS_WEEKLY_ON_DAY);
988
989         // Calculate whether this is the 1st, 2nd, 3rd, 4th, or last appearance of the given day.
990         int dayNumber = (time.monthDay - 1) / 7;
991         format = r.getString(R.string.monthly_on_day_count);
992         repeatArray.add(String.format(format, ordinals[dayNumber], days[time.weekDay]));
993         recurrenceIndexes.add(REPEATS_MONTHLY_ON_DAY_COUNT);
994
995         format = r.getString(R.string.monthly_on_day);
996         repeatArray.add(String.format(format, time.monthDay));
997         recurrenceIndexes.add(REPEATS_MONTHLY_ON_DAY);
998
999         long when = time.toMillis(false);
1000         format = r.getString(R.string.yearly);
1001         int flags = 0;
1002         if (DateFormat.is24HourFormat(this)) {
1003             flags |= DateUtils.FORMAT_24HOUR;
1004         }
1005         repeatArray.add(String.format(format, DateUtils.formatDateTime(this, when, flags)));
1006         recurrenceIndexes.add(REPEATS_YEARLY);
1007
1008         if (isCustomRecurrence) {
1009             repeatArray.add(r.getString(R.string.custom));
1010             recurrenceIndexes.add(REPEATS_CUSTOM);
1011         }
1012         mRecurrenceIndexes = recurrenceIndexes;
1013
1014         int position = recurrenceIndexes.indexOf(DOES_NOT_REPEAT);
1015         if (mRrule != null) {
1016             if (isCustomRecurrence) {
1017                 position = recurrenceIndexes.indexOf(REPEATS_CUSTOM);
1018             } else {
1019                 switch (mEventRecurrence.freq) {
1020                     case EventRecurrence.DAILY:
1021                         position = recurrenceIndexes.indexOf(REPEATS_DAILY);
1022                         break;
1023                     case EventRecurrence.WEEKLY:
1024                         if (mEventRecurrence.repeatsOnEveryWeekDay()) {
1025                             position = recurrenceIndexes.indexOf(REPEATS_EVERY_WEEKDAY);
1026                         } else {
1027                             position = recurrenceIndexes.indexOf(REPEATS_WEEKLY_ON_DAY);
1028                         }
1029                         break;
1030                     case EventRecurrence.MONTHLY:
1031                         if (mEventRecurrence.repeatsMonthlyOnDayCount()) {
1032                             position = recurrenceIndexes.indexOf(REPEATS_MONTHLY_ON_DAY_COUNT);
1033                         } else {
1034                             position = recurrenceIndexes.indexOf(REPEATS_MONTHLY_ON_DAY);
1035                         }
1036                         break;
1037                     case EventRecurrence.YEARLY:
1038                         position = recurrenceIndexes.indexOf(REPEATS_YEARLY);
1039                         break;
1040                 }
1041             }
1042         }
1043         ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, resource, repeatArray);
1044         adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
1045         mRepeatsSpinner.setAdapter(adapter);
1046         mRepeatsSpinner.setSelection(position);
1047     }
1048
1049     // Adds a reminder to the displayed list of reminders.
1050     // Returns true if successfully added reminder, false if no reminders can
1051     // be added.
1052     static boolean addReminder(Activity activity, View.OnClickListener listener,
1053             ArrayList<LinearLayout> items, ArrayList<Integer> values,
1054             ArrayList<String> labels, int minutes) {
1055
1056         if (items.size() >= MAX_REMINDERS) {
1057             return false;
1058         }
1059
1060         LayoutInflater inflater = activity.getLayoutInflater();
1061         LinearLayout parent = (LinearLayout) activity.findViewById(R.id.reminder_items_container);
1062         LinearLayout reminderItem = (LinearLayout) inflater.inflate(R.layout.edit_reminder_item, null);
1063         parent.addView(reminderItem);
1064         
1065         Spinner spinner = (Spinner) reminderItem.findViewById(R.id.reminder_value);
1066         Resources res = activity.getResources();
1067         spinner.setPrompt(res.getString(R.string.reminders_label));
1068         int resource = android.R.layout.simple_spinner_item;
1069         ArrayAdapter<String> adapter = new ArrayAdapter<String>(activity, resource, labels);
1070         adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
1071         spinner.setAdapter(adapter);
1072         
1073         ImageButton reminderRemoveButton;
1074         reminderRemoveButton = (ImageButton) reminderItem.findViewById(R.id.reminder_remove);
1075         reminderRemoveButton.setOnClickListener(listener);
1076
1077         int index = findMinutesInReminderList(values, minutes);
1078         spinner.setSelection(index);
1079         items.add(reminderItem);
1080
1081         return true;
1082     }
1083     
1084     static void addMinutesToList(Context context, ArrayList<Integer> values,
1085             ArrayList<String> labels, int minutes) {
1086         int index = values.indexOf(minutes);
1087         if (index != -1) {
1088             return;
1089         }
1090         
1091         // The requested "minutes" does not exist in the list, so insert it
1092         // into the list.
1093         
1094         String label = constructReminderLabel(context, minutes, false);
1095         int len = values.size();
1096         for (int i = 0; i < len; i++) {
1097             if (minutes < values.get(i)) {
1098                 values.add(i, minutes);
1099                 labels.add(i, label);
1100                 return;
1101             }
1102         }
1103         
1104         values.add(minutes);
1105         labels.add(len, label);
1106     }
1107     
1108     /**
1109      * Finds the index of the given "minutes" in the "values" list.
1110      * 
1111      * @param values the list of minutes corresponding to the spinner choices
1112      * @param minutes the minutes to search for in the values list
1113      * @return the index of "minutes" in the "values" list
1114      */
1115     private static int findMinutesInReminderList(ArrayList<Integer> values, int minutes) {
1116         int index = values.indexOf(minutes);
1117         if (index == -1) {
1118             // This should never happen.
1119             Log.e("Cal", "Cannot find minutes (" + minutes + ") in list");
1120             return 0;
1121         }
1122         return index;
1123     }
1124     
1125     // Constructs a label given an arbitrary number of minutes.  For example,
1126     // if the given minutes is 63, then this returns the string "63 minutes".
1127     // As another example, if the given minutes is 120, then this returns
1128     // "2 hours".
1129     static String constructReminderLabel(Context context, int minutes, boolean abbrev) {
1130         Resources resources = context.getResources();
1131         int value, resId;
1132         
1133         if (minutes % 60 != 0) {
1134             value = minutes;
1135             if (abbrev) {
1136                 resId = R.plurals.Nmins;
1137             } else {
1138                 resId = R.plurals.Nminutes;
1139             }
1140         } else if (minutes % (24 * 60) != 0) {
1141             value = minutes / 60;
1142             resId = R.plurals.Nhours;
1143         } else {
1144             value = minutes / ( 24 * 60);
1145             resId = R.plurals.Ndays;
1146         }
1147
1148         String format = resources.getQuantityString(resId, value);
1149         return String.format(format, value);
1150     }
1151
1152     private void updateRemindersVisibility() {
1153         if (mReminderItems.size() == 0) {
1154             mRemindersSeparator.setVisibility(View.GONE);
1155             mRemindersContainer.setVisibility(View.GONE);
1156         } else {
1157             mRemindersSeparator.setVisibility(View.VISIBLE);
1158             mRemindersContainer.setVisibility(View.VISIBLE);
1159         }
1160     }
1161
1162     private void setDate(TextView view, long millis) {
1163         int flags = DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR |
1164                 DateUtils.FORMAT_SHOW_WEEKDAY | DateUtils.FORMAT_ABBREV_MONTH |
1165                 DateUtils.FORMAT_ABBREV_WEEKDAY;
1166         view.setText(DateUtils.formatDateTime(this, millis, flags));
1167     }
1168
1169     private void setTime(TextView view, long millis) {
1170         int flags = DateUtils.FORMAT_SHOW_TIME;
1171         if (DateFormat.is24HourFormat(this)) {
1172             flags |= DateUtils.FORMAT_24HOUR;
1173         }
1174         view.setText(DateUtils.formatDateTime(this, millis, flags));
1175     }
1176
1177     // Saves the event.  Returns true if it is okay to exit this activity.
1178     private boolean save() {
1179         // If we are creating a new event, then make sure we wait until the
1180         // query to fetch the list of calendars has finished.
1181         if (mEventCursor == null) {
1182             if (!mCalendarsQueryComplete) {
1183                 // Wait for the calendars query to finish.
1184                 if (mLoadingCalendarsDialog == null) {
1185                     // Create the progress dialog
1186                     mLoadingCalendarsDialog = ProgressDialog.show(this,
1187                             getText(R.string.loading_calendars_title),
1188                             getText(R.string.loading_calendars_message),
1189                             true, true, this);
1190                     mSaveAfterQueryComplete = true;
1191                 }
1192                 return false;
1193             }
1194
1195             // Avoid creating a new event if the calendars cursor is empty. This
1196             // shouldn't ever happen since the setup wizard should ensure the user
1197             // has a calendar.
1198             if (mCalendarsCursor == null || mCalendarsCursor.getCount() == 0) {
1199                 Log.w("Cal", "The calendars table does not contain any calendars."
1200                         + " New event was not created.");
1201                 return true;
1202             }
1203             Toast.makeText(this, R.string.creating_event, Toast.LENGTH_SHORT).show();
1204         } else {
1205             Toast.makeText(this, R.string.saving_event, Toast.LENGTH_SHORT).show();
1206         }
1207
1208         ContentResolver cr = getContentResolver();
1209         ContentValues values = getContentValuesFromUi();
1210         Uri uri = mUri;
1211
1212         // For recurring events, we must make sure that we use duration rather
1213         // than dtend.
1214         if (uri == null) {
1215             // Create new event with new contents
1216             addRecurrenceRule(values);
1217             uri = cr.insert(Events.CONTENT_URI, values);
1218
1219         } else if (mRrule == null) {
1220             // Modify contents of a non-repeating event
1221             addRecurrenceRule(values);
1222             checkTimeDependentFields(values);
1223             cr.update(uri, values, null, null);
1224             
1225         } else if (mInitialValues.getAsString(Events.RRULE) == null) {
1226             // This event was changed from a non-repeating event to a
1227             // repeating event.
1228             addRecurrenceRule(values);
1229             values.remove(Events.DTEND);
1230             cr.update(uri, values, null, null);
1231
1232         } else if (mModification == MODIFY_SELECTED) {
1233             // Modify contents of the current instance of repeating event
1234
1235             // Create a recurrence exception
1236             long begin = mInitialValues.getAsLong(EVENT_BEGIN_TIME);
1237             values.put(Events.ORIGINAL_EVENT, mEventCursor.getString(EVENT_INDEX_SYNC_ID));
1238             values.put(Events.ORIGINAL_INSTANCE_TIME, begin);
1239             boolean allDay = mInitialValues.getAsInteger(Events.ALL_DAY) != 0;
1240             values.put(Events.ORIGINAL_ALL_DAY, allDay ? 1 : 0);
1241
1242             uri = cr.insert(Events.CONTENT_URI, values);
1243
1244         } else if (mModification == MODIFY_ALL_FOLLOWING) {
1245             // Modify this instance and all future instances of repeating event
1246             addRecurrenceRule(values);
1247
1248             if (mRrule == null) {
1249                 // We've changed a recurring event to a non-recurring event.
1250                 // If the event we are editing is the first in the series,
1251                 // then delete the whole series.  Otherwise, update the series
1252                 // to end at the new start time.
1253                 if (isFirstEventInSeries()) {
1254                     cr.delete(uri, null, null);
1255                 } else {
1256                     // Update the current repeating event to end at the new
1257                     // start time.
1258                     updatePastEvents(cr, uri);
1259                 }
1260                 uri = cr.insert(Events.CONTENT_URI, values);
1261             } else {
1262                 if (isFirstEventInSeries()) {
1263                     checkTimeDependentFields(values);
1264                     values.remove(Events.DTEND);
1265                     cr.update(uri, values, null, null);
1266                 } else {
1267                     // Update the current repeating event to end at the new
1268                     // start time.
1269                     updatePastEvents(cr, uri);
1270
1271                     // Create a new event with the user-modified fields
1272                     values.remove(Events.DTEND);
1273                     uri = cr.insert(Events.CONTENT_URI, values);
1274                 }
1275             }
1276
1277         } else if (mModification == MODIFY_ALL) {
1278             
1279             // Modify all instances of repeating event
1280             addRecurrenceRule(values);
1281             
1282             if (mRrule == null) {
1283                 // We've changed a recurring event to a non-recurring event.
1284                 // Delete the whole series and replace it with a new
1285                 // non-recurring event.
1286                 cr.delete(uri, null, null);
1287                 uri = cr.insert(Events.CONTENT_URI, values);
1288             } else {
1289                 checkTimeDependentFields(values);
1290                 values.remove(Events.DTEND);
1291                 cr.update(uri, values, null, null);
1292             }
1293         }
1294
1295         if (uri != null) {
1296             long eventId = ContentUris.parseId(uri);
1297             ArrayList<Integer> reminderMinutes = reminderItemsToMinutes(mReminderItems,
1298                     mReminderValues);
1299             saveReminders(cr, eventId, reminderMinutes, mOriginalMinutes);
1300         }
1301         return true;
1302     }
1303
1304     private boolean isFirstEventInSeries() {
1305         int dtStart = mEventCursor.getColumnIndexOrThrow(Events.DTSTART);
1306         long start = mEventCursor.getLong(dtStart);
1307         return start == mStartTime.toMillis(true);
1308     }
1309
1310     private void updatePastEvents(ContentResolver cr, Uri uri) {
1311         long oldStartMillis = mEventCursor.getLong(EVENT_INDEX_DTSTART);
1312         String oldDuration = mEventCursor.getString(EVENT_INDEX_DURATION);
1313         boolean allDay = mEventCursor.getInt(EVENT_INDEX_ALL_DAY) != 0;
1314         String oldRrule = mEventCursor.getString(EVENT_INDEX_RRULE);
1315         mEventRecurrence.parse(oldRrule);
1316
1317         Time untilTime = new Time();
1318         long begin = mInitialValues.getAsLong(EVENT_BEGIN_TIME);
1319         ContentValues oldValues = new ContentValues();
1320
1321         // The "until" time must be in UTC time in order for Google calendar
1322         // to display it properly.  For all-day events, the "until" time string
1323         // must include just the date field, and not the time field.  The
1324         // repeating events repeat up to and including the "until" time.
1325         untilTime.timezone = Time.TIMEZONE_UTC;
1326         
1327         // Subtract one second from the old begin time to get the new
1328         // "until" time.
1329         untilTime.set(begin - 1000);  // subtract one second (1000 millis) 
1330         if (allDay) {
1331             untilTime.hour = 0;
1332             untilTime.minute = 0;
1333             untilTime.second = 0;
1334             untilTime.allDay = true;
1335             untilTime.normalize(false);
1336             
1337             // For all-day events, the duration must be in days, not seconds.
1338             // Otherwise, Google Calendar will (mistakenly) change this event
1339             // into a non-all-day event.
1340             int len = oldDuration.length();
1341             if (oldDuration.charAt(0) == 'P' && oldDuration.charAt(len - 1) == 'S') {
1342                 int seconds = Integer.parseInt(oldDuration.substring(1, len - 1));
1343                 int days = (seconds + DAY_IN_SECONDS - 1) / DAY_IN_SECONDS;
1344                 oldDuration = "P" + days + "D";
1345             }
1346         }
1347         mEventRecurrence.until = untilTime.format2445();
1348
1349         oldValues.put(Events.DTSTART, oldStartMillis);
1350         oldValues.put(Events.DURATION, oldDuration);
1351         oldValues.put(Events.RRULE, mEventRecurrence.toString());
1352         cr.update(uri, oldValues, null, null);
1353     }
1354
1355     private void checkTimeDependentFields(ContentValues values) {
1356         long oldBegin = mInitialValues.getAsLong(EVENT_BEGIN_TIME);
1357         long oldEnd = mInitialValues.getAsLong(EVENT_END_TIME);
1358         boolean oldAllDay = mInitialValues.getAsInteger(Events.ALL_DAY) != 0;
1359         String oldRrule = mInitialValues.getAsString(Events.RRULE);
1360         String oldTimezone = mInitialValues.getAsString(Events.EVENT_TIMEZONE);
1361         
1362         long newBegin = values.getAsLong(Events.DTSTART);
1363         long newEnd = values.getAsLong(Events.DTEND);
1364         boolean newAllDay = values.getAsInteger(Events.ALL_DAY) != 0;
1365         String newRrule = values.getAsString(Events.RRULE);
1366         String newTimezone = values.getAsString(Events.EVENT_TIMEZONE);
1367         
1368         // If none of the time-dependent fields changed, then remove them.
1369         if (oldBegin == newBegin && oldEnd == newEnd && oldAllDay == newAllDay
1370                 && TextUtils.equals(oldRrule, newRrule)
1371                 && TextUtils.equals(oldTimezone, newTimezone)) {
1372             values.remove(Events.DTSTART);
1373             values.remove(Events.DTEND);
1374             values.remove(Events.DURATION);
1375             values.remove(Events.ALL_DAY);
1376             values.remove(Events.RRULE);
1377             values.remove(Events.EVENT_TIMEZONE);
1378             return;
1379         }
1380
1381         if (oldRrule == null || newRrule == null) {
1382             return;
1383         }
1384
1385         // If we are modifying all events then we need to set DTSTART to the
1386         // start time of the first event in the series, not the current
1387         // date and time.  If the start time of the event was changed
1388         // (from, say, 3pm to 4pm), then we want to add the time difference
1389         // to the start time of the first event in the series (the DTSTART
1390         // value).  If we are modifying one instance or all following instances,
1391         // then we leave the DTSTART field alone.
1392         if (mModification == MODIFY_ALL) {
1393             long oldStartMillis = mEventCursor.getLong(EVENT_INDEX_DTSTART);
1394             if (oldBegin != newBegin) {
1395                 // The user changed the start time of this event
1396                 long offset = newBegin - oldBegin;
1397                 oldStartMillis += offset;
1398             }
1399             values.put(Events.DTSTART, oldStartMillis);
1400         }
1401     }
1402     
1403     static ArrayList<Integer> reminderItemsToMinutes(ArrayList<LinearLayout> reminderItems,
1404             ArrayList<Integer> reminderValues) {
1405         int len = reminderItems.size();
1406         ArrayList<Integer> reminderMinutes = new ArrayList<Integer>(len);
1407         for (int index = 0; index < len; index++) {
1408             LinearLayout layout = reminderItems.get(index);
1409             Spinner spinner = (Spinner) layout.findViewById(R.id.reminder_value);
1410             int minutes = reminderValues.get(spinner.getSelectedItemPosition());
1411             reminderMinutes.add(minutes);
1412         }
1413         return reminderMinutes;
1414     }
1415
1416     /**
1417      * Saves the reminders, if they changed.  Returns true if the database
1418      * was updated.
1419      * 
1420      * @param cr the ContentResolver
1421      * @param eventId the id of the event whose reminders are being updated
1422      * @param reminderMinutes the array of reminders set by the user
1423      * @param originalMinutes the original array of reminders
1424      * @return true if the database was updated
1425      */
1426     static boolean saveReminders(ContentResolver cr, long eventId,
1427             ArrayList<Integer> reminderMinutes, ArrayList<Integer> originalMinutes) {
1428         // If the reminders have not changed, then don't update the database
1429         if (reminderMinutes.equals(originalMinutes)) {
1430             return false;
1431         }
1432
1433         // Delete all the existing reminders for this event
1434         String where = Reminders.EVENT_ID + "=?";
1435         String[] args = new String[] { Long.toString(eventId) };
1436         cr.delete(Reminders.CONTENT_URI, where, args);
1437
1438         // Update the "hasAlarm" field for the event
1439         ContentValues values = new ContentValues();
1440         int len = reminderMinutes.size();
1441         values.put(Events.HAS_ALARM, (len > 0) ? 1 : 0);
1442         Uri uri = ContentUris.withAppendedId(Events.CONTENT_URI, eventId);
1443         cr.update(uri, values, null /* where */, null /* selection args */);
1444
1445         // Insert the new reminders, if any
1446         for (int i = 0; i < len; i++) {
1447             int minutes = reminderMinutes.get(i);
1448
1449             values.clear();
1450             values.put(Reminders.MINUTES, minutes);
1451             values.put(Reminders.METHOD, Reminders.METHOD_ALERT);
1452             values.put(Reminders.EVENT_ID, eventId);
1453             cr.insert(Reminders.CONTENT_URI, values);
1454         }
1455         return true;
1456     }
1457
1458     private void addRecurrenceRule(ContentValues values) {
1459         updateRecurrenceRule();
1460
1461         if (mRrule == null) {
1462             return;
1463         }
1464         
1465         values.put(Events.RRULE, mRrule);
1466         long end = mEndTime.toMillis(true /* ignore dst */);
1467         long start = mStartTime.toMillis(true /* ignore dst */);
1468         String duration;
1469
1470         boolean isAllDay = mAllDayCheckBox.isChecked();
1471         if (isAllDay) {
1472             long days = (end - start + DateUtils.DAY_IN_MILLIS - 1) / DateUtils.DAY_IN_MILLIS;
1473             duration = "P" + days + "D";
1474         } else {
1475             long seconds = (end - start) / DateUtils.SECOND_IN_MILLIS;
1476             duration = "P" + seconds + "S";
1477         }
1478         values.put(Events.DURATION, duration);
1479     }
1480
1481     private void updateRecurrenceRule() {
1482         int position = mRepeatsSpinner.getSelectedItemPosition();
1483         int selection = mRecurrenceIndexes.get(position);
1484
1485         if (selection == DOES_NOT_REPEAT) {
1486             mRrule = null;
1487             return;
1488         } else if (selection == REPEATS_CUSTOM) {
1489             // Keep custom recurrence as before.
1490             return;
1491         } else if (selection == REPEATS_DAILY) {
1492             mEventRecurrence.freq = EventRecurrence.DAILY;
1493         } else if (selection == REPEATS_EVERY_WEEKDAY) {
1494             mEventRecurrence.freq = EventRecurrence.WEEKLY;
1495             int dayCount = 5;
1496             int[] byday = new int[dayCount];
1497             int[] bydayNum = new int[dayCount];
1498
1499             byday[0] = EventRecurrence.MO;
1500             byday[1] = EventRecurrence.TU;
1501             byday[2] = EventRecurrence.WE;
1502             byday[3] = EventRecurrence.TH;
1503             byday[4] = EventRecurrence.FR;
1504             for (int day = 0; day < dayCount; day++) {
1505                 bydayNum[day] = 0;
1506             }
1507
1508             mEventRecurrence.byday = byday;
1509             mEventRecurrence.bydayNum = bydayNum;
1510             mEventRecurrence.bydayCount = dayCount;
1511         } else if (selection == REPEATS_WEEKLY_ON_DAY) {
1512             mEventRecurrence.freq = EventRecurrence.WEEKLY;
1513             int[] days = new int[1];
1514             int dayCount = 1;
1515             int[] dayNum = new int[dayCount];
1516
1517             days[0] = EventRecurrence.timeDay2Day(mStartTime.weekDay);
1518             // not sure why this needs to be zero, but set it for now.
1519             dayNum[0] = 0;
1520
1521             mEventRecurrence.byday = days;
1522             mEventRecurrence.bydayNum = dayNum;
1523             mEventRecurrence.bydayCount = dayCount;
1524         } else if (selection == REPEATS_MONTHLY_ON_DAY) {
1525             mEventRecurrence.freq = EventRecurrence.MONTHLY;
1526             mEventRecurrence.bydayCount = 0;
1527             mEventRecurrence.bymonthdayCount = 1;
1528             int[] bymonthday = new int[1];
1529             bymonthday[0] = mStartTime.monthDay;
1530             mEventRecurrence.bymonthday = bymonthday;
1531         } else if (selection == REPEATS_MONTHLY_ON_DAY_COUNT) {
1532             mEventRecurrence.freq = EventRecurrence.MONTHLY;
1533             mEventRecurrence.bydayCount = 1;
1534             mEventRecurrence.bymonthdayCount = 0;
1535
1536             int[] byday = new int[1];
1537             int[] bydayNum = new int[1];
1538             // Compute the week number (for example, the "2nd" Monday)
1539             int dayCount = 1 + ((mStartTime.monthDay - 1) / 7);
1540             if (dayCount == 5) {
1541                 dayCount = -1;
1542             }
1543             bydayNum[0] = dayCount;
1544             byday[0] = EventRecurrence.timeDay2Day(mStartTime.weekDay);
1545             mEventRecurrence.byday = byday;
1546             mEventRecurrence.bydayNum = bydayNum;
1547         } else if (selection == REPEATS_YEARLY) {
1548             mEventRecurrence.freq = EventRecurrence.YEARLY;
1549         }
1550
1551         // Set the week start day.
1552         mEventRecurrence.wkst = EventRecurrence.calendarDay2Day(mFirstDayOfWeek);
1553         mRrule = mEventRecurrence.toString();
1554     }
1555
1556     private ContentValues getContentValuesFromUi() {
1557         String title = mTitleTextView.getText().toString();
1558         boolean isAllDay = mAllDayCheckBox.isChecked();
1559         String location = mLocationTextView.getText().toString();
1560         String description = mDescriptionTextView.getText().toString();
1561
1562         ContentValues values = new ContentValues();
1563
1564         String timezone = null;
1565         long startMillis;
1566         long endMillis;
1567         long calendarId;
1568         if (isAllDay) {
1569             // Reset start and end time, increment the monthDay by 1, and set
1570             // the timezone to UTC, as required for all-day events.
1571             timezone = Time.TIMEZONE_UTC;
1572             mStartTime.hour = 0;
1573             mStartTime.minute = 0;
1574             mStartTime.second = 0;
1575             mStartTime.timezone = timezone;
1576             startMillis = mStartTime.normalize(true);
1577
1578             mEndTime.hour = 0;
1579             mEndTime.minute = 0;
1580             mEndTime.second = 0;
1581             mEndTime.monthDay++;
1582             mEndTime.timezone = timezone;
1583             endMillis = mEndTime.normalize(true);
1584             
1585             if (mEventCursor == null) {
1586                 // This is a new event
1587                 calendarId = mCalendarsSpinner.getSelectedItemId();
1588             } else {
1589                 calendarId = mInitialValues.getAsLong(Events.CALENDAR_ID);
1590             }
1591         } else {
1592             startMillis = mStartTime.toMillis(true);
1593             endMillis = mEndTime.toMillis(true);
1594             if (mEventCursor != null) {
1595                 // This is an existing event
1596                 timezone = mEventCursor.getString(EVENT_INDEX_TIMEZONE);
1597                 
1598                 // The timezone might be null if we are changing an existing
1599                 // all-day event to a non-all-day event.  We need to assign
1600                 // a timezone to the non-all-day event.
1601                 if (TextUtils.isEmpty(timezone)) {
1602                     timezone = TimeZone.getDefault().getID();
1603                 }
1604                 calendarId = mInitialValues.getAsLong(Events.CALENDAR_ID);
1605             } else {
1606                 // This is a new event
1607                 calendarId = mCalendarsSpinner.getSelectedItemId();
1608                 
1609                 // The timezone for a new event is the currently displayed
1610                 // timezone, NOT the timezone of the containing calendar.
1611                 timezone = TimeZone.getDefault().getID();
1612             }
1613         }
1614
1615         values.put(Events.CALENDAR_ID, calendarId);
1616         values.put(Events.EVENT_TIMEZONE, timezone);
1617         values.put(Events.TITLE, title);
1618         values.put(Events.ALL_DAY, isAllDay ? 1 : 0);
1619         values.put(Events.DTSTART, startMillis);
1620         values.put(Events.DTEND, endMillis);
1621         values.put(Events.DESCRIPTION, description);
1622         values.put(Events.EVENT_LOCATION, location);
1623         values.put(Events.TRANSPARENCY, mAvailabilitySpinner.getSelectedItemPosition());
1624
1625         int visibility = mVisibilitySpinner.getSelectedItemPosition();
1626         if (visibility > 0) {
1627             // For now we the array contains the values 0, 2, and 3. We add one to match.
1628             visibility++;
1629         }
1630         values.put(Events.VISIBILITY, visibility);
1631
1632         return values;
1633     }
1634
1635     private boolean isEmpty() {
1636         String title = mTitleTextView.getText().toString();
1637         if (title.length() > 0) {
1638             return false;
1639         }
1640
1641         String location = mLocationTextView.getText().toString();
1642         if (location.length() > 0) {
1643             return false;
1644         }
1645
1646         String description = mDescriptionTextView.getText().toString();
1647         if (description.length() > 0) {
1648             return false;
1649         }
1650
1651         return true;
1652     }
1653
1654     private boolean isCustomRecurrence() {
1655
1656         if (mEventRecurrence.until != null || mEventRecurrence.interval != 0) {
1657             return true;
1658         }
1659
1660         if (mEventRecurrence.freq == 0) {
1661             return false;
1662         }
1663
1664         switch (mEventRecurrence.freq) {
1665         case EventRecurrence.DAILY:
1666             return false;
1667         case EventRecurrence.WEEKLY:
1668             if (mEventRecurrence.repeatsOnEveryWeekDay() && isWeekdayEvent()) {
1669                 return false;
1670             } else if (mEventRecurrence.bydayCount == 1) {
1671                 return false;
1672             }
1673             break;
1674         case EventRecurrence.MONTHLY:
1675             if (mEventRecurrence.repeatsMonthlyOnDayCount()) {
1676                 return false;
1677             } else if (mEventRecurrence.bydayCount == 0 && mEventRecurrence.bymonthdayCount == 1) {
1678                 return false;
1679             }
1680             break;
1681         case EventRecurrence.YEARLY:
1682             return false;
1683         }
1684
1685         return true;
1686     }
1687
1688     private boolean isWeekdayEvent() {
1689         if (mStartTime.weekDay != Time.SUNDAY && mStartTime.weekDay != Time.SATURDAY) {
1690             return true;
1691         }
1692         return false;
1693     }
1694 }