Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 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 | |
Erik | fbce65e | 2010-08-16 12:43:13 -0700 | [diff] [blame] | 17 | package com.android.calendar.event; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 18 | |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 19 | import android.app.Activity; |
| 20 | import android.app.AlertDialog; |
| 21 | import android.app.Fragment; |
James Kung | 95e9538 | 2013-03-20 12:14:33 -0700 | [diff] [blame] | 22 | import android.app.FragmentManager; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 23 | import android.content.AsyncQueryHandler; |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 24 | import android.content.ContentProviderOperation; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 25 | import android.content.ContentResolver; |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 26 | import android.content.ContentUris; |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 27 | import android.content.ContentValues; |
Daisuke Miyakawa | 5c0dec1 | 2010-09-22 17:21:42 -0700 | [diff] [blame] | 28 | import android.content.Context; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 29 | import android.content.DialogInterface; |
Michael Chan | d17d348 | 2011-08-18 16:11:51 -0700 | [diff] [blame] | 30 | import android.content.DialogInterface.OnCancelListener; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 31 | import android.content.DialogInterface.OnClickListener; |
Michael Chan | c250e2e | 2011-05-23 12:52:50 -0700 | [diff] [blame] | 32 | import android.content.Intent; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 33 | import android.database.Cursor; |
| 34 | import android.database.MatrixCursor; |
| 35 | import android.net.Uri; |
| 36 | import android.os.Bundle; |
RoboErik | a7c0390 | 2011-06-14 11:06:44 -0700 | [diff] [blame] | 37 | import android.provider.CalendarContract.Attendees; |
| 38 | import android.provider.CalendarContract.Calendars; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 39 | import android.provider.CalendarContract.Colors; |
RoboErik | a7c0390 | 2011-06-14 11:06:44 -0700 | [diff] [blame] | 40 | import android.provider.CalendarContract.Events; |
| 41 | import android.provider.CalendarContract.Reminders; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 42 | import android.text.TextUtils; |
RoboErik | c8e0f21 | 2011-10-13 17:57:39 -0700 | [diff] [blame] | 43 | import android.text.format.Time; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 44 | import android.util.Log; |
| 45 | import android.view.LayoutInflater; |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 46 | import android.view.Menu; |
| 47 | import android.view.MenuInflater; |
| 48 | import android.view.MenuItem; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 49 | import android.view.View; |
| 50 | import android.view.ViewGroup; |
Daisuke Miyakawa | 5c0dec1 | 2010-09-22 17:21:42 -0700 | [diff] [blame] | 51 | import android.view.inputmethod.InputMethodManager; |
Andy Huang | 135b2d4 | 2011-09-01 20:38:43 -0700 | [diff] [blame] | 52 | import android.widget.LinearLayout; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 53 | import android.widget.Toast; |
| 54 | |
Michael Chan | c250e2e | 2011-05-23 12:52:50 -0700 | [diff] [blame] | 55 | import com.android.calendar.AsyncQueryService; |
| 56 | import com.android.calendar.CalendarController; |
| 57 | import com.android.calendar.CalendarController.EventHandler; |
| 58 | import com.android.calendar.CalendarController.EventInfo; |
| 59 | import com.android.calendar.CalendarController.EventType; |
| 60 | import com.android.calendar.CalendarEventModel; |
| 61 | import com.android.calendar.CalendarEventModel.Attendee; |
| 62 | import com.android.calendar.CalendarEventModel.ReminderEntry; |
| 63 | import com.android.calendar.DeleteEventHelper; |
| 64 | import com.android.calendar.R; |
| 65 | import com.android.calendar.Utils; |
James Kung | a8b8c0d | 2013-02-13 17:28:16 -0800 | [diff] [blame] | 66 | import com.android.colorpicker.ColorPickerSwatch.OnColorSelectedListener; |
| 67 | import com.android.colorpicker.HsvColorComparator; |
Michael Chan | c250e2e | 2011-05-23 12:52:50 -0700 | [diff] [blame] | 68 | |
Erik | c130d9d | 2010-12-06 15:55:23 -0800 | [diff] [blame] | 69 | import java.io.Serializable; |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 70 | import java.util.ArrayList; |
Andy McFadden | 9645d9c | 2011-05-16 15:28:15 -0700 | [diff] [blame] | 71 | import java.util.Collections; |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 72 | |
James Kung | b8904fb | 2013-02-14 14:37:42 -0800 | [diff] [blame] | 73 | public class EditEventFragment extends Fragment implements EventHandler, OnColorSelectedListener { |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 74 | private static final String TAG = "EditEventActivity"; |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 75 | private static final String COLOR_PICKER_DIALOG_TAG = "ColorPickerDialog"; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 76 | |
James Kung | b8904fb | 2013-02-14 14:37:42 -0800 | [diff] [blame] | 77 | private static final int REQUEST_CODE_COLOR_PICKER = 0; |
| 78 | |
Erik | 59ead67 | 2010-11-29 15:47:08 -0800 | [diff] [blame] | 79 | private static final String BUNDLE_KEY_MODEL = "key_model"; |
| 80 | private static final String BUNDLE_KEY_EDIT_STATE = "key_edit_state"; |
Erik | c130d9d | 2010-12-06 15:55:23 -0800 | [diff] [blame] | 81 | private static final String BUNDLE_KEY_EVENT = "key_event"; |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 82 | private static final String BUNDLE_KEY_READ_ONLY = "key_read_only"; |
Mindy Pereira | 2d63dff | 2011-10-04 12:51:12 -0700 | [diff] [blame] | 83 | private static final String BUNDLE_KEY_EDIT_ON_LAUNCH = "key_edit_on_launch"; |
Erik | 59ead67 | 2010-11-29 15:47:08 -0800 | [diff] [blame] | 84 | |
James Kung | 56f42bf | 2013-03-29 14:59:29 -0700 | [diff] [blame] | 85 | private static final String BUNDLE_KEY_DATE_BUTTON_CLICKED = "date_button_clicked"; |
| 86 | |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 87 | private static final boolean DEBUG = false; |
| 88 | |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 89 | private static final int TOKEN_EVENT = 1; |
| 90 | private static final int TOKEN_ATTENDEES = 1 << 1; |
| 91 | private static final int TOKEN_REMINDERS = 1 << 2; |
| 92 | private static final int TOKEN_CALENDARS = 1 << 3; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 93 | private static final int TOKEN_COLORS = 1 << 4; |
| 94 | |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 95 | private static final int TOKEN_ALL = TOKEN_EVENT | TOKEN_ATTENDEES | TOKEN_REMINDERS |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 96 | | TOKEN_CALENDARS | TOKEN_COLORS; |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 97 | private static final int TOKEN_UNITIALIZED = 1 << 31; |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 98 | |
| 99 | /** |
| 100 | * A bitfield of TOKEN_* to keep track which query hasn't been completed |
| 101 | * yet. Once all queries have returned, the model can be applied to the |
| 102 | * view. |
| 103 | */ |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 104 | private int mOutstandingQueries = TOKEN_UNITIALIZED; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 105 | |
| 106 | EditEventHelper mHelper; |
| 107 | CalendarEventModel mModel; |
| 108 | CalendarEventModel mOriginalModel; |
Erik | 59ead67 | 2010-11-29 15:47:08 -0800 | [diff] [blame] | 109 | CalendarEventModel mRestoreModel; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 110 | EditEventView mView; |
| 111 | QueryHandler mHandler; |
| 112 | |
| 113 | private AlertDialog mModifyDialog; |
| 114 | int mModification = Utils.MODIFY_UNINITIALIZED; |
| 115 | |
Isaac Katzenelson | 6bcafcf | 2012-05-02 18:25:36 -0700 | [diff] [blame] | 116 | private final EventInfo mEvent; |
Erik | c130d9d | 2010-12-06 15:55:23 -0800 | [diff] [blame] | 117 | private EventBundle mEventBundle; |
James Kung | 1d1b1e4 | 2013-03-06 19:49:23 -0800 | [diff] [blame] | 118 | private ArrayList<ReminderEntry> mReminders; |
| 119 | private int mEventColor; |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 120 | private boolean mEventColorInitialized = false; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 121 | private Uri mUri; |
| 122 | private long mBegin; |
| 123 | private long mEnd; |
James Kung | 09fbd8e | 2012-11-12 11:19:46 -0800 | [diff] [blame] | 124 | private long mCalendarId = -1; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 125 | |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 126 | private EventColorPickerDialog mColorPickerDialog; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 127 | |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 128 | private Activity mContext; |
Isaac Katzenelson | 6bcafcf | 2012-05-02 18:25:36 -0700 | [diff] [blame] | 129 | private final Done mOnDone = new Done(); |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 130 | |
| 131 | private boolean mSaveOnDetach = true; |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 132 | private boolean mIsReadOnly = false; |
| 133 | public boolean mShowModifyDialogOnLaunch = false; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 134 | |
Sam Blitzstein | 7674b69 | 2013-01-29 11:45:20 -0800 | [diff] [blame] | 135 | private boolean mTimeSelectedWasStartTime; |
James Kung | 56f42bf | 2013-03-29 14:59:29 -0700 | [diff] [blame] | 136 | private boolean mDateSelectedWasStartDate; |
Sam Blitzstein | 7674b69 | 2013-01-29 11:45:20 -0800 | [diff] [blame] | 137 | |
Daisuke Miyakawa | 5c0dec1 | 2010-09-22 17:21:42 -0700 | [diff] [blame] | 138 | private InputMethodManager mInputMethodManager; |
| 139 | |
Isaac Katzenelson | 6bcafcf | 2012-05-02 18:25:36 -0700 | [diff] [blame] | 140 | private final Intent mIntent; |
Michael Chan | c250e2e | 2011-05-23 12:52:50 -0700 | [diff] [blame] | 141 | |
Andy Huang | 135b2d4 | 2011-09-01 20:38:43 -0700 | [diff] [blame] | 142 | private boolean mUseCustomActionBar; |
| 143 | |
Isaac Katzenelson | 6bcafcf | 2012-05-02 18:25:36 -0700 | [diff] [blame] | 144 | private final View.OnClickListener mActionBarListener = new View.OnClickListener() { |
Andy Huang | 135b2d4 | 2011-09-01 20:38:43 -0700 | [diff] [blame] | 145 | @Override |
| 146 | public void onClick(View v) { |
| 147 | onActionBarItemSelected(v.getId()); |
| 148 | } |
| 149 | }; |
| 150 | |
Erik | 364309f | 2010-12-23 14:26:26 -0800 | [diff] [blame] | 151 | // TODO turn this into a helper function in EditEventHelper for building the |
| 152 | // model |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 153 | private class QueryHandler extends AsyncQueryHandler { |
| 154 | public QueryHandler(ContentResolver cr) { |
| 155 | super(cr); |
| 156 | } |
| 157 | |
| 158 | @Override |
| 159 | protected void onQueryComplete(int token, Object cookie, Cursor cursor) { |
| 160 | // If the query didn't return a cursor for some reason return |
| 161 | if (cursor == null) { |
| 162 | return; |
| 163 | } |
| 164 | |
| 165 | // If the Activity is finishing, then close the cursor. |
| 166 | // Otherwise, use the new cursor in the adapter. |
Michael Chan | 6a7878f | 2010-08-17 16:46:07 -0700 | [diff] [blame] | 167 | final Activity activity = EditEventFragment.this.getActivity(); |
| 168 | if (activity == null || activity.isFinishing()) { |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 169 | cursor.close(); |
| 170 | return; |
| 171 | } |
| 172 | long eventId; |
| 173 | switch (token) { |
| 174 | case TOKEN_EVENT: |
| 175 | if (cursor.getCount() == 0) { |
| 176 | // The cursor is empty. This can happen if the event |
| 177 | // was deleted. |
| 178 | cursor.close(); |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 179 | mOnDone.setDoneCode(Utils.DONE_EXIT); |
RoboErik | 16bfd17 | 2011-08-01 17:30:14 -0700 | [diff] [blame] | 180 | mSaveOnDetach = false; |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 181 | mOnDone.run(); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 182 | return; |
| 183 | } |
| 184 | mOriginalModel = new CalendarEventModel(); |
| 185 | EditEventHelper.setModelFromCursor(mOriginalModel, cursor); |
| 186 | EditEventHelper.setModelFromCursor(mModel, cursor); |
| 187 | cursor.close(); |
| 188 | |
Erik | 59ead67 | 2010-11-29 15:47:08 -0800 | [diff] [blame] | 189 | mOriginalModel.mUri = mUri.toString(); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 190 | |
Erik | 59ead67 | 2010-11-29 15:47:08 -0800 | [diff] [blame] | 191 | mModel.mUri = mUri.toString(); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 192 | mModel.mOriginalStart = mBegin; |
| 193 | mModel.mOriginalEnd = mEnd; |
| 194 | mModel.mIsFirstEventInSeries = mBegin == mOriginalModel.mStart; |
| 195 | mModel.mStart = mBegin; |
| 196 | mModel.mEnd = mEnd; |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 197 | if (mEventColorInitialized) { |
| 198 | mModel.setEventColor(mEventColor); |
James Kung | 1d1b1e4 | 2013-03-06 19:49:23 -0800 | [diff] [blame] | 199 | } |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 200 | eventId = mModel.mId; |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 201 | |
| 202 | // TOKEN_ATTENDEES |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 203 | if (mModel.mHasAttendeeData && eventId != -1) { |
| 204 | Uri attUri = Attendees.CONTENT_URI; |
| 205 | String[] whereArgs = { |
| 206 | Long.toString(eventId) |
| 207 | }; |
| 208 | mHandler.startQuery(TOKEN_ATTENDEES, null, attUri, |
| 209 | EditEventHelper.ATTENDEES_PROJECTION, |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 210 | EditEventHelper.ATTENDEES_WHERE /* selection */, |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 211 | whereArgs /* selection args */, null /* sort order */); |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 212 | } else { |
| 213 | setModelIfDone(TOKEN_ATTENDEES); |
| 214 | } |
| 215 | |
| 216 | // TOKEN_REMINDERS |
James Kung | 1d1b1e4 | 2013-03-06 19:49:23 -0800 | [diff] [blame] | 217 | if (mModel.mHasAlarm && mReminders == null) { |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 218 | Uri rUri = Reminders.CONTENT_URI; |
| 219 | String[] remArgs = { |
Andy McFadden | 9645d9c | 2011-05-16 15:28:15 -0700 | [diff] [blame] | 220 | Long.toString(eventId) |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 221 | }; |
Andy McFadden | 9645d9c | 2011-05-16 15:28:15 -0700 | [diff] [blame] | 222 | mHandler.startQuery(TOKEN_REMINDERS, null, rUri, |
| 223 | EditEventHelper.REMINDERS_PROJECTION, |
| 224 | EditEventHelper.REMINDERS_WHERE /* selection */, |
| 225 | remArgs /* selection args */, null /* sort order */); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 226 | } else { |
Sam Blitzstein | 523cc48 | 2013-04-02 16:13:25 -0700 | [diff] [blame] | 227 | if (mReminders == null) { |
| 228 | // mReminders should not be null. |
| 229 | mReminders = new ArrayList<ReminderEntry>(); |
| 230 | } else { |
| 231 | Collections.sort(mReminders); |
| 232 | } |
James Kung | 1d1b1e4 | 2013-03-06 19:49:23 -0800 | [diff] [blame] | 233 | mOriginalModel.mReminders = mReminders; |
| 234 | mModel.mReminders = |
| 235 | (ArrayList<ReminderEntry>) mReminders.clone(); |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 236 | setModelIfDone(TOKEN_REMINDERS); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 237 | } |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 238 | |
| 239 | // TOKEN_CALENDARS |
| 240 | String[] selArgs = { |
| 241 | Long.toString(mModel.mCalendarId) |
| 242 | }; |
| 243 | mHandler.startQuery(TOKEN_CALENDARS, null, Calendars.CONTENT_URI, |
| 244 | EditEventHelper.CALENDARS_PROJECTION, EditEventHelper.CALENDARS_WHERE, |
| 245 | selArgs /* selection args */, null /* sort order */); |
| 246 | |
| 247 | setModelIfDone(TOKEN_EVENT); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 248 | break; |
| 249 | case TOKEN_ATTENDEES: |
| 250 | try { |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 251 | while (cursor.moveToNext()) { |
| 252 | String name = cursor.getString(EditEventHelper.ATTENDEES_INDEX_NAME); |
| 253 | String email = cursor.getString(EditEventHelper.ATTENDEES_INDEX_EMAIL); |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 254 | int status = cursor.getInt(EditEventHelper.ATTENDEES_INDEX_STATUS); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 255 | int relationship = cursor |
| 256 | .getInt(EditEventHelper.ATTENDEES_INDEX_RELATIONSHIP); |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 257 | if (relationship == Attendees.RELATIONSHIP_ORGANIZER) { |
| 258 | if (email != null) { |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 259 | mModel.mOrganizer = email; |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 260 | mModel.mIsOrganizer = mModel.mOwnerAccount |
| 261 | .equalsIgnoreCase(email); |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 262 | mOriginalModel.mOrganizer = email; |
| 263 | mOriginalModel.mIsOrganizer = mOriginalModel.mOwnerAccount |
| 264 | .equalsIgnoreCase(email); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 265 | } |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 266 | |
| 267 | if (TextUtils.isEmpty(name)) { |
| 268 | mModel.mOrganizerDisplayName = mModel.mOrganizer; |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 269 | mOriginalModel.mOrganizerDisplayName = |
| 270 | mOriginalModel.mOrganizer; |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 271 | } else { |
| 272 | mModel.mOrganizerDisplayName = name; |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 273 | mOriginalModel.mOrganizerDisplayName = name; |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 274 | } |
| 275 | } |
| 276 | |
| 277 | if (email != null) { |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 278 | if (mModel.mOwnerAccount != null && |
| 279 | mModel.mOwnerAccount.equalsIgnoreCase(email)) { |
| 280 | int attendeeId = |
| 281 | cursor.getInt(EditEventHelper.ATTENDEES_INDEX_ID); |
| 282 | mModel.mOwnerAttendeeId = attendeeId; |
| 283 | mModel.mSelfAttendeeStatus = status; |
| 284 | mOriginalModel.mOwnerAttendeeId = attendeeId; |
| 285 | mOriginalModel.mSelfAttendeeStatus = status; |
| 286 | continue; |
| 287 | } |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 288 | } |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 289 | Attendee attendee = new Attendee(name, email); |
| 290 | attendee.mStatus = status; |
| 291 | mModel.addAttendee(attendee); |
| 292 | mOriginalModel.addAttendee(attendee); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 293 | } |
| 294 | } finally { |
| 295 | cursor.close(); |
| 296 | } |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 297 | |
| 298 | setModelIfDone(TOKEN_ATTENDEES); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 299 | break; |
| 300 | case TOKEN_REMINDERS: |
| 301 | try { |
Erik | d290a01 | 2010-08-03 15:52:57 -0700 | [diff] [blame] | 302 | // Add all reminders to the models |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 303 | while (cursor.moveToNext()) { |
| 304 | int minutes = cursor.getInt(EditEventHelper.REMINDERS_INDEX_MINUTES); |
Andy McFadden | fea9af5 | 2011-05-13 15:40:10 -0700 | [diff] [blame] | 305 | int method = cursor.getInt(EditEventHelper.REMINDERS_INDEX_METHOD); |
| 306 | ReminderEntry re = ReminderEntry.valueOf(minutes, method); |
| 307 | mModel.mReminders.add(re); |
| 308 | mOriginalModel.mReminders.add(re); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 309 | } |
Andy McFadden | 9645d9c | 2011-05-16 15:28:15 -0700 | [diff] [blame] | 310 | |
| 311 | // Sort appropriately for display |
| 312 | Collections.sort(mModel.mReminders); |
| 313 | Collections.sort(mOriginalModel.mReminders); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 314 | } finally { |
| 315 | cursor.close(); |
| 316 | } |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 317 | |
| 318 | setModelIfDone(TOKEN_REMINDERS); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 319 | break; |
| 320 | case TOKEN_CALENDARS: |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 321 | try { |
James Kung | 09fbd8e | 2012-11-12 11:19:46 -0800 | [diff] [blame] | 322 | if (mModel.mId == -1) { |
| 323 | // Populate Calendar spinner only if no event id is set. |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 324 | MatrixCursor matrixCursor = Utils.matrixCursorFromCursor(cursor); |
| 325 | if (DEBUG) { |
| 326 | Log.d(TAG, "onQueryComplete: setting cursor with " |
| 327 | + matrixCursor.getCount() + " calendars"); |
| 328 | } |
James Kung | 09fbd8e | 2012-11-12 11:19:46 -0800 | [diff] [blame] | 329 | mView.setCalendarsCursor(matrixCursor, isAdded() && isResumed(), |
| 330 | mCalendarId); |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 331 | } else { |
| 332 | // Populate model for an existing event |
| 333 | EditEventHelper.setModelFromCalendarCursor(mModel, cursor); |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 334 | EditEventHelper.setModelFromCalendarCursor(mOriginalModel, cursor); |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 335 | } |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 336 | startQuery(TOKEN_COLORS, null, Colors.CONTENT_URI, |
| 337 | EditEventHelper.COLORS_PROJECTION, |
| 338 | Colors.COLOR_TYPE + "=" + Colors.TYPE_EVENT, null, null); |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 339 | } finally { |
| 340 | cursor.close(); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 341 | } |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 342 | setModelIfDone(TOKEN_CALENDARS); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 343 | break; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 344 | case TOKEN_COLORS: |
| 345 | if (cursor.moveToFirst()) { |
| 346 | EventColorCache cache = new EventColorCache(); |
| 347 | do |
| 348 | { |
| 349 | int colorKey = cursor.getInt(EditEventHelper.COLORS_INDEX_COLOR_KEY); |
| 350 | int rawColor = cursor.getInt(EditEventHelper.COLORS_INDEX_COLOR); |
| 351 | int displayColor = Utils.getDisplayColorFromColor(rawColor); |
| 352 | String accountName = cursor |
| 353 | .getString(EditEventHelper.COLORS_INDEX_ACCOUNT_NAME); |
| 354 | String accountType = cursor |
| 355 | .getString(EditEventHelper.COLORS_INDEX_ACCOUNT_TYPE); |
| 356 | cache.insertColor(accountName, accountType, |
| 357 | displayColor, colorKey); |
| 358 | } while (cursor.moveToNext()); |
James Kung | e134cd5 | 2013-02-13 11:33:49 -0800 | [diff] [blame] | 359 | cache.sortPalettes(new HsvColorComparator()); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 360 | |
| 361 | mModel.mEventColorCache = cache; |
| 362 | mView.mColorPickerNewEvent.setOnClickListener(mOnColorPickerClicked); |
| 363 | mView.mColorPickerExistingEvent.setOnClickListener(mOnColorPickerClicked); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 364 | } |
| 365 | if (cursor != null) { |
| 366 | cursor.close(); |
| 367 | } |
James Kung | b8904fb | 2013-02-14 14:37:42 -0800 | [diff] [blame] | 368 | mView.setColorPickerButtonStates(mModel.getCalendarEventColors()); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 369 | setModelIfDone(TOKEN_COLORS); |
| 370 | break; |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 371 | default: |
| 372 | cursor.close(); |
| 373 | break; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 374 | } |
| 375 | } |
| 376 | } |
| 377 | |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 378 | private View.OnClickListener mOnColorPickerClicked = new View.OnClickListener() { |
| 379 | |
| 380 | @Override |
| 381 | public void onClick(View v) { |
| 382 | int[] colors = mModel.getCalendarEventColors(); |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 383 | if (mColorPickerDialog == null) { |
| 384 | mColorPickerDialog = EventColorPickerDialog.newInstance(colors, |
| 385 | mModel.getEventColor(), mModel.getCalendarColor(), mView.mIsMultipane); |
| 386 | mColorPickerDialog.setOnColorSelectedListener(EditEventFragment.this); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 387 | } else { |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 388 | mColorPickerDialog.setCalendarColor(mModel.getCalendarColor()); |
| 389 | mColorPickerDialog.setColors(colors, mModel.getEventColor()); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 390 | } |
James Kung | 95e9538 | 2013-03-20 12:14:33 -0700 | [diff] [blame] | 391 | final FragmentManager fragmentManager = getFragmentManager(); |
| 392 | fragmentManager.executePendingTransactions(); |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 393 | if (!mColorPickerDialog.isAdded()) { |
| 394 | mColorPickerDialog.show(fragmentManager, COLOR_PICKER_DIALOG_TAG); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 395 | } |
| 396 | } |
| 397 | }; |
| 398 | |
Daisuke Miyakawa | bdcb9fc | 2010-10-18 13:10:56 -0700 | [diff] [blame] | 399 | private void setModelIfDone(int queryType) { |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 400 | synchronized (this) { |
| 401 | mOutstandingQueries &= ~queryType; |
| 402 | if (mOutstandingQueries == 0) { |
Erik | 59ead67 | 2010-11-29 15:47:08 -0800 | [diff] [blame] | 403 | if (mRestoreModel != null) { |
| 404 | mModel = mRestoreModel; |
| 405 | } |
Erik | 1bd9453 | 2010-12-08 15:01:26 -0800 | [diff] [blame] | 406 | if (mShowModifyDialogOnLaunch && mModification == Utils.MODIFY_UNINITIALIZED) { |
| 407 | if (!TextUtils.isEmpty(mModel.mRrule)) { |
| 408 | displayEditWhichDialog(); |
| 409 | } else { |
| 410 | mModification = Utils.MODIFY_ALL; |
| 411 | } |
| 412 | |
| 413 | } |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 414 | mView.setModel(mModel); |
Erik | 3400a2b | 2010-12-06 17:48:44 -0800 | [diff] [blame] | 415 | mView.setModification(mModification); |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 416 | } |
| 417 | } |
| 418 | } |
| 419 | |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 420 | public EditEventFragment() { |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 421 | this(null, null, false, -1, false, null); |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 422 | } |
| 423 | |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 424 | public EditEventFragment(EventInfo event, ArrayList<ReminderEntry> reminders, |
| 425 | boolean eventColorInitialized, int eventColor, boolean readOnly, Intent intent) { |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 426 | mEvent = event; |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 427 | mIsReadOnly = readOnly; |
Michael Chan | c250e2e | 2011-05-23 12:52:50 -0700 | [diff] [blame] | 428 | mIntent = intent; |
James Kung | 1d1b1e4 | 2013-03-06 19:49:23 -0800 | [diff] [blame] | 429 | |
| 430 | mReminders = reminders; |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 431 | mEventColorInitialized = eventColorInitialized; |
| 432 | if (eventColorInitialized) { |
| 433 | mEventColor = eventColor; |
| 434 | } |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 435 | setHasOptionsMenu(true); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 436 | } |
| 437 | |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 438 | @Override |
| 439 | public void onActivityCreated(Bundle savedInstanceState) { |
| 440 | super.onActivityCreated(savedInstanceState); |
| 441 | mColorPickerDialog = (EventColorPickerDialog) getActivity().getFragmentManager() |
| 442 | .findFragmentByTag(COLOR_PICKER_DIALOG_TAG); |
| 443 | if (mColorPickerDialog != null) { |
| 444 | mColorPickerDialog.setOnColorSelectedListener(this); |
| 445 | } |
| 446 | } |
| 447 | |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 448 | private void startQuery() { |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 449 | mUri = null; |
| 450 | mBegin = -1; |
| 451 | mEnd = -1; |
| 452 | if (mEvent != null) { |
| 453 | if (mEvent.id != -1) { |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 454 | mModel.mId = mEvent.id; |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 455 | mUri = ContentUris.withAppendedId(Events.CONTENT_URI, mEvent.id); |
Michael Chan | edecd9a | 2011-08-24 23:58:48 -0700 | [diff] [blame] | 456 | } else { |
| 457 | // New event. All day? |
| 458 | mModel.mAllDay = mEvent.extraLong == CalendarController.EXTRA_CREATE_ALL_DAY; |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 459 | } |
| 460 | if (mEvent.startTime != null) { |
| 461 | mBegin = mEvent.startTime.toMillis(true); |
| 462 | } |
| 463 | if (mEvent.endTime != null) { |
| 464 | mEnd = mEvent.endTime.toMillis(true); |
| 465 | } |
James Kung | 09fbd8e | 2012-11-12 11:19:46 -0800 | [diff] [blame] | 466 | if (mEvent.calendarId != -1) { |
| 467 | mCalendarId = mEvent.calendarId; |
| 468 | } |
Erik | c130d9d | 2010-12-06 15:55:23 -0800 | [diff] [blame] | 469 | } else if (mEventBundle != null) { |
Erik | 3400a2b | 2010-12-06 17:48:44 -0800 | [diff] [blame] | 470 | if (mEventBundle.id != -1) { |
| 471 | mModel.mId = mEventBundle.id; |
| 472 | mUri = ContentUris.withAppendedId(Events.CONTENT_URI, mEventBundle.id); |
| 473 | } |
Erik | c130d9d | 2010-12-06 15:55:23 -0800 | [diff] [blame] | 474 | mBegin = mEventBundle.start; |
| 475 | mEnd = mEventBundle.end; |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 476 | } |
Mason Tang | e700c16 | 2010-07-09 14:06:20 -0700 | [diff] [blame] | 477 | |
James Kung | 1d1b1e4 | 2013-03-06 19:49:23 -0800 | [diff] [blame] | 478 | if (mReminders != null) { |
| 479 | mModel.mReminders = mReminders; |
| 480 | } |
| 481 | |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 482 | if (mEventColorInitialized) { |
| 483 | mModel.setEventColor(mEventColor); |
James Kung | 1d1b1e4 | 2013-03-06 19:49:23 -0800 | [diff] [blame] | 484 | } |
| 485 | |
Mason Tang | e700c16 | 2010-07-09 14:06:20 -0700 | [diff] [blame] | 486 | if (mBegin <= 0) { |
| 487 | // use a default value instead |
| 488 | mBegin = mHelper.constructDefaultStartTime(System.currentTimeMillis()); |
| 489 | } |
Mason Tang | e700c16 | 2010-07-09 14:06:20 -0700 | [diff] [blame] | 490 | if (mEnd < mBegin) { |
| 491 | // use a default value instead |
| 492 | mEnd = mHelper.constructDefaultEndTime(mBegin); |
| 493 | } |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 494 | |
| 495 | // Kick off the query for the event |
| 496 | boolean newEvent = mUri == null; |
| 497 | if (!newEvent) { |
RoboErik | ef2add9 | 2011-06-09 14:49:53 -0700 | [diff] [blame] | 498 | mModel.mCalendarAccessLevel = Calendars.CAL_ACCESS_NONE; |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 499 | mOutstandingQueries = TOKEN_ALL; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 500 | if (DEBUG) { |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 501 | Log.d(TAG, "startQuery: uri for event is " + mUri.toString()); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 502 | } |
| 503 | mHandler.startQuery(TOKEN_EVENT, null, mUri, EditEventHelper.EVENT_PROJECTION, |
| 504 | null /* selection */, null /* selection args */, null /* sort order */); |
| 505 | } else { |
James Kung | 236429f | 2013-04-22 12:43:09 -0700 | [diff] [blame] | 506 | mOutstandingQueries = TOKEN_CALENDARS | TOKEN_COLORS; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 507 | if (DEBUG) { |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 508 | Log.d(TAG, "startQuery: Editing a new event."); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 509 | } |
Michael Chan | f9fa0ab | 2012-12-14 00:41:18 -0800 | [diff] [blame] | 510 | mModel.mOriginalStart = mBegin; |
| 511 | mModel.mOriginalEnd = mEnd; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 512 | mModel.mStart = mBegin; |
| 513 | mModel.mEnd = mEnd; |
James Kung | 09fbd8e | 2012-11-12 11:19:46 -0800 | [diff] [blame] | 514 | mModel.mCalendarId = mCalendarId; |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 515 | mModel.mSelfAttendeeStatus = Attendees.ATTENDEE_STATUS_ACCEPTED; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 516 | |
| 517 | // Start a query in the background to read the list of calendars |
| 518 | mHandler.startQuery(TOKEN_CALENDARS, null, Calendars.CONTENT_URI, |
| 519 | EditEventHelper.CALENDARS_PROJECTION, |
| 520 | EditEventHelper.CALENDARS_WHERE_WRITEABLE_VISIBLE, null /* selection args */, |
| 521 | null /* sort order */); |
Erik | c07a57f | 2010-12-01 10:45:48 -0800 | [diff] [blame] | 522 | |
| 523 | mModification = Utils.MODIFY_ALL; |
Erik | c07a57f | 2010-12-01 10:45:48 -0800 | [diff] [blame] | 524 | mView.setModification(mModification); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 525 | } |
| 526 | } |
| 527 | |
| 528 | @Override |
| 529 | public void onAttach(Activity activity) { |
| 530 | super.onAttach(activity); |
| 531 | mContext = activity; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 532 | |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 533 | mHelper = new EditEventHelper(activity, null); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 534 | mHandler = new QueryHandler(activity.getContentResolver()); |
Michael Chan | c250e2e | 2011-05-23 12:52:50 -0700 | [diff] [blame] | 535 | mModel = new CalendarEventModel(activity, mIntent); |
Daisuke Miyakawa | 5c0dec1 | 2010-09-22 17:21:42 -0700 | [diff] [blame] | 536 | mInputMethodManager = (InputMethodManager) |
| 537 | activity.getSystemService(Context.INPUT_METHOD_SERVICE); |
Andy Huang | 135b2d4 | 2011-09-01 20:38:43 -0700 | [diff] [blame] | 538 | |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 539 | mUseCustomActionBar = !Utils.getConfigBool(mContext, R.bool.multiple_pane_config); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 540 | } |
| 541 | |
| 542 | @Override |
| 543 | public View onCreateView(LayoutInflater inflater, ViewGroup container, |
| 544 | Bundle savedInstanceState) { |
| 545 | // mContext.requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS); |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 546 | View view; |
| 547 | if (mIsReadOnly) { |
| 548 | view = inflater.inflate(R.layout.edit_event_single_column, null); |
| 549 | } else { |
| 550 | view = inflater.inflate(R.layout.edit_event, null); |
| 551 | } |
James Kung | 56f42bf | 2013-03-29 14:59:29 -0700 | [diff] [blame] | 552 | mView = new EditEventView(mContext, view, mOnDone, mTimeSelectedWasStartTime, |
| 553 | mDateSelectedWasStartDate); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 554 | startQuery(); |
Andy Huang | 135b2d4 | 2011-09-01 20:38:43 -0700 | [diff] [blame] | 555 | |
| 556 | if (mUseCustomActionBar) { |
| 557 | View actionBarButtons = inflater.inflate(R.layout.edit_event_custom_actionbar, |
| 558 | new LinearLayout(mContext), false); |
| 559 | View cancelActionView = actionBarButtons.findViewById(R.id.action_cancel); |
| 560 | cancelActionView.setOnClickListener(mActionBarListener); |
| 561 | View doneActionView = actionBarButtons.findViewById(R.id.action_done); |
| 562 | doneActionView.setOnClickListener(mActionBarListener); |
| 563 | |
| 564 | mContext.getActionBar().setCustomView(actionBarButtons); |
| 565 | } |
| 566 | |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 567 | return view; |
| 568 | } |
| 569 | |
| 570 | @Override |
Andy Huang | 135b2d4 | 2011-09-01 20:38:43 -0700 | [diff] [blame] | 571 | public void onDestroyView() { |
| 572 | super.onDestroyView(); |
| 573 | |
| 574 | if (mUseCustomActionBar) { |
| 575 | mContext.getActionBar().setCustomView(null); |
| 576 | } |
| 577 | } |
| 578 | |
| 579 | @Override |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 580 | public void onCreate(Bundle savedInstanceState) { |
| 581 | super.onCreate(savedInstanceState); |
Erik | 59ead67 | 2010-11-29 15:47:08 -0800 | [diff] [blame] | 582 | if (savedInstanceState != null) { |
| 583 | if (savedInstanceState.containsKey(BUNDLE_KEY_MODEL)) { |
| 584 | mRestoreModel = (CalendarEventModel) savedInstanceState.getSerializable( |
| 585 | BUNDLE_KEY_MODEL); |
| 586 | } |
| 587 | if (savedInstanceState.containsKey(BUNDLE_KEY_EDIT_STATE)) { |
| 588 | mModification = savedInstanceState.getInt(BUNDLE_KEY_EDIT_STATE); |
| 589 | } |
Mindy Pereira | 2d63dff | 2011-10-04 12:51:12 -0700 | [diff] [blame] | 590 | if (savedInstanceState.containsKey(BUNDLE_KEY_EDIT_ON_LAUNCH)) { |
| 591 | mShowModifyDialogOnLaunch = savedInstanceState |
| 592 | .getBoolean(BUNDLE_KEY_EDIT_ON_LAUNCH); |
| 593 | } |
Erik | c130d9d | 2010-12-06 15:55:23 -0800 | [diff] [blame] | 594 | if (savedInstanceState.containsKey(BUNDLE_KEY_EVENT)) { |
| 595 | mEventBundle = (EventBundle) savedInstanceState.getSerializable(BUNDLE_KEY_EVENT); |
| 596 | } |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 597 | if (savedInstanceState.containsKey(BUNDLE_KEY_READ_ONLY)) { |
| 598 | mIsReadOnly = savedInstanceState.getBoolean(BUNDLE_KEY_READ_ONLY); |
| 599 | } |
Sam Blitzstein | 7674b69 | 2013-01-29 11:45:20 -0800 | [diff] [blame] | 600 | if (savedInstanceState.containsKey("EditEventView_timebuttonclicked")) { |
| 601 | mTimeSelectedWasStartTime = savedInstanceState.getBoolean( |
| 602 | "EditEventView_timebuttonclicked"); |
| 603 | } |
James Kung | 56f42bf | 2013-03-29 14:59:29 -0700 | [diff] [blame] | 604 | if (savedInstanceState.containsKey(BUNDLE_KEY_DATE_BUTTON_CLICKED)) { |
| 605 | mDateSelectedWasStartDate = savedInstanceState.getBoolean( |
| 606 | BUNDLE_KEY_DATE_BUTTON_CLICKED); |
| 607 | } |
Sam Blitzstein | 7674b69 | 2013-01-29 11:45:20 -0800 | [diff] [blame] | 608 | |
Erik | 59ead67 | 2010-11-29 15:47:08 -0800 | [diff] [blame] | 609 | } |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 610 | } |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 611 | |
| 612 | |
| 613 | @Override |
| 614 | public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { |
| 615 | super.onCreateOptionsMenu(menu, inflater); |
Andy Huang | 135b2d4 | 2011-09-01 20:38:43 -0700 | [diff] [blame] | 616 | |
| 617 | if (!mUseCustomActionBar) { |
| 618 | inflater.inflate(R.menu.edit_event_title_bar, menu); |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 619 | } |
| 620 | } |
| 621 | |
| 622 | @Override |
| 623 | public boolean onOptionsItemSelected(MenuItem item) { |
Andy Huang | 135b2d4 | 2011-09-01 20:38:43 -0700 | [diff] [blame] | 624 | return onActionBarItemSelected(item.getItemId()); |
| 625 | } |
| 626 | |
| 627 | /** |
| 628 | * Handles menu item selections, whether they come from our custom action bar buttons or from |
| 629 | * the standard menu items. Depends on the menu item ids matching the custom action bar button |
| 630 | * ids. |
| 631 | * |
| 632 | * @param itemId the button or menu item id |
| 633 | * @return whether the event was handled here |
| 634 | */ |
| 635 | private boolean onActionBarItemSelected(int itemId) { |
Michael Chan | bb6d927 | 2012-08-17 17:32:58 -0700 | [diff] [blame] | 636 | if (itemId == R.id.action_done) { |
| 637 | if (EditEventHelper.canModifyEvent(mModel) || EditEventHelper.canRespond(mModel)) { |
| 638 | if (mView != null && mView.prepareForSave()) { |
| 639 | if (mModification == Utils.MODIFY_UNINITIALIZED) { |
| 640 | mModification = Utils.MODIFY_ALL; |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 641 | } |
Michael Chan | bb6d927 | 2012-08-17 17:32:58 -0700 | [diff] [blame] | 642 | mOnDone.setDoneCode(Utils.DONE_SAVE | Utils.DONE_EXIT); |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 643 | mOnDone.run(); |
| 644 | } else { |
| 645 | mOnDone.setDoneCode(Utils.DONE_REVERT); |
| 646 | mOnDone.run(); |
| 647 | } |
Michael Chan | bb6d927 | 2012-08-17 17:32:58 -0700 | [diff] [blame] | 648 | } else if (EditEventHelper.canAddReminders(mModel) && mModel.mId != -1 |
| 649 | && mOriginalModel != null && mView.prepareForSave()) { |
| 650 | saveReminders(); |
| 651 | mOnDone.setDoneCode(Utils.DONE_EXIT); |
| 652 | mOnDone.run(); |
| 653 | } else { |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 654 | mOnDone.setDoneCode(Utils.DONE_REVERT); |
| 655 | mOnDone.run(); |
Michael Chan | bb6d927 | 2012-08-17 17:32:58 -0700 | [diff] [blame] | 656 | } |
| 657 | } else if (itemId == R.id.action_cancel) { |
| 658 | mOnDone.setDoneCode(Utils.DONE_REVERT); |
| 659 | mOnDone.run(); |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 660 | } |
| 661 | return true; |
| 662 | } |
| 663 | |
| 664 | private void saveReminders() { |
| 665 | ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>(3); |
Andy McFadden | fea9af5 | 2011-05-13 15:40:10 -0700 | [diff] [blame] | 666 | boolean changed = EditEventHelper.saveReminders(ops, mModel.mId, mModel.mReminders, |
| 667 | mOriginalModel.mReminders, false /* no force save */); |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 668 | |
| 669 | if (!changed) { |
| 670 | return; |
| 671 | } |
| 672 | |
| 673 | AsyncQueryService service = new AsyncQueryService(getActivity()); |
| 674 | service.startBatch(0, null, Calendars.CONTENT_URI.getAuthority(), ops, 0); |
| 675 | // Update the "hasAlarm" field for the event |
| 676 | Uri uri = ContentUris.withAppendedId(Events.CONTENT_URI, mModel.mId); |
Andy McFadden | fea9af5 | 2011-05-13 15:40:10 -0700 | [diff] [blame] | 677 | int len = mModel.mReminders.size(); |
Erik | 5f62079 | 2010-10-27 12:42:01 -0700 | [diff] [blame] | 678 | boolean hasAlarm = len > 0; |
| 679 | if (hasAlarm != mOriginalModel.mHasAlarm) { |
| 680 | ContentValues values = new ContentValues(); |
| 681 | values.put(Events.HAS_ALARM, hasAlarm ? 1 : 0); |
| 682 | service.startUpdate(0, null, uri, values, null, null, 0); |
| 683 | } |
| 684 | |
| 685 | Toast.makeText(mContext, R.string.saving_event, Toast.LENGTH_SHORT).show(); |
| 686 | } |
| 687 | |
Erik | 46cde5c | 2010-12-05 13:16:16 -0800 | [diff] [blame] | 688 | protected void displayEditWhichDialog() { |
Mindy Pereira | 2d63dff | 2011-10-04 12:51:12 -0700 | [diff] [blame] | 689 | if (mModification == Utils.MODIFY_UNINITIALIZED) { |
RoboErik | e0dbac6 | 2011-06-29 15:09:37 -0700 | [diff] [blame] | 690 | final boolean notSynced = TextUtils.isEmpty(mModel.mSyncId); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 691 | boolean isFirstEventInSeries = mModel.mIsFirstEventInSeries; |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 692 | int itemIndex = 0; |
| 693 | CharSequence[] items; |
Michael Chan | 1ec8763 | 2010-11-18 22:16:22 -0800 | [diff] [blame] | 694 | |
| 695 | if (notSynced) { |
| 696 | // If this event has not been synced, then don't allow deleting |
| 697 | // or changing a single instance. |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 698 | if (isFirstEventInSeries) { |
| 699 | // Still display the option so the user knows all events are |
| 700 | // changing |
| 701 | items = new CharSequence[1]; |
| 702 | } else { |
| 703 | items = new CharSequence[2]; |
| 704 | } |
| 705 | } else { |
| 706 | if (isFirstEventInSeries) { |
| 707 | items = new CharSequence[2]; |
| 708 | } else { |
| 709 | items = new CharSequence[3]; |
| 710 | } |
| 711 | items[itemIndex++] = mContext.getText(R.string.modify_event); |
| 712 | } |
| 713 | items[itemIndex++] = mContext.getText(R.string.modify_all); |
| 714 | |
| 715 | // Do one more check to make sure this remains at the end of the list |
| 716 | if (!isFirstEventInSeries) { |
| 717 | items[itemIndex++] = mContext.getText(R.string.modify_all_following); |
| 718 | } |
| 719 | |
| 720 | // Display the modification dialog. |
| 721 | if (mModifyDialog != null) { |
| 722 | mModifyDialog.dismiss(); |
| 723 | mModifyDialog = null; |
| 724 | } |
RoboErik | 28dab65 | 2011-07-21 15:08:39 -0700 | [diff] [blame] | 725 | mModifyDialog = new AlertDialog.Builder(mContext).setTitle(R.string.edit_event_label) |
| 726 | .setItems(items, new OnClickListener() { |
Michael Chan | f9fa0ab | 2012-12-14 00:41:18 -0800 | [diff] [blame] | 727 | @Override |
RoboErik | 28dab65 | 2011-07-21 15:08:39 -0700 | [diff] [blame] | 728 | public void onClick(DialogInterface dialog, int which) { |
| 729 | if (which == 0) { |
| 730 | // Update this if we start allowing exceptions |
| 731 | // to unsynced events in the app |
| 732 | mModification = notSynced ? Utils.MODIFY_ALL |
| 733 | : Utils.MODIFY_SELECTED; |
| 734 | if (mModification == Utils.MODIFY_SELECTED) { |
| 735 | mModel.mOriginalSyncId = notSynced ? null : mModel.mSyncId; |
| 736 | mModel.mOriginalId = mModel.mId; |
| 737 | } |
| 738 | } else if (which == 1) { |
| 739 | mModification = notSynced ? Utils.MODIFY_ALL_FOLLOWING |
| 740 | : Utils.MODIFY_ALL; |
| 741 | } else if (which == 2) { |
| 742 | mModification = Utils.MODIFY_ALL_FOLLOWING; |
| 743 | } |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 744 | |
RoboErik | 28dab65 | 2011-07-21 15:08:39 -0700 | [diff] [blame] | 745 | mView.setModification(mModification); |
RoboErik | 28dab65 | 2011-07-21 15:08:39 -0700 | [diff] [blame] | 746 | } |
| 747 | }).show(); |
Michael Chan | d17d348 | 2011-08-18 16:11:51 -0700 | [diff] [blame] | 748 | |
| 749 | mModifyDialog.setOnCancelListener(new OnCancelListener() { |
| 750 | @Override |
| 751 | public void onCancel(DialogInterface dialog) { |
| 752 | Activity a = EditEventFragment.this.getActivity(); |
| 753 | if (a != null) { |
| 754 | a.finish(); |
| 755 | } |
| 756 | } |
| 757 | }); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 758 | } |
| 759 | } |
| 760 | |
| 761 | class Done implements EditEventHelper.EditDoneRunnable { |
| 762 | private int mCode = -1; |
| 763 | |
Michael Chan | f9fa0ab | 2012-12-14 00:41:18 -0800 | [diff] [blame] | 764 | @Override |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 765 | public void setDoneCode(int code) { |
| 766 | mCode = code; |
| 767 | } |
| 768 | |
Michael Chan | f9fa0ab | 2012-12-14 00:41:18 -0800 | [diff] [blame] | 769 | @Override |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 770 | public void run() { |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 771 | // We only want this to get called once, either because the user |
| 772 | // pressed back/home or one of the buttons on screen |
| 773 | mSaveOnDetach = false; |
RoboErik | aca9e03 | 2011-06-10 15:16:56 -0700 | [diff] [blame] | 774 | if (mModification == Utils.MODIFY_UNINITIALIZED) { |
| 775 | // If this is uninitialized the user hit back, the only |
| 776 | // changeable item is response to default to all events. |
| 777 | mModification = Utils.MODIFY_ALL; |
| 778 | } |
Erik | 7b92da2 | 2010-09-23 14:55:22 -0700 | [diff] [blame] | 779 | |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 780 | if ((mCode & Utils.DONE_SAVE) != 0 && mModel != null |
| 781 | && (EditEventHelper.canRespond(mModel) |
| 782 | || EditEventHelper.canModifyEvent(mModel)) |
RoboErik | 6a7003d | 2011-08-04 16:23:20 -0700 | [diff] [blame] | 783 | && mView.prepareForSave() |
Michael Chan | d0fb2dd | 2011-01-07 14:37:18 -0800 | [diff] [blame] | 784 | && !isEmptyNewEvent() |
Andy McFadden | ae5bcce | 2011-04-14 09:28:08 -0700 | [diff] [blame] | 785 | && mModel.normalizeReminders() |
Michael Chan | 304bf0d | 2010-10-13 14:04:56 -0700 | [diff] [blame] | 786 | && mHelper.saveEvent(mModel, mOriginalModel, mModification)) { |
| 787 | int stringResource; |
Michael Chan | ea8ebdb | 2011-02-28 19:04:00 -0800 | [diff] [blame] | 788 | if (!mModel.mAttendeesList.isEmpty()) { |
| 789 | if (mModel.mUri != null) { |
| 790 | stringResource = R.string.saving_event_with_guest; |
| 791 | } else { |
| 792 | stringResource = R.string.creating_event_with_guest; |
| 793 | } |
Michael Chan | 304bf0d | 2010-10-13 14:04:56 -0700 | [diff] [blame] | 794 | } else { |
Michael Chan | ea8ebdb | 2011-02-28 19:04:00 -0800 | [diff] [blame] | 795 | if (mModel.mUri != null) { |
| 796 | stringResource = R.string.saving_event; |
| 797 | } else { |
| 798 | stringResource = R.string.creating_event; |
| 799 | } |
Erik | 7b92da2 | 2010-09-23 14:55:22 -0700 | [diff] [blame] | 800 | } |
Michael Chan | 304bf0d | 2010-10-13 14:04:56 -0700 | [diff] [blame] | 801 | Toast.makeText(mContext, stringResource, Toast.LENGTH_SHORT).show(); |
RoboErik | 2bd5cc0 | 2011-07-28 14:19:54 -0700 | [diff] [blame] | 802 | } else if ((mCode & Utils.DONE_SAVE) != 0 && mModel != null && isEmptyNewEvent()) { |
| 803 | Toast.makeText(mContext, R.string.empty_event, Toast.LENGTH_SHORT).show(); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 804 | } |
Erik | 7b92da2 | 2010-09-23 14:55:22 -0700 | [diff] [blame] | 805 | |
RoboErik | 2fda245 | 2011-02-15 17:47:45 -0800 | [diff] [blame] | 806 | if ((mCode & Utils.DONE_DELETE) != 0 && mOriginalModel != null |
| 807 | && EditEventHelper.canModifyCalendar(mOriginalModel)) { |
Erik | 7b92da2 | 2010-09-23 14:55:22 -0700 | [diff] [blame] | 808 | long begin = mModel.mStart; |
| 809 | long end = mModel.mEnd; |
| 810 | int which = -1; |
| 811 | switch (mModification) { |
| 812 | case Utils.MODIFY_SELECTED: |
| 813 | which = DeleteEventHelper.DELETE_SELECTED; |
| 814 | break; |
| 815 | case Utils.MODIFY_ALL_FOLLOWING: |
| 816 | which = DeleteEventHelper.DELETE_ALL_FOLLOWING; |
| 817 | break; |
| 818 | case Utils.MODIFY_ALL: |
| 819 | which = DeleteEventHelper.DELETE_ALL; |
| 820 | break; |
| 821 | } |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 822 | DeleteEventHelper deleteHelper = new DeleteEventHelper( |
| 823 | mContext, mContext, !mIsReadOnly /* exitWhenDone */); |
Erik | 6663f36 | 2011-01-18 10:05:55 -0800 | [diff] [blame] | 824 | deleteHelper.delete(begin, end, mOriginalModel, which); |
Erik | 7b92da2 | 2010-09-23 14:55:22 -0700 | [diff] [blame] | 825 | } |
| 826 | |
| 827 | if ((mCode & Utils.DONE_EXIT) != 0) { |
| 828 | // This will exit the edit event screen, should be called |
| 829 | // when we want to return to the main calendar views |
Isaac Katzenelson | 4024dee | 2011-09-29 14:40:46 -0700 | [diff] [blame] | 830 | if ((mCode & Utils.DONE_SAVE) != 0) { |
| 831 | if (mContext != null) { |
RoboErik | c8e0f21 | 2011-10-13 17:57:39 -0700 | [diff] [blame] | 832 | long start = mModel.mStart; |
| 833 | long end = mModel.mEnd; |
| 834 | if (mModel.mAllDay) { |
| 835 | // For allday events we want to go to the day in the |
| 836 | // user's current tz |
| 837 | String tz = Utils.getTimeZone(mContext, null); |
| 838 | Time t = new Time(Time.TIMEZONE_UTC); |
| 839 | t.set(start); |
| 840 | t.timezone = tz; |
| 841 | start = t.toMillis(true); |
| 842 | |
| 843 | t.timezone = Time.TIMEZONE_UTC; |
| 844 | t.set(end); |
| 845 | t.timezone = tz; |
| 846 | end = t.toMillis(true); |
| 847 | } |
Isaac Katzenelson | 6bcafcf | 2012-05-02 18:25:36 -0700 | [diff] [blame] | 848 | CalendarController.getInstance(mContext).launchViewEvent(-1, start, end, |
| 849 | Attendees.ATTENDEE_STATUS_NONE); |
Isaac Katzenelson | 4024dee | 2011-09-29 14:40:46 -0700 | [diff] [blame] | 850 | } |
| 851 | } |
Michael Chan | 0d4a304 | 2011-09-18 18:02:38 -0700 | [diff] [blame] | 852 | Activity a = EditEventFragment.this.getActivity(); |
| 853 | if (a != null) { |
| 854 | a.finish(); |
| 855 | } |
Erik | 7b92da2 | 2010-09-23 14:55:22 -0700 | [diff] [blame] | 856 | } |
| 857 | |
Daisuke Miyakawa | 5c0dec1 | 2010-09-22 17:21:42 -0700 | [diff] [blame] | 858 | // Hide a software keyboard so that user won't see it even after this Fragment's |
| 859 | // disappearing. |
| 860 | final View focusedView = mContext.getCurrentFocus(); |
| 861 | if (focusedView != null) { |
| 862 | mInputMethodManager.hideSoftInputFromWindow(focusedView.getWindowToken(), 0); |
| 863 | focusedView.clearFocus(); |
| 864 | } |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 865 | } |
| 866 | } |
| 867 | |
Michael Chan | d0fb2dd | 2011-01-07 14:37:18 -0800 | [diff] [blame] | 868 | boolean isEmptyNewEvent() { |
| 869 | if (mOriginalModel != null) { |
| 870 | // Not new |
| 871 | return false; |
| 872 | } |
| 873 | |
Michael Chan | f9fa0ab | 2012-12-14 00:41:18 -0800 | [diff] [blame] | 874 | if (mModel.mOriginalStart != mModel.mStart || mModel.mOriginalEnd != mModel.mEnd) { |
| 875 | return false; |
Michael Chan | d0fb2dd | 2011-01-07 14:37:18 -0800 | [diff] [blame] | 876 | } |
| 877 | |
Michael Chan | f9fa0ab | 2012-12-14 00:41:18 -0800 | [diff] [blame] | 878 | if (!mModel.mAttendeesList.isEmpty()) { |
| 879 | return false; |
Michael Chan | d0fb2dd | 2011-01-07 14:37:18 -0800 | [diff] [blame] | 880 | } |
| 881 | |
Michael Chan | f9fa0ab | 2012-12-14 00:41:18 -0800 | [diff] [blame] | 882 | return mModel.isEmpty(); |
Michael Chan | d0fb2dd | 2011-01-07 14:37:18 -0800 | [diff] [blame] | 883 | } |
| 884 | |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 885 | @Override |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 886 | public void onPause() { |
| 887 | Activity act = getActivity(); |
Erik | 55d4c8c | 2010-12-22 13:59:57 -0800 | [diff] [blame] | 888 | if (mSaveOnDetach && act != null && !mIsReadOnly && !act.isChangingConfigurations() |
| 889 | && mView.prepareForSave()) { |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 890 | mOnDone.setDoneCode(Utils.DONE_SAVE); |
| 891 | mOnDone.run(); |
| 892 | } |
| 893 | super.onPause(); |
| 894 | } |
| 895 | |
| 896 | @Override |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 897 | public void onDestroy() { |
Dmitri Plotnikov | ee21220 | 2010-08-27 17:58:19 -0700 | [diff] [blame] | 898 | if (mView != null) { |
| 899 | mView.setModel(null); |
| 900 | } |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 901 | if (mModifyDialog != null) { |
| 902 | mModifyDialog.dismiss(); |
| 903 | mModifyDialog = null; |
| 904 | } |
Erik | 7b92da2 | 2010-09-23 14:55:22 -0700 | [diff] [blame] | 905 | super.onDestroy(); |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 906 | } |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 907 | |
| 908 | @Override |
| 909 | public void eventsChanged() { |
| 910 | // TODO Requery to see if event has changed |
| 911 | } |
| 912 | |
| 913 | @Override |
Erik | 59ead67 | 2010-11-29 15:47:08 -0800 | [diff] [blame] | 914 | public void onSaveInstanceState(Bundle outState) { |
| 915 | mView.prepareForSave(); |
| 916 | outState.putSerializable(BUNDLE_KEY_MODEL, mModel); |
| 917 | outState.putInt(BUNDLE_KEY_EDIT_STATE, mModification); |
Erik | c130d9d | 2010-12-06 15:55:23 -0800 | [diff] [blame] | 918 | if (mEventBundle == null && mEvent != null) { |
| 919 | mEventBundle = new EventBundle(); |
| 920 | mEventBundle.id = mEvent.id; |
| 921 | if (mEvent.startTime != null) { |
| 922 | mEventBundle.start = mEvent.startTime.toMillis(true); |
| 923 | } |
| 924 | if (mEvent.endTime != null) { |
| 925 | mEventBundle.end = mEvent.startTime.toMillis(true); |
| 926 | } |
| 927 | } |
Mindy Pereira | 2d63dff | 2011-10-04 12:51:12 -0700 | [diff] [blame] | 928 | outState.putBoolean(BUNDLE_KEY_EDIT_ON_LAUNCH, mShowModifyDialogOnLaunch); |
Erik | c130d9d | 2010-12-06 15:55:23 -0800 | [diff] [blame] | 929 | outState.putSerializable(BUNDLE_KEY_EVENT, mEventBundle); |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 930 | outState.putBoolean(BUNDLE_KEY_READ_ONLY, mIsReadOnly); |
Sam Blitzstein | 7674b69 | 2013-01-29 11:45:20 -0800 | [diff] [blame] | 931 | |
| 932 | outState.putBoolean("EditEventView_timebuttonclicked", mView.mTimeSelectedWasStartTime); |
James Kung | 56f42bf | 2013-03-29 14:59:29 -0700 | [diff] [blame] | 933 | outState.putBoolean(BUNDLE_KEY_DATE_BUTTON_CLICKED, mView.mDateSelectedWasStartDate); |
Erik | 59ead67 | 2010-11-29 15:47:08 -0800 | [diff] [blame] | 934 | } |
| 935 | |
| 936 | @Override |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 937 | public long getSupportedEventTypes() { |
Erik | 7b92da2 | 2010-09-23 14:55:22 -0700 | [diff] [blame] | 938 | return EventType.USER_HOME; |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 939 | } |
| 940 | |
| 941 | @Override |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 942 | public void handleEvent(EventInfo event) { |
Erik | 7b92da2 | 2010-09-23 14:55:22 -0700 | [diff] [blame] | 943 | // It's currently unclear if we want to save the event or not when home |
| 944 | // is pressed. When creating a new event we shouldn't save since we |
| 945 | // can't get the id of the new event easily. |
| 946 | if ((false && event.eventType == EventType.USER_HOME) || (event.eventType == EventType.GO_TO |
| 947 | && mSaveOnDetach)) { |
| 948 | if (mView != null && mView.prepareForSave()) { |
| 949 | mOnDone.setDoneCode(Utils.DONE_SAVE); |
| 950 | mOnDone.run(); |
| 951 | } |
| 952 | } |
Erik | dd95df5 | 2010-08-27 09:31:18 -0700 | [diff] [blame] | 953 | } |
Erik | c130d9d | 2010-12-06 15:55:23 -0800 | [diff] [blame] | 954 | |
Erik | a7694ee | 2010-12-07 15:46:18 -0800 | [diff] [blame] | 955 | private static class EventBundle implements Serializable { |
Michael Chan | 17c0cea | 2011-08-19 18:00:29 -0700 | [diff] [blame] | 956 | private static final long serialVersionUID = 1L; |
Erik | c130d9d | 2010-12-06 15:55:23 -0800 | [diff] [blame] | 957 | long id = -1; |
| 958 | long start = -1; |
| 959 | long end = -1; |
| 960 | } |
James Kung | b8904fb | 2013-02-14 14:37:42 -0800 | [diff] [blame] | 961 | |
| 962 | @Override |
| 963 | public void onColorSelected(int color) { |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 964 | if (!mModel.isEventColorInitialized() || mModel.getEventColor() != color) { |
| 965 | mModel.setEventColor(color); |
James Kung | b8904fb | 2013-02-14 14:37:42 -0800 | [diff] [blame] | 966 | mView.updateHeadlineColor(mModel, color); |
| 967 | } |
| 968 | } |
Erik | 79f2281 | 2010-06-23 16:55:38 -0700 | [diff] [blame] | 969 | } |