Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -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 | |
| 17 | package com.android.calendar; |
| 18 | |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 19 | import static android.provider.CalendarContract.EXTRA_EVENT_ALL_DAY; |
| 20 | import static android.provider.CalendarContract.EXTRA_EVENT_BEGIN_TIME; |
| 21 | import static android.provider.CalendarContract.EXTRA_EVENT_END_TIME; |
| 22 | import static com.android.calendar.CalendarController.EVENT_EDIT_ON_LAUNCH; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 23 | |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 24 | import android.animation.Animator; |
| 25 | import android.animation.AnimatorListenerAdapter; |
| 26 | import android.animation.ObjectAnimator; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 27 | import android.app.Activity; |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 28 | import android.app.Dialog; |
| 29 | import android.app.DialogFragment; |
James Kung | 95e9538 | 2013-03-20 12:14:33 -0700 | [diff] [blame] | 30 | import android.app.FragmentManager; |
Andy McFadden | ef31a98 | 2011-06-09 07:38:56 -0700 | [diff] [blame] | 31 | import android.app.Service; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 32 | import android.content.ActivityNotFoundException; |
Erik | 364309f | 2010-12-23 14:26:26 -0800 | [diff] [blame] | 33 | import android.content.ContentProviderOperation; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 34 | import android.content.ContentResolver; |
| 35 | import android.content.ContentUris; |
| 36 | import android.content.ContentValues; |
| 37 | import android.content.Context; |
Isaac Katzenelson | b0a313a | 2011-10-24 11:41:56 -0700 | [diff] [blame] | 38 | import android.content.DialogInterface; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 39 | import android.content.Intent; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 40 | import android.content.SharedPreferences; |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 41 | import android.content.pm.ApplicationInfo; |
| 42 | import android.content.pm.PackageManager; |
| 43 | import android.content.pm.PackageManager.NameNotFoundException; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 44 | import android.content.res.Resources; |
| 45 | import android.database.Cursor; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 46 | import android.graphics.Color; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 47 | import android.graphics.Rect; |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 48 | import android.graphics.drawable.Drawable; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 49 | import android.net.Uri; |
| 50 | import android.os.Bundle; |
RoboErik | a7c0390 | 2011-06-14 11:06:44 -0700 | [diff] [blame] | 51 | import android.provider.CalendarContract; |
| 52 | import android.provider.CalendarContract.Attendees; |
| 53 | import android.provider.CalendarContract.Calendars; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 54 | import android.provider.CalendarContract.Colors; |
RoboErik | a7c0390 | 2011-06-14 11:06:44 -0700 | [diff] [blame] | 55 | import android.provider.CalendarContract.Events; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 56 | import android.provider.CalendarContract.Reminders; |
Erik | cb81189 | 2010-09-28 13:44:19 -0700 | [diff] [blame] | 57 | import android.provider.ContactsContract; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 58 | import android.provider.ContactsContract.CommonDataKinds; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 59 | import android.provider.ContactsContract.Intents; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 60 | import android.provider.ContactsContract.QuickContact; |
Michael Chan | 8ce3b7d | 2010-09-01 15:41:01 -0700 | [diff] [blame] | 61 | import android.text.Spannable; |
| 62 | import android.text.SpannableStringBuilder; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 63 | import android.text.TextUtils; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 64 | import android.text.format.Time; |
Andy McFadden | 73b0765 | 2011-08-23 15:45:09 -0700 | [diff] [blame] | 65 | import android.text.method.LinkMovementMethod; |
| 66 | import android.text.method.MovementMethod; |
Michael Chan | 8ce3b7d | 2010-09-01 15:41:01 -0700 | [diff] [blame] | 67 | import android.text.style.ForegroundColorSpan; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 68 | import android.text.util.Rfc822Token; |
| 69 | import android.util.Log; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 70 | import android.util.SparseIntArray; |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 71 | import android.view.Gravity; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 72 | import android.view.LayoutInflater; |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 73 | import android.view.Menu; |
| 74 | import android.view.MenuInflater; |
| 75 | import android.view.MenuItem; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 76 | import android.view.MotionEvent; |
| 77 | import android.view.View; |
Erik | cb81189 | 2010-09-28 13:44:19 -0700 | [diff] [blame] | 78 | import android.view.View.OnClickListener; |
| 79 | import android.view.View.OnTouchListener; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 80 | import android.view.ViewGroup; |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 81 | import android.view.Window; |
| 82 | import android.view.WindowManager; |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 83 | import android.view.accessibility.AccessibilityEvent; |
| 84 | import android.view.accessibility.AccessibilityManager; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 85 | import android.widget.AdapterView; |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 86 | import android.widget.AdapterView.OnItemSelectedListener; |
Michael Chan | 8ce3b7d | 2010-09-01 15:41:01 -0700 | [diff] [blame] | 87 | import android.widget.Button; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 88 | import android.widget.LinearLayout; |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 89 | import android.widget.RadioButton; |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 90 | import android.widget.RadioGroup; |
| 91 | import android.widget.RadioGroup.OnCheckedChangeListener; |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 92 | import android.widget.ScrollView; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 93 | import android.widget.TextView; |
| 94 | import android.widget.Toast; |
| 95 | |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 96 | import com.android.calendar.CalendarController.EventInfo; |
| 97 | import com.android.calendar.CalendarController.EventType; |
| 98 | import com.android.calendar.CalendarEventModel.Attendee; |
| 99 | import com.android.calendar.CalendarEventModel.ReminderEntry; |
Sara Ting | 7da2767 | 2012-07-24 16:23:53 -0700 | [diff] [blame] | 100 | import com.android.calendar.alerts.QuickResponseActivity; |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 101 | import com.android.calendar.event.AttendeesView; |
| 102 | import com.android.calendar.event.EditEventActivity; |
| 103 | import com.android.calendar.event.EditEventHelper; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 104 | import com.android.calendar.event.EventColorPickerDialog; |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 105 | import com.android.calendar.event.EventViewUtils; |
Sara Ting | da3ee39 | 2012-12-10 15:18:26 -0800 | [diff] [blame] | 106 | import com.android.calendarcommon2.DateException; |
| 107 | import com.android.calendarcommon2.Duration; |
Michael Chan | 8a528ad | 2012-06-26 17:44:34 -0700 | [diff] [blame] | 108 | import com.android.calendarcommon2.EventRecurrence; |
James Kung | a8b8c0d | 2013-02-13 17:28:16 -0800 | [diff] [blame] | 109 | import com.android.colorpicker.ColorPickerSwatch.OnColorSelectedListener; |
| 110 | import com.android.colorpicker.HsvColorComparator; |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 111 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 112 | import java.util.ArrayList; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 113 | import java.util.Arrays; |
| 114 | import java.util.Collections; |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 115 | import java.util.List; |
Isaac Katzenelson | f6f7977 | 2011-06-02 16:29:18 -0700 | [diff] [blame] | 116 | |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 117 | public class EventInfoFragment extends DialogFragment implements OnCheckedChangeListener, |
James Kung | b8904fb | 2013-02-14 14:37:42 -0800 | [diff] [blame] | 118 | CalendarController.EventHandler, OnClickListener, DeleteEventHelper.DeleteNotifyListener, |
| 119 | OnColorSelectedListener { |
Michael Chan | 83efa2d | 2012-04-24 17:42:21 -0700 | [diff] [blame] | 120 | |
James Kung | e134cd5 | 2013-02-13 11:33:49 -0800 | [diff] [blame] | 121 | public static final boolean DEBUG = false; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 122 | |
Michael Chan | 2c7c851 | 2010-12-10 14:12:57 -0800 | [diff] [blame] | 123 | public static final String TAG = "EventInfoFragment"; |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 124 | public static final String COLOR_PICKER_DIALOG_TAG = "EventColorPickerDialog"; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 125 | |
James Kung | b8904fb | 2013-02-14 14:37:42 -0800 | [diff] [blame] | 126 | private static final int REQUEST_CODE_COLOR_PICKER = 0; |
| 127 | |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 128 | protected static final String BUNDLE_KEY_EVENT_ID = "key_event_id"; |
| 129 | protected static final String BUNDLE_KEY_START_MILLIS = "key_start_millis"; |
| 130 | protected static final String BUNDLE_KEY_END_MILLIS = "key_end_millis"; |
| 131 | protected static final String BUNDLE_KEY_IS_DIALOG = "key_fragment_is_dialog"; |
Isaac Katzenelson | b0a313a | 2011-10-24 11:41:56 -0700 | [diff] [blame] | 132 | protected static final String BUNDLE_KEY_DELETE_DIALOG_VISIBLE = "key_delete_dialog_visible"; |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 133 | protected static final String BUNDLE_KEY_WINDOW_STYLE = "key_window_style"; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 134 | protected static final String BUNDLE_KEY_CALENDAR_COLOR = "key_calendar_color"; |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 135 | protected static final String BUNDLE_KEY_CALENDAR_COLOR_INIT = "key_calendar_color_init"; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 136 | protected static final String BUNDLE_KEY_CURRENT_COLOR = "key_current_color"; |
James Kung | 497a625 | 2013-05-17 14:47:33 -0700 | [diff] [blame^] | 137 | protected static final String BUNDLE_KEY_CURRENT_COLOR_KEY = "key_current_color_key"; |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 138 | protected static final String BUNDLE_KEY_CURRENT_COLOR_INIT = "key_current_color_init"; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 139 | protected static final String BUNDLE_KEY_ORIGINAL_COLOR = "key_original_color"; |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 140 | protected static final String BUNDLE_KEY_ORIGINAL_COLOR_INIT = "key_original_color_init"; |
Sam Blitzstein | 94a1f1a | 2013-02-12 15:16:35 -0800 | [diff] [blame] | 141 | protected static final String BUNDLE_KEY_ATTENDEE_RESPONSE = "key_attendee_response"; |
| 142 | protected static final String BUNDLE_KEY_USER_SET_ATTENDEE_RESPONSE = |
| 143 | "key_user_set_attendee_response"; |
| 144 | protected static final String BUNDLE_KEY_TENTATIVE_USER_RESPONSE = |
| 145 | "key_tentative_user_response"; |
| 146 | protected static final String BUNDLE_KEY_RESPONSE_WHICH_EVENTS = "key_response_which_events"; |
| 147 | protected static final String BUNDLE_KEY_REMINDER_MINUTES = "key_reminder_minutes"; |
| 148 | protected static final String BUNDLE_KEY_REMINDER_METHODS = "key_reminder_methods"; |
| 149 | |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 150 | |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 151 | private static final String PERIOD_SPACE = ". "; |
| 152 | |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 153 | private static final String NO_EVENT_COLOR = ""; |
| 154 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 155 | /** |
| 156 | * These are the corresponding indices into the array of strings |
| 157 | * "R.array.change_response_labels" in the resource file. |
| 158 | */ |
| 159 | static final int UPDATE_SINGLE = 0; |
| 160 | static final int UPDATE_ALL = 1; |
| 161 | |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 162 | // Style of view |
| 163 | public static final int FULL_WINDOW_STYLE = 0; |
| 164 | public static final int DIALOG_WINDOW_STYLE = 1; |
| 165 | |
| 166 | private int mWindowStyle = DIALOG_WINDOW_STYLE; |
| 167 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 168 | // Query tokens for QueryHandler |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 169 | private static final int TOKEN_QUERY_EVENT = 1 << 0; |
| 170 | private static final int TOKEN_QUERY_CALENDARS = 1 << 1; |
| 171 | private static final int TOKEN_QUERY_ATTENDEES = 1 << 2; |
| 172 | private static final int TOKEN_QUERY_DUPLICATE_CALENDARS = 1 << 3; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 173 | private static final int TOKEN_QUERY_REMINDERS = 1 << 4; |
Sara Ting | 6aad0ff | 2012-08-02 10:55:52 -0700 | [diff] [blame] | 174 | private static final int TOKEN_QUERY_VISIBLE_CALENDARS = 1 << 5; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 175 | private static final int TOKEN_QUERY_COLORS = 1 << 6; |
| 176 | |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 177 | private static final int TOKEN_QUERY_ALL = TOKEN_QUERY_DUPLICATE_CALENDARS |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 178 | | TOKEN_QUERY_ATTENDEES | TOKEN_QUERY_CALENDARS | TOKEN_QUERY_EVENT |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 179 | | TOKEN_QUERY_REMINDERS | TOKEN_QUERY_VISIBLE_CALENDARS | TOKEN_QUERY_COLORS; |
Sara Ting | 6aad0ff | 2012-08-02 10:55:52 -0700 | [diff] [blame] | 180 | |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 181 | private int mCurrentQuery = 0; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 182 | |
| 183 | private static final String[] EVENT_PROJECTION = new String[] { |
| 184 | Events._ID, // 0 do not remove; used in DeleteEventHelper |
| 185 | Events.TITLE, // 1 do not remove; used in DeleteEventHelper |
| 186 | Events.RRULE, // 2 do not remove; used in DeleteEventHelper |
| 187 | Events.ALL_DAY, // 3 do not remove; used in DeleteEventHelper |
| 188 | Events.CALENDAR_ID, // 4 do not remove; used in DeleteEventHelper |
| 189 | Events.DTSTART, // 5 do not remove; used in DeleteEventHelper |
| 190 | Events._SYNC_ID, // 6 do not remove; used in DeleteEventHelper |
| 191 | Events.EVENT_TIMEZONE, // 7 do not remove; used in DeleteEventHelper |
| 192 | Events.DESCRIPTION, // 8 |
| 193 | Events.EVENT_LOCATION, // 9 |
Michael Chan | 693ca60 | 2012-05-31 12:24:11 -0700 | [diff] [blame] | 194 | Calendars.CALENDAR_ACCESS_LEVEL, // 10 |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 195 | Events.CALENDAR_COLOR, // 11 |
| 196 | Events.EVENT_COLOR, // 12 |
| 197 | Events.HAS_ATTENDEE_DATA, // 13 |
| 198 | Events.ORGANIZER, // 14 |
| 199 | Events.HAS_ALARM, // 15 |
| 200 | Calendars.MAX_REMINDERS, // 16 |
| 201 | Calendars.ALLOWED_REMINDERS, // 17 |
| 202 | Events.CUSTOM_APP_PACKAGE, // 18 |
| 203 | Events.CUSTOM_APP_URI, // 19 |
Sara Ting | da3ee39 | 2012-12-10 15:18:26 -0800 | [diff] [blame] | 204 | Events.DTEND, // 20 |
| 205 | Events.DURATION, // 21 |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 206 | Events.ORIGINAL_SYNC_ID // 22 do not remove; used in DeleteEventHelper |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 207 | }; |
| 208 | private static final int EVENT_INDEX_ID = 0; |
| 209 | private static final int EVENT_INDEX_TITLE = 1; |
| 210 | private static final int EVENT_INDEX_RRULE = 2; |
| 211 | private static final int EVENT_INDEX_ALL_DAY = 3; |
| 212 | private static final int EVENT_INDEX_CALENDAR_ID = 4; |
Sara Ting | da3ee39 | 2012-12-10 15:18:26 -0800 | [diff] [blame] | 213 | private static final int EVENT_INDEX_DTSTART = 5; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 214 | private static final int EVENT_INDEX_SYNC_ID = 6; |
| 215 | private static final int EVENT_INDEX_EVENT_TIMEZONE = 7; |
| 216 | private static final int EVENT_INDEX_DESCRIPTION = 8; |
| 217 | private static final int EVENT_INDEX_EVENT_LOCATION = 9; |
Michael Chan | 71b221a | 2010-10-25 17:55:44 -0700 | [diff] [blame] | 218 | private static final int EVENT_INDEX_ACCESS_LEVEL = 10; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 219 | private static final int EVENT_INDEX_CALENDAR_COLOR = 11; |
| 220 | private static final int EVENT_INDEX_EVENT_COLOR = 12; |
| 221 | private static final int EVENT_INDEX_HAS_ATTENDEE_DATA = 13; |
| 222 | private static final int EVENT_INDEX_ORGANIZER = 14; |
| 223 | private static final int EVENT_INDEX_HAS_ALARM = 15; |
| 224 | private static final int EVENT_INDEX_MAX_REMINDERS = 16; |
| 225 | private static final int EVENT_INDEX_ALLOWED_REMINDERS = 17; |
| 226 | private static final int EVENT_INDEX_CUSTOM_APP_PACKAGE = 18; |
| 227 | private static final int EVENT_INDEX_CUSTOM_APP_URI = 19; |
Sara Ting | da3ee39 | 2012-12-10 15:18:26 -0800 | [diff] [blame] | 228 | private static final int EVENT_INDEX_DTEND = 20; |
| 229 | private static final int EVENT_INDEX_DURATION = 21; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 230 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 231 | private static final String[] ATTENDEES_PROJECTION = new String[] { |
| 232 | Attendees._ID, // 0 |
| 233 | Attendees.ATTENDEE_NAME, // 1 |
| 234 | Attendees.ATTENDEE_EMAIL, // 2 |
| 235 | Attendees.ATTENDEE_RELATIONSHIP, // 3 |
| 236 | Attendees.ATTENDEE_STATUS, // 4 |
Sara Ting | ddbc002 | 2012-04-26 17:08:46 -0700 | [diff] [blame] | 237 | Attendees.ATTENDEE_IDENTITY, // 5 |
| 238 | Attendees.ATTENDEE_ID_NAMESPACE // 6 |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 239 | }; |
| 240 | private static final int ATTENDEES_INDEX_ID = 0; |
| 241 | private static final int ATTENDEES_INDEX_NAME = 1; |
| 242 | private static final int ATTENDEES_INDEX_EMAIL = 2; |
| 243 | private static final int ATTENDEES_INDEX_RELATIONSHIP = 3; |
| 244 | private static final int ATTENDEES_INDEX_STATUS = 4; |
Sara Ting | ddbc002 | 2012-04-26 17:08:46 -0700 | [diff] [blame] | 245 | private static final int ATTENDEES_INDEX_IDENTITY = 5; |
| 246 | private static final int ATTENDEES_INDEX_ID_NAMESPACE = 6; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 247 | |
Michael Chan | 693ca60 | 2012-05-31 12:24:11 -0700 | [diff] [blame] | 248 | static { |
Sara Ting | fac2d15 | 2012-05-31 14:59:57 -0700 | [diff] [blame] | 249 | if (!Utils.isJellybeanOrLater()) { |
Michael Chan | 693ca60 | 2012-05-31 12:24:11 -0700 | [diff] [blame] | 250 | EVENT_PROJECTION[EVENT_INDEX_CUSTOM_APP_PACKAGE] = Events._ID; // dummy value |
| 251 | EVENT_PROJECTION[EVENT_INDEX_CUSTOM_APP_URI] = Events._ID; // dummy value |
| 252 | |
| 253 | ATTENDEES_PROJECTION[ATTENDEES_INDEX_IDENTITY] = Attendees._ID; // dummy value |
| 254 | ATTENDEES_PROJECTION[ATTENDEES_INDEX_ID_NAMESPACE] = Attendees._ID; // dummy value |
| 255 | } |
| 256 | } |
| 257 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 258 | private static final String ATTENDEES_WHERE = Attendees.EVENT_ID + "=?"; |
| 259 | |
| 260 | private static final String ATTENDEES_SORT_ORDER = Attendees.ATTENDEE_NAME + " ASC, " |
| 261 | + Attendees.ATTENDEE_EMAIL + " ASC"; |
| 262 | |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 263 | private static final String[] REMINDERS_PROJECTION = new String[] { |
| 264 | Reminders._ID, // 0 |
| 265 | Reminders.MINUTES, // 1 |
| 266 | Reminders.METHOD // 2 |
| 267 | }; |
| 268 | private static final int REMINDERS_INDEX_ID = 0; |
| 269 | private static final int REMINDERS_MINUTES_ID = 1; |
| 270 | private static final int REMINDERS_METHOD_ID = 2; |
| 271 | |
| 272 | private static final String REMINDERS_WHERE = Reminders.EVENT_ID + "=?"; |
| 273 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 274 | static final String[] CALENDARS_PROJECTION = new String[] { |
| 275 | Calendars._ID, // 0 |
RoboErik | ef2add9 | 2011-06-09 14:49:53 -0700 | [diff] [blame] | 276 | Calendars.CALENDAR_DISPLAY_NAME, // 1 |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 277 | Calendars.OWNER_ACCOUNT, // 2 |
Sara Ting | 42896f7 | 2012-03-15 15:24:36 -0700 | [diff] [blame] | 278 | Calendars.CAN_ORGANIZER_RESPOND, // 3 |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 279 | Calendars.ACCOUNT_NAME, // 4 |
| 280 | Calendars.ACCOUNT_TYPE // 5 |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 281 | }; |
| 282 | static final int CALENDARS_INDEX_DISPLAY_NAME = 1; |
| 283 | static final int CALENDARS_INDEX_OWNER_ACCOUNT = 2; |
| 284 | static final int CALENDARS_INDEX_OWNER_CAN_RESPOND = 3; |
Sara Ting | 42896f7 | 2012-03-15 15:24:36 -0700 | [diff] [blame] | 285 | static final int CALENDARS_INDEX_ACCOUNT_NAME = 4; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 286 | static final int CALENDARS_INDEX_ACCOUNT_TYPE = 5; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 287 | |
| 288 | static final String CALENDARS_WHERE = Calendars._ID + "=?"; |
RoboErik | ef2add9 | 2011-06-09 14:49:53 -0700 | [diff] [blame] | 289 | static final String CALENDARS_DUPLICATE_NAME_WHERE = Calendars.CALENDAR_DISPLAY_NAME + "=?"; |
Sara Ting | 6aad0ff | 2012-08-02 10:55:52 -0700 | [diff] [blame] | 290 | static final String CALENDARS_VISIBLE_WHERE = Calendars.VISIBLE + "=?"; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 291 | |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 292 | static final String[] COLORS_PROJECTION = new String[] { |
| 293 | Colors._ID, // 0 |
| 294 | Colors.COLOR, // 1 |
| 295 | Colors.COLOR_KEY // 2 |
| 296 | }; |
| 297 | |
| 298 | static final String COLORS_WHERE = Colors.ACCOUNT_NAME + "=? AND " + Colors.ACCOUNT_TYPE + |
| 299 | "=? AND " + Colors.COLOR_TYPE + "=" + Colors.TYPE_EVENT; |
| 300 | |
| 301 | public static final int COLORS_INDEX_COLOR = 1; |
| 302 | public static final int COLORS_INDEX_COLOR_KEY = 2; |
Andy McFadden | fd8ce5e | 2011-11-15 15:44:57 -0800 | [diff] [blame] | 303 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 304 | private View mView; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 305 | |
| 306 | private Uri mUri; |
| 307 | private long mEventId; |
| 308 | private Cursor mEventCursor; |
| 309 | private Cursor mAttendeesCursor; |
| 310 | private Cursor mCalendarsCursor; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 311 | private Cursor mRemindersCursor; |
| 312 | |
Michael Chan | 0a01fd3 | 2011-01-23 15:13:28 -0800 | [diff] [blame] | 313 | private static float mScale = 0; // Used for supporting different screen densities |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 314 | |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 315 | private static int mCustomAppIconSize = 32; |
| 316 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 317 | private long mStartMillis; |
| 318 | private long mEndMillis; |
Michael Chan | 8b1119b | 2012-01-06 16:04:55 -0800 | [diff] [blame] | 319 | private boolean mAllDay; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 320 | |
| 321 | private boolean mHasAttendeeData; |
Michael Chan | 83efa2d | 2012-04-24 17:42:21 -0700 | [diff] [blame] | 322 | private String mEventOrganizerEmail; |
| 323 | private String mEventOrganizerDisplayName = ""; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 324 | private boolean mIsOrganizer; |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 325 | private long mCalendarOwnerAttendeeId = EditEventHelper.ATTENDEE_ID_NONE; |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 326 | private boolean mOwnerCanRespond; |
Sara Ting | 42896f7 | 2012-03-15 15:24:36 -0700 | [diff] [blame] | 327 | private String mSyncAccountName; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 328 | private String mCalendarOwnerAccount; |
| 329 | private boolean mCanModifyCalendar; |
RoboErik | 65eeb79 | 2011-08-08 12:54:00 -0700 | [diff] [blame] | 330 | private boolean mCanModifyEvent; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 331 | private boolean mIsBusyFreeCalendar; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 332 | private int mNumOfAttendees; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 333 | private EditResponseHelper mEditResponseHelper; |
Isaac Katzenelson | b0a313a | 2011-10-24 11:41:56 -0700 | [diff] [blame] | 334 | private boolean mDeleteDialogVisible = false; |
| 335 | private DeleteEventHelper mDeleteHelper; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 336 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 337 | private int mOriginalAttendeeResponse; |
Isaac Katzenelson | 6bcafcf | 2012-05-02 18:25:36 -0700 | [diff] [blame] | 338 | private int mAttendeeResponseFromIntent = Attendees.ATTENDEE_STATUS_NONE; |
| 339 | private int mUserSetResponse = Attendees.ATTENDEE_STATUS_NONE; |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 340 | private int mWhichEvents = -1; |
| 341 | // Used as the temporary response until the dialog is confirmed. It is also |
| 342 | // able to be used as a state marker for configuration changes. |
| 343 | private int mTentativeUserSetResponse = Attendees.ATTENDEE_STATUS_NONE; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 344 | private boolean mIsRepeating; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 345 | private boolean mHasAlarm; |
| 346 | private int mMaxReminders; |
| 347 | private String mCalendarAllowedReminders; |
Isaac Katzenelson | b33cdf4 | 2011-10-14 18:15:18 -0700 | [diff] [blame] | 348 | // Used to prevent saving changes in event if it is being deleted. |
| 349 | private boolean mEventDeletionStarted = false; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 350 | |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 351 | private TextView mTitle; |
Sara Ting | 75f5366 | 2012-04-09 15:37:10 -0700 | [diff] [blame] | 352 | private TextView mWhenDateTime; |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 353 | private TextView mWhere; |
Michael Chan | 99704a2 | 2011-11-11 10:24:37 -0800 | [diff] [blame] | 354 | private ExpandableTextView mDesc; |
Isaac Katzenelson | c0624ee | 2011-06-03 09:24:27 -0700 | [diff] [blame] | 355 | private AttendeesView mLongAttendees; |
Sara Ting | 7ffa24c | 2012-08-28 15:44:37 -0700 | [diff] [blame] | 356 | private Button emailAttendeesButton; |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 357 | private Menu mMenu = null; |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 358 | private View mHeadlines; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 359 | private ScrollView mScrollView; |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 360 | private View mLoadingMsgView; |
| 361 | private ObjectAnimator mAnimateAlpha; |
Isaac Katzenelson | 263b029 | 2012-03-14 14:55:50 -0700 | [diff] [blame] | 362 | private long mLoadingMsgStartTime; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 363 | |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 364 | private EventColorPickerDialog mColorPickerDialog; |
James Kung | e134cd5 | 2013-02-13 11:33:49 -0800 | [diff] [blame] | 365 | private SparseIntArray mDisplayColorKeyMap = new SparseIntArray(); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 366 | private int[] mColors; |
| 367 | private int mOriginalColor = -1; |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 368 | private boolean mOriginalColorInitialized = false; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 369 | private int mCalendarColor = -1; |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 370 | private boolean mCalendarColorInitialized = false; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 371 | private int mCurrentColor = -1; |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 372 | private boolean mCurrentColorInitialized = false; |
James Kung | 497a625 | 2013-05-17 14:47:33 -0700 | [diff] [blame^] | 373 | private int mCurrentColorKey = -1; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 374 | |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 375 | private static final int FADE_IN_TIME = 300; // in milliseconds |
Isaac Katzenelson | 263b029 | 2012-03-14 14:55:50 -0700 | [diff] [blame] | 376 | private static final int LOADING_MSG_DELAY = 600; // in milliseconds |
| 377 | private static final int LOADING_MSG_MIN_DISPLAY_TIME = 600; |
Isaac Katzenelson | 80d640f | 2012-04-20 09:21:28 -0700 | [diff] [blame] | 378 | private boolean mNoCrossFade = false; // Used to prevent repeated cross-fade |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 379 | private RadioGroup mResponseRadioGroup; |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 380 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 381 | ArrayList<Attendee> mAcceptedAttendees = new ArrayList<Attendee>(); |
| 382 | ArrayList<Attendee> mDeclinedAttendees = new ArrayList<Attendee>(); |
| 383 | ArrayList<Attendee> mTentativeAttendees = new ArrayList<Attendee>(); |
| 384 | ArrayList<Attendee> mNoResponseAttendees = new ArrayList<Attendee>(); |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 385 | ArrayList<String> mToEmails = new ArrayList<String>(); |
| 386 | ArrayList<String> mCcEmails = new ArrayList<String>(); |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 387 | |
| 388 | private int mDefaultReminderMinutes; |
Isaac Katzenelson | ac4350b | 2012-04-18 15:33:26 -0700 | [diff] [blame] | 389 | private final ArrayList<LinearLayout> mReminderViews = new ArrayList<LinearLayout>(0); |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 390 | public ArrayList<ReminderEntry> mReminders; |
RoboErik | 7f078b7 | 2011-09-06 10:25:31 -0700 | [diff] [blame] | 391 | public ArrayList<ReminderEntry> mOriginalReminders = new ArrayList<ReminderEntry>(); |
| 392 | public ArrayList<ReminderEntry> mUnsupportedReminders = new ArrayList<ReminderEntry>(); |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 393 | private boolean mUserModifiedReminders = false; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 394 | |
| 395 | /** |
| 396 | * Contents of the "minutes" spinner. This has default values from the XML file, augmented |
| 397 | * with any additional values that were already associated with the event. |
| 398 | */ |
| 399 | private ArrayList<Integer> mReminderMinuteValues; |
| 400 | private ArrayList<String> mReminderMinuteLabels; |
| 401 | |
| 402 | /** |
| 403 | * Contents of the "methods" spinner. The "values" list specifies the method constant |
| 404 | * (e.g. {@link Reminders#METHOD_ALERT}) associated with the labels. Any methods that |
| 405 | * aren't allowed by the Calendar will be removed. |
| 406 | */ |
| 407 | private ArrayList<Integer> mReminderMethodValues; |
| 408 | private ArrayList<String> mReminderMethodLabels; |
| 409 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 410 | private QueryHandler mHandler; |
| 411 | |
Isaac Katzenelson | b33cdf4 | 2011-10-14 18:15:18 -0700 | [diff] [blame] | 412 | |
Isaac Katzenelson | ac4350b | 2012-04-18 15:33:26 -0700 | [diff] [blame] | 413 | private final Runnable mTZUpdater = new Runnable() { |
Erik | cb81189 | 2010-09-28 13:44:19 -0700 | [diff] [blame] | 414 | @Override |
| 415 | public void run() { |
| 416 | updateEvent(mView); |
| 417 | } |
| 418 | }; |
| 419 | |
Isaac Katzenelson | ac4350b | 2012-04-18 15:33:26 -0700 | [diff] [blame] | 420 | private final Runnable mLoadingMsgAlphaUpdater = new Runnable() { |
Isaac Katzenelson | 263b029 | 2012-03-14 14:55:50 -0700 | [diff] [blame] | 421 | @Override |
| 422 | public void run() { |
| 423 | // Since this is run after a delay, make sure to only show the message |
| 424 | // if the event's data is not shown yet. |
| 425 | if (!mAnimateAlpha.isRunning() && mScrollView.getAlpha() == 0) { |
| 426 | mLoadingMsgStartTime = System.currentTimeMillis(); |
| 427 | mLoadingMsgView.setAlpha(1); |
| 428 | } |
| 429 | } |
| 430 | }; |
| 431 | |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 432 | private OnItemSelectedListener mReminderChangeListener; |
| 433 | |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 434 | private static int mDialogWidth = 500; |
| 435 | private static int mDialogHeight = 600; |
Isaac Katzenelson | 0aa0c61 | 2011-10-03 16:46:10 -0700 | [diff] [blame] | 436 | private static int DIALOG_TOP_MARGIN = 8; |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 437 | private boolean mIsDialog = false; |
RoboErik | 7c6236d | 2011-02-24 16:41:18 -0800 | [diff] [blame] | 438 | private boolean mIsPaused = true; |
| 439 | private boolean mDismissOnResume = false; |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 440 | private int mX = -1; |
| 441 | private int mY = -1; |
Isaac Katzenelson | 0aa0c61 | 2011-10-03 16:46:10 -0700 | [diff] [blame] | 442 | private int mMinTop; // Dialog cannot be above this location |
Isaac Katzenelson | 10b6021 | 2011-06-28 17:59:14 -0700 | [diff] [blame] | 443 | private boolean mIsTabletConfig; |
| 444 | private Activity mActivity; |
Michael Chan | be2a432 | 2011-08-11 13:39:14 -0700 | [diff] [blame] | 445 | private Context mContext; |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 446 | |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 447 | private CalendarController mController; |
| 448 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 449 | private class QueryHandler extends AsyncQueryService { |
| 450 | public QueryHandler(Context context) { |
| 451 | super(context); |
| 452 | } |
| 453 | |
| 454 | @Override |
| 455 | protected void onQueryComplete(int token, Object cookie, Cursor cursor) { |
Mason Tang | 4003d1c | 2010-08-17 13:50:45 -0700 | [diff] [blame] | 456 | // if the activity is finishing, then close the cursor and return |
| 457 | final Activity activity = getActivity(); |
| 458 | if (activity == null || activity.isFinishing()) { |
Isaac Katzenelson | 47f6cc6 | 2012-06-28 18:56:16 -0700 | [diff] [blame] | 459 | if (cursor != null) { |
| 460 | cursor.close(); |
| 461 | } |
Mason Tang | 4003d1c | 2010-08-17 13:50:45 -0700 | [diff] [blame] | 462 | return; |
| 463 | } |
| 464 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 465 | switch (token) { |
| 466 | case TOKEN_QUERY_EVENT: |
| 467 | mEventCursor = Utils.matrixCursorFromCursor(cursor); |
| 468 | if (initEventCursor()) { |
| 469 | // The cursor is empty. This can happen if the event was |
| 470 | // deleted. |
| 471 | // FRAG_TODO we should no longer rely on Activity.finish() |
Mason Tang | 1df2ca6 | 2010-08-18 16:10:25 -0700 | [diff] [blame] | 472 | activity.finish(); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 473 | return; |
| 474 | } |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 475 | if (!mCalendarColorInitialized) { |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 476 | mCalendarColor = Utils.getDisplayColorFromColor( |
| 477 | mEventCursor.getInt(EVENT_INDEX_CALENDAR_COLOR)); |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 478 | mCalendarColorInitialized = true; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 479 | } |
| 480 | |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 481 | if (!mOriginalColorInitialized) { |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 482 | mOriginalColor = mEventCursor.isNull(EVENT_INDEX_EVENT_COLOR) |
| 483 | ? mCalendarColor : Utils.getDisplayColorFromColor( |
| 484 | mEventCursor.getInt(EVENT_INDEX_EVENT_COLOR)); |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 485 | mOriginalColorInitialized = true; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 486 | } |
| 487 | |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 488 | if (!mCurrentColorInitialized) { |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 489 | mCurrentColor = mOriginalColor; |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 490 | mCurrentColorInitialized = true; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 491 | } |
| 492 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 493 | updateEvent(mView); |
RoboErik | e35a032 | 2011-09-01 16:21:49 -0700 | [diff] [blame] | 494 | prepareReminders(); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 495 | |
| 496 | // start calendar query |
| 497 | Uri uri = Calendars.CONTENT_URI; |
| 498 | String[] args = new String[] { |
| 499 | Long.toString(mEventCursor.getLong(EVENT_INDEX_CALENDAR_ID))}; |
| 500 | startQuery(TOKEN_QUERY_CALENDARS, null, uri, CALENDARS_PROJECTION, |
| 501 | CALENDARS_WHERE, args, null); |
| 502 | break; |
| 503 | case TOKEN_QUERY_CALENDARS: |
| 504 | mCalendarsCursor = Utils.matrixCursorFromCursor(cursor); |
| 505 | updateCalendar(mView); |
Mason Tang | 4003d1c | 2010-08-17 13:50:45 -0700 | [diff] [blame] | 506 | // FRAG_TODO fragments shouldn't set the title anymore |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 507 | updateTitle(); |
| 508 | |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 509 | args = new String[] { |
| 510 | mCalendarsCursor.getString(CALENDARS_INDEX_ACCOUNT_NAME), |
| 511 | mCalendarsCursor.getString(CALENDARS_INDEX_ACCOUNT_TYPE) }; |
| 512 | uri = Colors.CONTENT_URI; |
| 513 | startQuery(TOKEN_QUERY_COLORS, null, uri, COLORS_PROJECTION, COLORS_WHERE, args, |
| 514 | null); |
| 515 | |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 516 | if (!mIsBusyFreeCalendar) { |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 517 | args = new String[] { Long.toString(mEventId) }; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 518 | |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 519 | // start attendees query |
| 520 | uri = Attendees.CONTENT_URI; |
| 521 | startQuery(TOKEN_QUERY_ATTENDEES, null, uri, ATTENDEES_PROJECTION, |
| 522 | ATTENDEES_WHERE, args, ATTENDEES_SORT_ORDER); |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 523 | } else { |
| 524 | sendAccessibilityEventIfQueryDone(TOKEN_QUERY_ATTENDEES); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 525 | } |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 526 | if (mHasAlarm) { |
| 527 | // start reminders query |
| 528 | args = new String[] { Long.toString(mEventId) }; |
| 529 | uri = Reminders.CONTENT_URI; |
| 530 | startQuery(TOKEN_QUERY_REMINDERS, null, uri, |
| 531 | REMINDERS_PROJECTION, REMINDERS_WHERE, args, null); |
| 532 | } else { |
| 533 | sendAccessibilityEventIfQueryDone(TOKEN_QUERY_REMINDERS); |
| 534 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 535 | break; |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 536 | case TOKEN_QUERY_COLORS: |
| 537 | ArrayList<Integer> colors = new ArrayList<Integer>(); |
| 538 | if (cursor.moveToFirst()) { |
| 539 | do |
| 540 | { |
| 541 | int colorKey = cursor.getInt(COLORS_INDEX_COLOR_KEY); |
| 542 | int rawColor = cursor.getInt(COLORS_INDEX_COLOR); |
| 543 | int displayColor = Utils.getDisplayColorFromColor(rawColor); |
James Kung | e134cd5 | 2013-02-13 11:33:49 -0800 | [diff] [blame] | 544 | mDisplayColorKeyMap.put(displayColor, colorKey); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 545 | colors.add(displayColor); |
| 546 | } while (cursor.moveToNext()); |
| 547 | } |
| 548 | cursor.close(); |
| 549 | Integer[] sortedColors = new Integer[colors.size()]; |
James Kung | e134cd5 | 2013-02-13 11:33:49 -0800 | [diff] [blame] | 550 | Arrays.sort(colors.toArray(sortedColors), new HsvColorComparator()); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 551 | mColors = new int[sortedColors.length]; |
| 552 | for (int i = 0; i < sortedColors.length; i++) { |
| 553 | mColors[i] = sortedColors[i].intValue(); |
| 554 | |
| 555 | float[] hsv = new float[3]; |
| 556 | Color.colorToHSV(mColors[i], hsv); |
James Kung | e134cd5 | 2013-02-13 11:33:49 -0800 | [diff] [blame] | 557 | if (DEBUG) { |
| 558 | Log.d("Color", "H:" + hsv[0] + ",S:" + hsv[1] + ",V:" + hsv[2]); |
| 559 | } |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 560 | } |
James Kung | 6090ba2 | 2013-04-03 13:00:49 -0700 | [diff] [blame] | 561 | if (mCanModifyCalendar) { |
| 562 | View button = mView.findViewById(R.id.change_color); |
| 563 | if (button != null && mColors.length > 0) { |
| 564 | button.setEnabled(true); |
| 565 | button.setVisibility(View.VISIBLE); |
| 566 | } |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 567 | } |
| 568 | updateMenu(); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 569 | break; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 570 | case TOKEN_QUERY_ATTENDEES: |
| 571 | mAttendeesCursor = Utils.matrixCursorFromCursor(cursor); |
| 572 | initAttendeesCursor(mView); |
| 573 | updateResponse(mView); |
| 574 | break; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 575 | case TOKEN_QUERY_REMINDERS: |
| 576 | mRemindersCursor = Utils.matrixCursorFromCursor(cursor); |
| 577 | initReminders(mView, mRemindersCursor); |
| 578 | break; |
Sara Ting | 6aad0ff | 2012-08-02 10:55:52 -0700 | [diff] [blame] | 579 | case TOKEN_QUERY_VISIBLE_CALENDARS: |
| 580 | if (cursor.getCount() > 1) { |
| 581 | // Start duplicate calendars query to detect whether to add the calendar |
| 582 | // email to the calendar owner display. |
| 583 | String displayName = mCalendarsCursor.getString(CALENDARS_INDEX_DISPLAY_NAME); |
| 584 | mHandler.startQuery(TOKEN_QUERY_DUPLICATE_CALENDARS, null, |
| 585 | Calendars.CONTENT_URI, CALENDARS_PROJECTION, |
| 586 | CALENDARS_DUPLICATE_NAME_WHERE, new String[] {displayName}, null); |
| 587 | } else { |
| 588 | // Don't need to display the calendar owner when there is only a single |
| 589 | // calendar. Skip the duplicate calendars query. |
| 590 | setVisibilityCommon(mView, R.id.calendar_container, View.GONE); |
| 591 | mCurrentQuery |= TOKEN_QUERY_DUPLICATE_CALENDARS; |
| 592 | } |
| 593 | break; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 594 | case TOKEN_QUERY_DUPLICATE_CALENDARS: |
Michael Chan | 71b221a | 2010-10-25 17:55:44 -0700 | [diff] [blame] | 595 | SpannableStringBuilder sb = new SpannableStringBuilder(); |
| 596 | |
Michael Chan | 71b221a | 2010-10-25 17:55:44 -0700 | [diff] [blame] | 597 | // Calendar display name |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 598 | String calendarName = mCalendarsCursor.getString(CALENDARS_INDEX_DISPLAY_NAME); |
Michael Chan | 71b221a | 2010-10-25 17:55:44 -0700 | [diff] [blame] | 599 | sb.append(calendarName); |
| 600 | |
| 601 | // Show email account if display name is not unique and |
| 602 | // display name != email |
| 603 | String email = mCalendarsCursor.getString(CALENDARS_INDEX_OWNER_ACCOUNT); |
Sara Ting | 6aad0ff | 2012-08-02 10:55:52 -0700 | [diff] [blame] | 604 | if (cursor.getCount() > 1 && !calendarName.equalsIgnoreCase(email) && |
| 605 | Utils.isValidEmail(email)) { |
Michael Chan | 71b221a | 2010-10-25 17:55:44 -0700 | [diff] [blame] | 606 | sb.append(" (").append(email).append(")"); |
| 607 | } |
| 608 | |
Sara Ting | 6aad0ff | 2012-08-02 10:55:52 -0700 | [diff] [blame] | 609 | setVisibilityCommon(mView, R.id.calendar_container, View.VISIBLE); |
| 610 | setTextCommon(mView, R.id.calendar_name, sb); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 611 | break; |
| 612 | } |
| 613 | cursor.close(); |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 614 | sendAccessibilityEventIfQueryDone(token); |
Sara Ting | 6aad0ff | 2012-08-02 10:55:52 -0700 | [diff] [blame] | 615 | |
| 616 | // All queries are done, show the view. |
Isaac Katzenelson | 263b029 | 2012-03-14 14:55:50 -0700 | [diff] [blame] | 617 | if (mCurrentQuery == TOKEN_QUERY_ALL) { |
| 618 | if (mLoadingMsgView.getAlpha() == 1) { |
| 619 | // Loading message is showing, let it stay a bit more (to prevent |
| 620 | // flashing) by adding a start delay to the event animation |
| 621 | long timeDiff = LOADING_MSG_MIN_DISPLAY_TIME - (System.currentTimeMillis() - |
| 622 | mLoadingMsgStartTime); |
| 623 | if (timeDiff > 0) { |
| 624 | mAnimateAlpha.setStartDelay(timeDiff); |
| 625 | } |
| 626 | } |
Isaac Katzenelson | 80d640f | 2012-04-20 09:21:28 -0700 | [diff] [blame] | 627 | if (!mAnimateAlpha.isRunning() &&!mAnimateAlpha.isStarted() && !mNoCrossFade) { |
| 628 | mAnimateAlpha.start(); |
| 629 | } else { |
| 630 | mScrollView.setAlpha(1); |
| 631 | mLoadingMsgView.setVisibility(View.GONE); |
| 632 | } |
Isaac Katzenelson | 263b029 | 2012-03-14 14:55:50 -0700 | [diff] [blame] | 633 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 634 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 635 | } |
| 636 | |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 637 | private void sendAccessibilityEventIfQueryDone(int token) { |
| 638 | mCurrentQuery |= token; |
| 639 | if (mCurrentQuery == TOKEN_QUERY_ALL) { |
| 640 | sendAccessibilityEvent(); |
| 641 | } |
| 642 | } |
| 643 | |
Michael Chan | 0a01fd3 | 2011-01-23 15:13:28 -0800 | [diff] [blame] | 644 | public EventInfoFragment(Context context, Uri uri, long startMillis, long endMillis, |
Sam Blitzstein | 94a1f1a | 2013-02-12 15:16:35 -0800 | [diff] [blame] | 645 | int attendeeResponse, boolean isDialog, int windowStyle, |
| 646 | ArrayList<ReminderEntry> reminders) { |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 647 | |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 648 | Resources r = context.getResources(); |
| 649 | if (mScale == 0) { |
| 650 | mScale = context.getResources().getDisplayMetrics().density; |
| 651 | if (mScale != 1) { |
| 652 | mCustomAppIconSize *= mScale; |
| 653 | if (isDialog) { |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 654 | DIALOG_TOP_MARGIN *= mScale; |
| 655 | } |
Michael Chan | 0a01fd3 | 2011-01-23 15:13:28 -0800 | [diff] [blame] | 656 | } |
| 657 | } |
Michael Chan | 363aa9c | 2012-05-17 10:31:32 -0700 | [diff] [blame] | 658 | if (isDialog) { |
| 659 | setDialogSize(r); |
| 660 | } |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 661 | mIsDialog = isDialog; |
Isaac Katzenelson | c0624ee | 2011-06-03 09:24:27 -0700 | [diff] [blame] | 662 | |
Michael Chan | 2fc6b79 | 2011-01-26 17:12:44 -0800 | [diff] [blame] | 663 | setStyle(DialogFragment.STYLE_NO_TITLE, 0); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 664 | mUri = uri; |
| 665 | mStartMillis = startMillis; |
| 666 | mEndMillis = endMillis; |
| 667 | mAttendeeResponseFromIntent = attendeeResponse; |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 668 | mWindowStyle = windowStyle; |
Sam Blitzstein | 94a1f1a | 2013-02-12 15:16:35 -0800 | [diff] [blame] | 669 | |
| 670 | // Pass in null if no reminders are being specified. |
| 671 | // This may be used to explicitly show certain reminders already known |
| 672 | // about, such as during configuration changes. |
| 673 | mReminders = reminders; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 674 | } |
| 675 | |
Andy McFadden | ef31a98 | 2011-06-09 07:38:56 -0700 | [diff] [blame] | 676 | // This is currently required by the fragment manager. |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 677 | public EventInfoFragment() { |
| 678 | } |
| 679 | |
Michael Chan | 0a01fd3 | 2011-01-23 15:13:28 -0800 | [diff] [blame] | 680 | public EventInfoFragment(Context context, long eventId, long startMillis, long endMillis, |
Sam Blitzstein | 94a1f1a | 2013-02-12 15:16:35 -0800 | [diff] [blame] | 681 | int attendeeResponse, boolean isDialog, int windowStyle, |
| 682 | ArrayList<ReminderEntry> reminders) { |
Michael Chan | 0a01fd3 | 2011-01-23 15:13:28 -0800 | [diff] [blame] | 683 | this(context, ContentUris.withAppendedId(Events.CONTENT_URI, eventId), startMillis, |
Sam Blitzstein | 94a1f1a | 2013-02-12 15:16:35 -0800 | [diff] [blame] | 684 | endMillis, attendeeResponse, isDialog, windowStyle, reminders); |
Mason Tang | 4003d1c | 2010-08-17 13:50:45 -0700 | [diff] [blame] | 685 | mEventId = eventId; |
| 686 | } |
| 687 | |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 688 | @Override |
| 689 | public void onActivityCreated(Bundle savedInstanceState) { |
| 690 | super.onActivityCreated(savedInstanceState); |
| 691 | |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 692 | mReminderChangeListener = new OnItemSelectedListener() { |
| 693 | @Override |
| 694 | public void onItemSelected(AdapterView<?> parent, View view, int position, long id) { |
| 695 | Integer prevValue = (Integer) parent.getTag(); |
| 696 | if (prevValue == null || prevValue != position) { |
| 697 | parent.setTag(position); |
| 698 | mUserModifiedReminders = true; |
| 699 | } |
| 700 | } |
| 701 | |
| 702 | @Override |
| 703 | public void onNothingSelected(AdapterView<?> parent) { |
| 704 | // do nothing |
| 705 | } |
| 706 | |
| 707 | }; |
| 708 | |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 709 | if (savedInstanceState != null) { |
| 710 | mIsDialog = savedInstanceState.getBoolean(BUNDLE_KEY_IS_DIALOG, false); |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 711 | mWindowStyle = savedInstanceState.getInt(BUNDLE_KEY_WINDOW_STYLE, |
| 712 | DIALOG_WINDOW_STYLE); |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 713 | } |
| 714 | |
| 715 | if (mIsDialog) { |
| 716 | applyDialogParams(); |
| 717 | } |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 718 | |
| 719 | final Activity activity = getActivity(); |
| 720 | mContext = activity; |
| 721 | mColorPickerDialog = (EventColorPickerDialog) activity.getFragmentManager() |
| 722 | .findFragmentByTag(COLOR_PICKER_DIALOG_TAG); |
| 723 | if (mColorPickerDialog != null) { |
| 724 | mColorPickerDialog.setOnColorSelectedListener(this); |
| 725 | } |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 726 | } |
| 727 | |
| 728 | private void applyDialogParams() { |
| 729 | Dialog dialog = getDialog(); |
| 730 | dialog.setCanceledOnTouchOutside(true); |
| 731 | |
| 732 | Window window = dialog.getWindow(); |
| 733 | window.addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND); |
| 734 | |
| 735 | WindowManager.LayoutParams a = window.getAttributes(); |
| 736 | a.dimAmount = .4f; |
| 737 | |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 738 | a.width = mDialogWidth; |
| 739 | a.height = mDialogHeight; |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 740 | |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 741 | |
Isaac Katzenelson | 0b1bd10 | 2011-04-07 14:26:29 -0700 | [diff] [blame] | 742 | // On tablets , do smart positioning of dialog |
| 743 | // On phones , use the whole screen |
| 744 | |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 745 | if (mX != -1 || mY != -1) { |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 746 | a.x = mX - mDialogWidth / 2; |
| 747 | a.y = mY - mDialogHeight / 2; |
Isaac Katzenelson | 0aa0c61 | 2011-10-03 16:46:10 -0700 | [diff] [blame] | 748 | if (a.y < mMinTop) { |
| 749 | a.y = mMinTop + DIALOG_TOP_MARGIN; |
Isaac Katzenelson | 0b1bd10 | 2011-04-07 14:26:29 -0700 | [diff] [blame] | 750 | } |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 751 | a.gravity = Gravity.LEFT | Gravity.TOP; |
Isaac Katzenelson | 0b1bd10 | 2011-04-07 14:26:29 -0700 | [diff] [blame] | 752 | } |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 753 | window.setAttributes(a); |
| 754 | } |
| 755 | |
Isaac Katzenelson | 0aa0c61 | 2011-10-03 16:46:10 -0700 | [diff] [blame] | 756 | public void setDialogParams(int x, int y, int minTop) { |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 757 | mX = x; |
| 758 | mY = y; |
Isaac Katzenelson | 0aa0c61 | 2011-10-03 16:46:10 -0700 | [diff] [blame] | 759 | mMinTop = minTop; |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 760 | } |
| 761 | |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 762 | // Implements OnCheckedChangeListener |
| 763 | @Override |
| 764 | public void onCheckedChanged(RadioGroup group, int checkedId) { |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 765 | // If we haven't finished the return from the dialog yet, don't display. |
| 766 | if (mTentativeUserSetResponse != Attendees.ATTENDEE_STATUS_NONE) { |
| 767 | return; |
| 768 | } |
| 769 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 770 | // If this is not a repeating event, then don't display the dialog |
| 771 | // asking which events to change. |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 772 | int response = getResponseFromButtonId(checkedId); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 773 | if (!mIsRepeating) { |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 774 | mUserSetResponse = response; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 775 | return; |
| 776 | } |
| 777 | |
| 778 | // If the selection is the same as the original, then don't display the |
| 779 | // dialog asking which events to change. |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 780 | if (checkedId == findButtonIdForResponse(mOriginalAttendeeResponse)) { |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 781 | mUserSetResponse = response; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 782 | return; |
| 783 | } |
| 784 | |
| 785 | // This is a repeating event. We need to ask the user if they mean to |
| 786 | // change just this one instance or all instances. |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 787 | mTentativeUserSetResponse = response; |
| 788 | mEditResponseHelper.showDialog(mWhichEvents); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 789 | } |
| 790 | |
| 791 | public void onNothingSelected(AdapterView<?> parent) { |
| 792 | } |
| 793 | |
| 794 | @Override |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 795 | public void onDetach() { |
| 796 | super.onDetach(); |
| 797 | mController.deregisterEventHandler(R.layout.event_info); |
| 798 | } |
| 799 | |
| 800 | @Override |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 801 | public void onAttach(Activity activity) { |
| 802 | super.onAttach(activity); |
Isaac Katzenelson | 10b6021 | 2011-06-28 17:59:14 -0700 | [diff] [blame] | 803 | mActivity = activity; |
James Kung | 1dadfa2 | 2013-04-11 19:22:41 -0700 | [diff] [blame] | 804 | // Ensure that mIsTabletConfig is set before creating the menu. |
James Kung | 0054412 | 2013-04-15 12:15:22 -0700 | [diff] [blame] | 805 | mIsTabletConfig = Utils.getConfigBool(mActivity, R.bool.tablet_config); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 806 | mController = CalendarController.getInstance(mActivity); |
| 807 | mController.registerEventHandler(R.layout.event_info, this); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 808 | mEditResponseHelper = new EditResponseHelper(activity); |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 809 | mEditResponseHelper.setDismissListener( |
| 810 | new DialogInterface.OnDismissListener() { |
| 811 | @Override |
| 812 | public void onDismiss(DialogInterface dialog) { |
| 813 | // If the user dismisses the dialog (without hitting OK), |
| 814 | // then we want to revert the selection that opened the dialog. |
| 815 | if (mEditResponseHelper.getWhichEvents() != -1) { |
| 816 | mUserSetResponse = mTentativeUserSetResponse; |
| 817 | mWhichEvents = mEditResponseHelper.getWhichEvents(); |
| 818 | } else { |
| 819 | // Revert the attending response radio selection to whatever |
| 820 | // was selected prior to this selection (possibly nothing). |
| 821 | int oldResponse; |
| 822 | if (mUserSetResponse != Attendees.ATTENDEE_STATUS_NONE) { |
| 823 | oldResponse = mUserSetResponse; |
| 824 | } else { |
| 825 | oldResponse = mOriginalAttendeeResponse; |
| 826 | } |
| 827 | int buttonToCheck = findButtonIdForResponse(oldResponse); |
| 828 | |
| 829 | if (mResponseRadioGroup != null) { |
| 830 | mResponseRadioGroup.check(buttonToCheck); |
| 831 | } |
| 832 | |
| 833 | // If the radio group is being cleared, also clear the |
| 834 | // dialog's selection of which events should be included |
| 835 | // in this response. |
| 836 | if (buttonToCheck == -1) { |
| 837 | mEditResponseHelper.setWhichEvents(-1); |
| 838 | } |
| 839 | } |
| 840 | |
| 841 | // Since OnPause will force the dialog to dismiss, do |
| 842 | // not change the dialog status |
| 843 | if (!mIsPaused) { |
| 844 | mTentativeUserSetResponse = Attendees.ATTENDEE_STATUS_NONE; |
| 845 | } |
| 846 | } |
| 847 | }); |
RoboErik | 86550ce | 2011-08-22 16:47:51 -0700 | [diff] [blame] | 848 | |
| 849 | if (mAttendeeResponseFromIntent != Attendees.ATTENDEE_STATUS_NONE) { |
| 850 | mEditResponseHelper.setWhichEvents(UPDATE_ALL); |
James Kung | 9626716 | 2013-05-01 11:42:57 -0700 | [diff] [blame] | 851 | mWhichEvents = mEditResponseHelper.getWhichEvents(); |
RoboErik | 86550ce | 2011-08-22 16:47:51 -0700 | [diff] [blame] | 852 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 853 | mHandler = new QueryHandler(activity); |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 854 | if (!mIsDialog) { |
| 855 | setHasOptionsMenu(true); |
| 856 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 857 | } |
| 858 | |
| 859 | @Override |
| 860 | public View onCreateView(LayoutInflater inflater, ViewGroup container, |
| 861 | Bundle savedInstanceState) { |
Isaac Katzenelson | 320c1b1 | 2011-11-07 15:31:45 -0800 | [diff] [blame] | 862 | |
| 863 | if (savedInstanceState != null) { |
| 864 | mIsDialog = savedInstanceState.getBoolean(BUNDLE_KEY_IS_DIALOG, false); |
| 865 | mWindowStyle = savedInstanceState.getInt(BUNDLE_KEY_WINDOW_STYLE, |
| 866 | DIALOG_WINDOW_STYLE); |
| 867 | mDeleteDialogVisible = |
| 868 | savedInstanceState.getBoolean(BUNDLE_KEY_DELETE_DIALOG_VISIBLE,false); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 869 | mCalendarColor = savedInstanceState.getInt(BUNDLE_KEY_CALENDAR_COLOR); |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 870 | mCalendarColorInitialized = |
| 871 | savedInstanceState.getBoolean(BUNDLE_KEY_CALENDAR_COLOR_INIT); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 872 | mOriginalColor = savedInstanceState.getInt(BUNDLE_KEY_ORIGINAL_COLOR); |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 873 | mOriginalColorInitialized = savedInstanceState.getBoolean( |
| 874 | BUNDLE_KEY_ORIGINAL_COLOR_INIT); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 875 | mCurrentColor = savedInstanceState.getInt(BUNDLE_KEY_CURRENT_COLOR); |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 876 | mCurrentColorInitialized = savedInstanceState.getBoolean( |
| 877 | BUNDLE_KEY_CURRENT_COLOR_INIT); |
James Kung | 497a625 | 2013-05-17 14:47:33 -0700 | [diff] [blame^] | 878 | mCurrentColorKey = savedInstanceState.getInt(BUNDLE_KEY_CURRENT_COLOR_KEY); |
Sam Blitzstein | 94a1f1a | 2013-02-12 15:16:35 -0800 | [diff] [blame] | 879 | |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 880 | mTentativeUserSetResponse = savedInstanceState.getInt( |
| 881 | BUNDLE_KEY_TENTATIVE_USER_RESPONSE, |
| 882 | Attendees.ATTENDEE_STATUS_NONE); |
| 883 | if (mTentativeUserSetResponse != Attendees.ATTENDEE_STATUS_NONE && |
| 884 | mEditResponseHelper != null) { |
| 885 | // If the edit response helper dialog is open, we'll need to |
| 886 | // know if either of the choices were selected. |
| 887 | mEditResponseHelper.setWhichEvents(savedInstanceState.getInt( |
| 888 | BUNDLE_KEY_RESPONSE_WHICH_EVENTS, -1)); |
| 889 | } |
Sam Blitzstein | 94a1f1a | 2013-02-12 15:16:35 -0800 | [diff] [blame] | 890 | mUserSetResponse = savedInstanceState.getInt( |
| 891 | BUNDLE_KEY_USER_SET_ATTENDEE_RESPONSE, |
| 892 | Attendees.ATTENDEE_STATUS_NONE); |
| 893 | if (mUserSetResponse != Attendees.ATTENDEE_STATUS_NONE) { |
| 894 | // If the response was set by the user before a configuration |
| 895 | // change, we'll need to know which choice was selected. |
| 896 | mWhichEvents = savedInstanceState.getInt( |
| 897 | BUNDLE_KEY_RESPONSE_WHICH_EVENTS, -1); |
| 898 | } |
| 899 | |
| 900 | mReminders = Utils.readRemindersFromBundle(savedInstanceState); |
Isaac Katzenelson | 320c1b1 | 2011-11-07 15:31:45 -0800 | [diff] [blame] | 901 | } |
| 902 | |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 903 | if (mWindowStyle == DIALOG_WINDOW_STYLE) { |
Michael Chan | cba7f1f | 2011-11-07 17:05:59 -0800 | [diff] [blame] | 904 | mView = inflater.inflate(R.layout.event_info_dialog, container, false); |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 905 | } else { |
| 906 | mView = inflater.inflate(R.layout.event_info, container, false); |
| 907 | } |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 908 | mScrollView = (ScrollView) mView.findViewById(R.id.event_info_scroll_view); |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 909 | mLoadingMsgView = mView.findViewById(R.id.event_info_loading_msg); |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 910 | mTitle = (TextView) mView.findViewById(R.id.title); |
Sara Ting | 75f5366 | 2012-04-09 15:37:10 -0700 | [diff] [blame] | 911 | mWhenDateTime = (TextView) mView.findViewById(R.id.when_datetime); |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 912 | mWhere = (TextView) mView.findViewById(R.id.where); |
Michael Chan | 99704a2 | 2011-11-11 10:24:37 -0800 | [diff] [blame] | 913 | mDesc = (ExpandableTextView) mView.findViewById(R.id.description); |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 914 | mHeadlines = mView.findViewById(R.id.event_info_headline); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 915 | mLongAttendees = (AttendeesView) mView.findViewById(R.id.long_attendee_list); |
| 916 | |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 917 | mResponseRadioGroup = (RadioGroup) mView.findViewById(R.id.response_value); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 918 | |
Mason Tang | 4003d1c | 2010-08-17 13:50:45 -0700 | [diff] [blame] | 919 | if (mUri == null) { |
| 920 | // restore event ID from bundle |
| 921 | mEventId = savedInstanceState.getLong(BUNDLE_KEY_EVENT_ID); |
| 922 | mUri = ContentUris.withAppendedId(Events.CONTENT_URI, mEventId); |
| 923 | mStartMillis = savedInstanceState.getLong(BUNDLE_KEY_START_MILLIS); |
| 924 | mEndMillis = savedInstanceState.getLong(BUNDLE_KEY_END_MILLIS); |
| 925 | } |
| 926 | |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 927 | mAnimateAlpha = ObjectAnimator.ofFloat(mScrollView, "Alpha", 0, 1); |
| 928 | mAnimateAlpha.setDuration(FADE_IN_TIME); |
| 929 | mAnimateAlpha.addListener(new AnimatorListenerAdapter() { |
| 930 | int defLayerType; |
| 931 | |
| 932 | @Override |
| 933 | public void onAnimationStart(Animator animation) { |
| 934 | // Use hardware layer for better performance during animation |
| 935 | defLayerType = mScrollView.getLayerType(); |
| 936 | mScrollView.setLayerType(View.LAYER_TYPE_HARDWARE, null); |
| 937 | // Ensure that the loading message is gone before showing the |
| 938 | // event info |
Isaac Katzenelson | 263b029 | 2012-03-14 14:55:50 -0700 | [diff] [blame] | 939 | mLoadingMsgView.removeCallbacks(mLoadingMsgAlphaUpdater); |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 940 | mLoadingMsgView.setVisibility(View.GONE); |
| 941 | } |
| 942 | |
| 943 | @Override |
| 944 | public void onAnimationCancel(Animator animation) { |
| 945 | mScrollView.setLayerType(defLayerType, null); |
| 946 | } |
| 947 | |
| 948 | @Override |
| 949 | public void onAnimationEnd(Animator animation) { |
| 950 | mScrollView.setLayerType(defLayerType, null); |
Isaac Katzenelson | 80d640f | 2012-04-20 09:21:28 -0700 | [diff] [blame] | 951 | // Do not cross fade after the first time |
| 952 | mNoCrossFade = true; |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 953 | } |
| 954 | }); |
| 955 | |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 956 | mLoadingMsgView.setAlpha(0); |
| 957 | mScrollView.setAlpha(0); |
Isaac Katzenelson | 263b029 | 2012-03-14 14:55:50 -0700 | [diff] [blame] | 958 | mLoadingMsgView.postDelayed(mLoadingMsgAlphaUpdater, LOADING_MSG_DELAY); |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 959 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 960 | // start loading the data |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 961 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 962 | mHandler.startQuery(TOKEN_QUERY_EVENT, null, mUri, EVENT_PROJECTION, |
| 963 | null, null, null); |
| 964 | |
Isaac Katzenelson | d4e45fa | 2012-06-04 16:38:11 -0700 | [diff] [blame] | 965 | View b = mView.findViewById(R.id.delete); |
Michael Chan | 8ce3b7d | 2010-09-01 15:41:01 -0700 | [diff] [blame] | 966 | b.setOnClickListener(new OnClickListener() { |
| 967 | @Override |
| 968 | public void onClick(View v) { |
RoboErik | 69be855 | 2011-02-14 16:51:59 -0800 | [diff] [blame] | 969 | if (!mCanModifyCalendar) { |
| 970 | return; |
| 971 | } |
Isaac Katzenelson | d4e45fa | 2012-06-04 16:38:11 -0700 | [diff] [blame] | 972 | mDeleteHelper = |
| 973 | new DeleteEventHelper(mContext, mActivity, !mIsDialog && !mIsTabletConfig /* exitWhenDone */); |
Isaac Katzenelson | b0a313a | 2011-10-24 11:41:56 -0700 | [diff] [blame] | 974 | mDeleteHelper.setDeleteNotificationListener(EventInfoFragment.this); |
| 975 | mDeleteHelper.setOnDismissListener(createDeleteOnDismissListener()); |
| 976 | mDeleteDialogVisible = true; |
| 977 | mDeleteHelper.delete(mStartMillis, mEndMillis, mEventId, -1, onDeleteRunnable); |
Isaac Katzenelson | d4e45fa | 2012-06-04 16:38:11 -0700 | [diff] [blame] | 978 | } |
| 979 | }); |
Michael Chan | 8ce3b7d | 2010-09-01 15:41:01 -0700 | [diff] [blame] | 980 | |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 981 | b = mView.findViewById(R.id.change_color); |
| 982 | b.setOnClickListener(new OnClickListener() { |
| 983 | @Override |
| 984 | public void onClick(View v) { |
| 985 | if (!mCanModifyCalendar) { |
| 986 | return; |
| 987 | } |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 988 | showEventColorPickerDialog(); |
| 989 | } |
| 990 | }); |
| 991 | |
Isaac Katzenelson | 10b6021 | 2011-06-28 17:59:14 -0700 | [diff] [blame] | 992 | // Hide Edit/Delete buttons if in full screen mode on a phone |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 993 | if (!mIsDialog && !mIsTabletConfig || mWindowStyle == EventInfoFragment.FULL_WINDOW_STYLE) { |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 994 | mView.findViewById(R.id.event_info_buttons_container).setVisibility(View.GONE); |
| 995 | } |
| 996 | |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 997 | // Create a listener for the email guests button |
Sara Ting | 7ffa24c | 2012-08-28 15:44:37 -0700 | [diff] [blame] | 998 | emailAttendeesButton = (Button) mView.findViewById(R.id.email_attendees_button); |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 999 | if (emailAttendeesButton != null) { |
| 1000 | emailAttendeesButton.setOnClickListener(new View.OnClickListener() { |
| 1001 | @Override |
| 1002 | public void onClick(View v) { |
| 1003 | emailAttendees(); |
| 1004 | } |
| 1005 | }); |
| 1006 | } |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1007 | |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 1008 | // Create a listener for the add reminder button |
Michael Chan | b20942b | 2011-09-08 00:52:18 -0700 | [diff] [blame] | 1009 | View reminderAddButton = mView.findViewById(R.id.reminder_add); |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1010 | View.OnClickListener addReminderOnClickListener = new View.OnClickListener() { |
| 1011 | @Override |
| 1012 | public void onClick(View v) { |
| 1013 | addReminder(); |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 1014 | mUserModifiedReminders = true; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1015 | } |
| 1016 | }; |
| 1017 | reminderAddButton.setOnClickListener(addReminderOnClickListener); |
| 1018 | |
| 1019 | // Set reminders variables |
| 1020 | |
| 1021 | SharedPreferences prefs = GeneralPreferences.getSharedPreferences(mActivity); |
| 1022 | String defaultReminderString = prefs.getString( |
| 1023 | GeneralPreferences.KEY_DEFAULT_REMINDER, GeneralPreferences.NO_REMINDER_STRING); |
| 1024 | mDefaultReminderMinutes = Integer.parseInt(defaultReminderString); |
| 1025 | prepareReminders(); |
| 1026 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1027 | return mView; |
| 1028 | } |
| 1029 | |
Isaac Katzenelson | ac4350b | 2012-04-18 15:33:26 -0700 | [diff] [blame] | 1030 | private final Runnable onDeleteRunnable = new Runnable() { |
Erik | 89ad082 | 2011-01-18 15:55:17 -0800 | [diff] [blame] | 1031 | @Override |
| 1032 | public void run() { |
RoboErik | 7c6236d | 2011-02-24 16:41:18 -0800 | [diff] [blame] | 1033 | if (EventInfoFragment.this.mIsPaused) { |
| 1034 | mDismissOnResume = true; |
| 1035 | return; |
| 1036 | } |
Erik | 89ad082 | 2011-01-18 15:55:17 -0800 | [diff] [blame] | 1037 | if (EventInfoFragment.this.isVisible()) { |
| 1038 | EventInfoFragment.this.dismiss(); |
| 1039 | } |
| 1040 | } |
| 1041 | }; |
| 1042 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1043 | private void updateTitle() { |
| 1044 | Resources res = getActivity().getResources(); |
| 1045 | if (mCanModifyCalendar && !mIsOrganizer) { |
| 1046 | getActivity().setTitle(res.getString(R.string.event_info_title_invite)); |
| 1047 | } else { |
| 1048 | getActivity().setTitle(res.getString(R.string.event_info_title)); |
| 1049 | } |
| 1050 | } |
| 1051 | |
| 1052 | /** |
| 1053 | * Initializes the event cursor, which is expected to point to the first |
| 1054 | * (and only) result from a query. |
| 1055 | * @return true if the cursor is empty. |
| 1056 | */ |
| 1057 | private boolean initEventCursor() { |
| 1058 | if ((mEventCursor == null) || (mEventCursor.getCount() == 0)) { |
| 1059 | return true; |
| 1060 | } |
| 1061 | mEventCursor.moveToFirst(); |
| 1062 | mEventId = mEventCursor.getInt(EVENT_INDEX_ID); |
| 1063 | String rRule = mEventCursor.getString(EVENT_INDEX_RRULE); |
Michael Chan | 66b2067 | 2010-12-20 13:50:28 -0800 | [diff] [blame] | 1064 | mIsRepeating = !TextUtils.isEmpty(rRule); |
Sam Blitzstein | 94a1f1a | 2013-02-12 15:16:35 -0800 | [diff] [blame] | 1065 | // mHasAlarm will be true if it was saved in the event already, or if |
| 1066 | // we've explicitly been provided reminders (e.g. during rotation). |
| 1067 | mHasAlarm = (mEventCursor.getInt(EVENT_INDEX_HAS_ALARM) == 1)? true : |
| 1068 | (mReminders != null && mReminders.size() > 0); |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1069 | mMaxReminders = mEventCursor.getInt(EVENT_INDEX_MAX_REMINDERS); |
| 1070 | mCalendarAllowedReminders = mEventCursor.getString(EVENT_INDEX_ALLOWED_REMINDERS); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1071 | return false; |
| 1072 | } |
| 1073 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1074 | @SuppressWarnings("fallthrough") |
| 1075 | private void initAttendeesCursor(View view) { |
Isaac Katzenelson | 6bcafcf | 2012-05-02 18:25:36 -0700 | [diff] [blame] | 1076 | mOriginalAttendeeResponse = Attendees.ATTENDEE_STATUS_NONE; |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 1077 | mCalendarOwnerAttendeeId = EditEventHelper.ATTENDEE_ID_NONE; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1078 | mNumOfAttendees = 0; |
| 1079 | if (mAttendeesCursor != null) { |
| 1080 | mNumOfAttendees = mAttendeesCursor.getCount(); |
| 1081 | if (mAttendeesCursor.moveToFirst()) { |
| 1082 | mAcceptedAttendees.clear(); |
| 1083 | mDeclinedAttendees.clear(); |
| 1084 | mTentativeAttendees.clear(); |
| 1085 | mNoResponseAttendees.clear(); |
| 1086 | |
| 1087 | do { |
| 1088 | int status = mAttendeesCursor.getInt(ATTENDEES_INDEX_STATUS); |
| 1089 | String name = mAttendeesCursor.getString(ATTENDEES_INDEX_NAME); |
| 1090 | String email = mAttendeesCursor.getString(ATTENDEES_INDEX_EMAIL); |
| 1091 | |
Michael Chan | 83efa2d | 2012-04-24 17:42:21 -0700 | [diff] [blame] | 1092 | if (mAttendeesCursor.getInt(ATTENDEES_INDEX_RELATIONSHIP) == |
| 1093 | Attendees.RELATIONSHIP_ORGANIZER) { |
| 1094 | |
| 1095 | // Overwrites the one from Event table if available |
| 1096 | if (!TextUtils.isEmpty(name)) { |
| 1097 | mEventOrganizerDisplayName = name; |
| 1098 | if (!mIsOrganizer) { |
| 1099 | setVisibilityCommon(view, R.id.organizer_container, View.VISIBLE); |
| 1100 | setTextCommon(view, R.id.organizer, mEventOrganizerDisplayName); |
| 1101 | } |
| 1102 | } |
| 1103 | } |
| 1104 | |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 1105 | if (mCalendarOwnerAttendeeId == EditEventHelper.ATTENDEE_ID_NONE && |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1106 | mCalendarOwnerAccount.equalsIgnoreCase(email)) { |
| 1107 | mCalendarOwnerAttendeeId = mAttendeesCursor.getInt(ATTENDEES_INDEX_ID); |
| 1108 | mOriginalAttendeeResponse = mAttendeesCursor.getInt(ATTENDEES_INDEX_STATUS); |
| 1109 | } else { |
Michael Chan | 693ca60 | 2012-05-31 12:24:11 -0700 | [diff] [blame] | 1110 | String identity = null; |
| 1111 | String idNamespace = null; |
| 1112 | |
Sara Ting | fac2d15 | 2012-05-31 14:59:57 -0700 | [diff] [blame] | 1113 | if (Utils.isJellybeanOrLater()) { |
Michael Chan | 693ca60 | 2012-05-31 12:24:11 -0700 | [diff] [blame] | 1114 | identity = mAttendeesCursor.getString(ATTENDEES_INDEX_IDENTITY); |
| 1115 | idNamespace = mAttendeesCursor.getString(ATTENDEES_INDEX_ID_NAMESPACE); |
| 1116 | } |
Sara Ting | ddbc002 | 2012-04-26 17:08:46 -0700 | [diff] [blame] | 1117 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1118 | // Don't show your own status in the list because: |
| 1119 | // 1) it doesn't make sense for event without other guests. |
| 1120 | // 2) there's a spinner for that for events with guests. |
| 1121 | switch(status) { |
| 1122 | case Attendees.ATTENDEE_STATUS_ACCEPTED: |
Isaac Katzenelson | fe25c50 | 2011-06-02 13:31:59 -0700 | [diff] [blame] | 1123 | mAcceptedAttendees.add(new Attendee(name, email, |
Sara Ting | ddbc002 | 2012-04-26 17:08:46 -0700 | [diff] [blame] | 1124 | Attendees.ATTENDEE_STATUS_ACCEPTED, identity, |
| 1125 | idNamespace)); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1126 | break; |
| 1127 | case Attendees.ATTENDEE_STATUS_DECLINED: |
Isaac Katzenelson | fe25c50 | 2011-06-02 13:31:59 -0700 | [diff] [blame] | 1128 | mDeclinedAttendees.add(new Attendee(name, email, |
Sara Ting | ddbc002 | 2012-04-26 17:08:46 -0700 | [diff] [blame] | 1129 | Attendees.ATTENDEE_STATUS_DECLINED, identity, |
| 1130 | idNamespace)); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1131 | break; |
Michael Chan | 8ce3b7d | 2010-09-01 15:41:01 -0700 | [diff] [blame] | 1132 | case Attendees.ATTENDEE_STATUS_TENTATIVE: |
Isaac Katzenelson | fe25c50 | 2011-06-02 13:31:59 -0700 | [diff] [blame] | 1133 | mTentativeAttendees.add(new Attendee(name, email, |
Sara Ting | ddbc002 | 2012-04-26 17:08:46 -0700 | [diff] [blame] | 1134 | Attendees.ATTENDEE_STATUS_TENTATIVE, identity, |
| 1135 | idNamespace)); |
Michael Chan | 8ce3b7d | 2010-09-01 15:41:01 -0700 | [diff] [blame] | 1136 | break; |
| 1137 | default: |
Isaac Katzenelson | fe25c50 | 2011-06-02 13:31:59 -0700 | [diff] [blame] | 1138 | mNoResponseAttendees.add(new Attendee(name, email, |
Sara Ting | ddbc002 | 2012-04-26 17:08:46 -0700 | [diff] [blame] | 1139 | Attendees.ATTENDEE_STATUS_NONE, identity, |
| 1140 | idNamespace)); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1141 | } |
| 1142 | } |
| 1143 | } while (mAttendeesCursor.moveToNext()); |
| 1144 | mAttendeesCursor.moveToFirst(); |
| 1145 | |
| 1146 | updateAttendees(view); |
| 1147 | } |
| 1148 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1149 | } |
| 1150 | |
| 1151 | @Override |
Mason Tang | 4003d1c | 2010-08-17 13:50:45 -0700 | [diff] [blame] | 1152 | public void onSaveInstanceState(Bundle outState) { |
| 1153 | super.onSaveInstanceState(outState); |
| 1154 | outState.putLong(BUNDLE_KEY_EVENT_ID, mEventId); |
| 1155 | outState.putLong(BUNDLE_KEY_START_MILLIS, mStartMillis); |
| 1156 | outState.putLong(BUNDLE_KEY_END_MILLIS, mEndMillis); |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 1157 | outState.putBoolean(BUNDLE_KEY_IS_DIALOG, mIsDialog); |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 1158 | outState.putInt(BUNDLE_KEY_WINDOW_STYLE, mWindowStyle); |
Isaac Katzenelson | b0a313a | 2011-10-24 11:41:56 -0700 | [diff] [blame] | 1159 | outState.putBoolean(BUNDLE_KEY_DELETE_DIALOG_VISIBLE, mDeleteDialogVisible); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1160 | outState.putInt(BUNDLE_KEY_CALENDAR_COLOR, mCalendarColor); |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 1161 | outState.putBoolean(BUNDLE_KEY_CALENDAR_COLOR_INIT, mCalendarColorInitialized); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1162 | outState.putInt(BUNDLE_KEY_ORIGINAL_COLOR, mOriginalColor); |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 1163 | outState.putBoolean(BUNDLE_KEY_ORIGINAL_COLOR_INIT, mOriginalColorInitialized); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1164 | outState.putInt(BUNDLE_KEY_CURRENT_COLOR, mCurrentColor); |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 1165 | outState.putBoolean(BUNDLE_KEY_CURRENT_COLOR_INIT, mCurrentColorInitialized); |
James Kung | 497a625 | 2013-05-17 14:47:33 -0700 | [diff] [blame^] | 1166 | outState.putInt(BUNDLE_KEY_CURRENT_COLOR_KEY, mCurrentColorKey); |
James Kung | f56b149 | 2013-03-07 15:10:13 -0800 | [diff] [blame] | 1167 | |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 1168 | // We'll need the temporary response for configuration changes. |
| 1169 | outState.putInt(BUNDLE_KEY_TENTATIVE_USER_RESPONSE, mTentativeUserSetResponse); |
| 1170 | if (mTentativeUserSetResponse != Attendees.ATTENDEE_STATUS_NONE && |
| 1171 | mEditResponseHelper != null) { |
| 1172 | outState.putInt(BUNDLE_KEY_RESPONSE_WHICH_EVENTS, |
| 1173 | mEditResponseHelper.getWhichEvents()); |
| 1174 | } |
Sam Blitzstein | 94a1f1a | 2013-02-12 15:16:35 -0800 | [diff] [blame] | 1175 | |
| 1176 | // Save the current response. |
| 1177 | int response; |
| 1178 | if (mAttendeeResponseFromIntent != Attendees.ATTENDEE_STATUS_NONE) { |
| 1179 | response = mAttendeeResponseFromIntent; |
| 1180 | } else { |
| 1181 | response = mOriginalAttendeeResponse; |
| 1182 | } |
| 1183 | outState.putInt(BUNDLE_KEY_ATTENDEE_RESPONSE, response); |
| 1184 | if (mUserSetResponse != Attendees.ATTENDEE_STATUS_NONE) { |
| 1185 | response = mUserSetResponse; |
| 1186 | outState.putInt(BUNDLE_KEY_USER_SET_ATTENDEE_RESPONSE, response); |
| 1187 | outState.putInt(BUNDLE_KEY_RESPONSE_WHICH_EVENTS, mWhichEvents); |
| 1188 | } |
| 1189 | |
| 1190 | // Save the reminders. |
| 1191 | mReminders = EventViewUtils.reminderItemsToReminders(mReminderViews, |
| 1192 | mReminderMinuteValues, mReminderMethodValues); |
| 1193 | int numReminders = mReminders.size(); |
| 1194 | ArrayList<Integer> reminderMinutes = |
| 1195 | new ArrayList<Integer>(numReminders); |
| 1196 | ArrayList<Integer> reminderMethods = |
| 1197 | new ArrayList<Integer>(numReminders); |
| 1198 | for (ReminderEntry reminder : mReminders) { |
| 1199 | reminderMinutes.add(reminder.getMinutes()); |
| 1200 | reminderMethods.add(reminder.getMethod()); |
| 1201 | } |
| 1202 | outState.putIntegerArrayList( |
| 1203 | BUNDLE_KEY_REMINDER_MINUTES, reminderMinutes); |
| 1204 | outState.putIntegerArrayList( |
| 1205 | BUNDLE_KEY_REMINDER_METHODS, reminderMethods); |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 1206 | } |
| 1207 | |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 1208 | @Override |
| 1209 | public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { |
| 1210 | super.onCreateOptionsMenu(menu, inflater); |
James Kung | 1dadfa2 | 2013-04-11 19:22:41 -0700 | [diff] [blame] | 1211 | // Show color/edit/delete buttons only in non-dialog configuration |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 1212 | if (!mIsDialog && !mIsTabletConfig || mWindowStyle == EventInfoFragment.FULL_WINDOW_STYLE) { |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 1213 | inflater.inflate(R.menu.event_info_title_bar, menu); |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 1214 | mMenu = menu; |
| 1215 | updateMenu(); |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 1216 | } |
Mason Tang | 4003d1c | 2010-08-17 13:50:45 -0700 | [diff] [blame] | 1217 | } |
| 1218 | |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 1219 | @Override |
| 1220 | public boolean onOptionsItemSelected(MenuItem item) { |
| 1221 | |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 1222 | // If we're a dialog we don't want to handle menu buttons |
| 1223 | if (mIsDialog) { |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 1224 | return false; |
| 1225 | } |
| 1226 | // Handles option menu selections: |
| 1227 | // Home button - close event info activity and start the main calendar |
| 1228 | // one |
| 1229 | // Edit button - start the event edit activity and close the info |
| 1230 | // activity |
| 1231 | // Delete button - start a delete query that calls a runnable that close |
| 1232 | // the info activity |
| 1233 | |
Michael Chan | bb6d927 | 2012-08-17 17:32:58 -0700 | [diff] [blame] | 1234 | final int itemId = item.getItemId(); |
| 1235 | if (itemId == android.R.id.home) { |
| 1236 | Utils.returnToCalendarHome(mContext); |
| 1237 | mActivity.finish(); |
| 1238 | return true; |
| 1239 | } else if (itemId == R.id.info_action_edit) { |
James Kung | 1d1b1e4 | 2013-03-06 19:49:23 -0800 | [diff] [blame] | 1240 | doEdit(); |
Michael Chan | bb6d927 | 2012-08-17 17:32:58 -0700 | [diff] [blame] | 1241 | mActivity.finish(); |
| 1242 | } else if (itemId == R.id.info_action_delete) { |
| 1243 | mDeleteHelper = |
| 1244 | new DeleteEventHelper(mActivity, mActivity, true /* exitWhenDone */); |
| 1245 | mDeleteHelper.setDeleteNotificationListener(EventInfoFragment.this); |
| 1246 | mDeleteHelper.setOnDismissListener(createDeleteOnDismissListener()); |
| 1247 | mDeleteDialogVisible = true; |
| 1248 | mDeleteHelper.delete(mStartMillis, mEndMillis, mEventId, -1, onDeleteRunnable); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1249 | } else if (itemId == R.id.info_action_change_color) { |
| 1250 | showEventColorPickerDialog(); |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 1251 | } |
| 1252 | return super.onOptionsItemSelected(item); |
| 1253 | } |
Mason Tang | 4003d1c | 2010-08-17 13:50:45 -0700 | [diff] [blame] | 1254 | |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1255 | private void showEventColorPickerDialog() { |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 1256 | if (mColorPickerDialog == null) { |
| 1257 | mColorPickerDialog = EventColorPickerDialog.newInstance(mColors, mCurrentColor, |
| 1258 | mCalendarColor, mIsTabletConfig); |
| 1259 | mColorPickerDialog.setOnColorSelectedListener(this); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1260 | } |
James Kung | 95e9538 | 2013-03-20 12:14:33 -0700 | [diff] [blame] | 1261 | final FragmentManager fragmentManager = getFragmentManager(); |
| 1262 | fragmentManager.executePendingTransactions(); |
James Kung | 2fca024 | 2013-04-02 16:09:50 -0700 | [diff] [blame] | 1263 | if (!mColorPickerDialog.isAdded()) { |
| 1264 | mColorPickerDialog.show(fragmentManager, COLOR_PICKER_DIALOG_TAG); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1265 | } |
| 1266 | } |
| 1267 | |
| 1268 | private boolean saveEventColor() { |
| 1269 | if (mCurrentColor == mOriginalColor) { |
| 1270 | return false; |
| 1271 | } |
| 1272 | |
| 1273 | ContentValues values = new ContentValues(); |
| 1274 | if (mCurrentColor != mCalendarColor) { |
James Kung | 497a625 | 2013-05-17 14:47:33 -0700 | [diff] [blame^] | 1275 | values.put(Events.EVENT_COLOR_KEY, mCurrentColorKey); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1276 | } else { |
| 1277 | values.put(Events.EVENT_COLOR_KEY, NO_EVENT_COLOR); |
| 1278 | } |
| 1279 | Uri uri = ContentUris.withAppendedId(Events.CONTENT_URI, mEventId); |
| 1280 | mHandler.startUpdate(mHandler.getNextToken(), null, uri, values, |
| 1281 | null, null, Utils.UNDO_DELAY); |
| 1282 | return true; |
| 1283 | } |
| 1284 | |
Mason Tang | 4003d1c | 2010-08-17 13:50:45 -0700 | [diff] [blame] | 1285 | @Override |
Sam Blitzstein | 9d4a952 | 2012-10-17 14:39:38 -0700 | [diff] [blame] | 1286 | public void onStop() { |
| 1287 | Activity act = getActivity(); |
| 1288 | if (!mEventDeletionStarted && act != null && !act.isChangingConfigurations()) { |
James Kung | 497a625 | 2013-05-17 14:47:33 -0700 | [diff] [blame^] | 1289 | |
Isaac Katzenelson | ac4350b | 2012-04-18 15:33:26 -0700 | [diff] [blame] | 1290 | boolean responseSaved = saveResponse(); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1291 | boolean eventColorSaved = saveEventColor(); |
| 1292 | if (saveReminders() || responseSaved || eventColorSaved) { |
Isaac Katzenelson | b33cdf4 | 2011-10-14 18:15:18 -0700 | [diff] [blame] | 1293 | Toast.makeText(getActivity(), R.string.saving_event, Toast.LENGTH_SHORT).show(); |
| 1294 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1295 | } |
Sam Blitzstein | 9d4a952 | 2012-10-17 14:39:38 -0700 | [diff] [blame] | 1296 | super.onStop(); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1297 | } |
| 1298 | |
| 1299 | @Override |
| 1300 | public void onDestroy() { |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1301 | if (mEventCursor != null) { |
| 1302 | mEventCursor.close(); |
| 1303 | } |
| 1304 | if (mCalendarsCursor != null) { |
| 1305 | mCalendarsCursor.close(); |
| 1306 | } |
| 1307 | if (mAttendeesCursor != null) { |
| 1308 | mAttendeesCursor.close(); |
| 1309 | } |
Michael Chan | 71d0883 | 2010-08-25 18:28:59 -0700 | [diff] [blame] | 1310 | super.onDestroy(); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1311 | } |
| 1312 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1313 | /** |
| 1314 | * Asynchronously saves the response to an invitation if the user changed |
| 1315 | * the response. Returns true if the database will be updated. |
| 1316 | * |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1317 | * @return true if the database will be changed |
| 1318 | */ |
| 1319 | private boolean saveResponse() { |
| 1320 | if (mAttendeesCursor == null || mEventCursor == null) { |
| 1321 | return false; |
| 1322 | } |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 1323 | |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 1324 | int status = getResponseFromButtonId( |
| 1325 | mResponseRadioGroup.getCheckedRadioButtonId()); |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 1326 | if (status == Attendees.ATTENDEE_STATUS_NONE) { |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1327 | return false; |
| 1328 | } |
| 1329 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1330 | // If the status has not changed, then don't update the database |
| 1331 | if (status == mOriginalAttendeeResponse) { |
| 1332 | return false; |
| 1333 | } |
| 1334 | |
| 1335 | // If we never got an owner attendee id we can't set the status |
Erik | d845fbe | 2010-08-12 11:20:01 -0700 | [diff] [blame] | 1336 | if (mCalendarOwnerAttendeeId == EditEventHelper.ATTENDEE_ID_NONE) { |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1337 | return false; |
| 1338 | } |
| 1339 | |
| 1340 | if (!mIsRepeating) { |
| 1341 | // This is a non-repeating event |
| 1342 | updateResponse(mEventId, mCalendarOwnerAttendeeId, status); |
Sam Blitzstein | 9d4a952 | 2012-10-17 14:39:38 -0700 | [diff] [blame] | 1343 | mOriginalAttendeeResponse = status; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1344 | return true; |
| 1345 | } |
| 1346 | |
James Kung | 9626716 | 2013-05-01 11:42:57 -0700 | [diff] [blame] | 1347 | if (DEBUG) { |
| 1348 | Log.d(TAG, "Repeating event: mWhichEvents=" + mWhichEvents); |
| 1349 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1350 | // This is a repeating event |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 1351 | switch (mWhichEvents) { |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1352 | case -1: |
| 1353 | return false; |
| 1354 | case UPDATE_SINGLE: |
Andy McFadden | c928e3d | 2011-06-13 09:53:20 -0700 | [diff] [blame] | 1355 | createExceptionResponse(mEventId, status); |
Sam Blitzstein | 9d4a952 | 2012-10-17 14:39:38 -0700 | [diff] [blame] | 1356 | mOriginalAttendeeResponse = status; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1357 | return true; |
| 1358 | case UPDATE_ALL: |
| 1359 | updateResponse(mEventId, mCalendarOwnerAttendeeId, status); |
Sam Blitzstein | 9d4a952 | 2012-10-17 14:39:38 -0700 | [diff] [blame] | 1360 | mOriginalAttendeeResponse = status; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1361 | return true; |
| 1362 | default: |
| 1363 | Log.e(TAG, "Unexpected choice for updating invitation response"); |
| 1364 | break; |
| 1365 | } |
| 1366 | return false; |
| 1367 | } |
| 1368 | |
| 1369 | private void updateResponse(long eventId, long attendeeId, int status) { |
| 1370 | // Update the attendee status in the attendees table. the provider |
| 1371 | // takes care of updating the self attendance status. |
| 1372 | ContentValues values = new ContentValues(); |
| 1373 | |
| 1374 | if (!TextUtils.isEmpty(mCalendarOwnerAccount)) { |
| 1375 | values.put(Attendees.ATTENDEE_EMAIL, mCalendarOwnerAccount); |
| 1376 | } |
| 1377 | values.put(Attendees.ATTENDEE_STATUS, status); |
| 1378 | values.put(Attendees.EVENT_ID, eventId); |
| 1379 | |
| 1380 | Uri uri = ContentUris.withAppendedId(Attendees.CONTENT_URI, attendeeId); |
| 1381 | |
| 1382 | mHandler.startUpdate(mHandler.getNextToken(), null, uri, values, |
| 1383 | null, null, Utils.UNDO_DELAY); |
| 1384 | } |
| 1385 | |
Andy McFadden | c928e3d | 2011-06-13 09:53:20 -0700 | [diff] [blame] | 1386 | /** |
| 1387 | * Creates an exception to a recurring event. The only change we're making is to the |
| 1388 | * "self attendee status" value. The provider will take care of updating the corresponding |
| 1389 | * Attendees.attendeeStatus entry. |
| 1390 | * |
| 1391 | * @param eventId The recurring event. |
| 1392 | * @param status The new value for selfAttendeeStatus. |
| 1393 | */ |
| 1394 | private void createExceptionResponse(long eventId, int status) { |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1395 | ContentValues values = new ContentValues(); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1396 | values.put(Events.ORIGINAL_INSTANCE_TIME, mStartMillis); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1397 | values.put(Events.SELF_ATTENDEE_STATUS, status); |
Andy McFadden | c928e3d | 2011-06-13 09:53:20 -0700 | [diff] [blame] | 1398 | values.put(Events.STATUS, Events.STATUS_CONFIRMED); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1399 | |
Erik | 364309f | 2010-12-23 14:26:26 -0800 | [diff] [blame] | 1400 | ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>(); |
Andy McFadden | 79b2c8c | 2011-06-30 15:26:05 -0700 | [diff] [blame] | 1401 | Uri exceptionUri = Uri.withAppendedPath(Events.CONTENT_EXCEPTION_URI, |
Andy McFadden | c928e3d | 2011-06-13 09:53:20 -0700 | [diff] [blame] | 1402 | String.valueOf(eventId)); |
| 1403 | ops.add(ContentProviderOperation.newInsert(exceptionUri).withValues(values).build()); |
Erik | 364309f | 2010-12-23 14:26:26 -0800 | [diff] [blame] | 1404 | |
Andy McFadden | c928e3d | 2011-06-13 09:53:20 -0700 | [diff] [blame] | 1405 | mHandler.startBatch(mHandler.getNextToken(), null, CalendarContract.AUTHORITY, ops, |
| 1406 | Utils.UNDO_DELAY); |
| 1407 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1408 | |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 1409 | public static int getResponseFromButtonId(int buttonId) { |
| 1410 | int response; |
Michael Chan | bb6d927 | 2012-08-17 17:32:58 -0700 | [diff] [blame] | 1411 | if (buttonId == R.id.response_yes) { |
| 1412 | response = Attendees.ATTENDEE_STATUS_ACCEPTED; |
| 1413 | } else if (buttonId == R.id.response_maybe) { |
| 1414 | response = Attendees.ATTENDEE_STATUS_TENTATIVE; |
| 1415 | } else if (buttonId == R.id.response_no) { |
| 1416 | response = Attendees.ATTENDEE_STATUS_DECLINED; |
| 1417 | } else { |
| 1418 | response = Attendees.ATTENDEE_STATUS_NONE; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1419 | } |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 1420 | return response; |
| 1421 | } |
| 1422 | |
| 1423 | public static int findButtonIdForResponse(int response) { |
| 1424 | int buttonId; |
| 1425 | switch (response) { |
| 1426 | case Attendees.ATTENDEE_STATUS_ACCEPTED: |
| 1427 | buttonId = R.id.response_yes; |
| 1428 | break; |
| 1429 | case Attendees.ATTENDEE_STATUS_TENTATIVE: |
| 1430 | buttonId = R.id.response_maybe; |
| 1431 | break; |
| 1432 | case Attendees.ATTENDEE_STATUS_DECLINED: |
| 1433 | buttonId = R.id.response_no; |
| 1434 | break; |
| 1435 | default: |
| 1436 | buttonId = -1; |
| 1437 | } |
| 1438 | return buttonId; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1439 | } |
| 1440 | |
| 1441 | private void doEdit() { |
Erik | c41b99b | 2010-11-24 10:27:13 -0800 | [diff] [blame] | 1442 | Context c = getActivity(); |
| 1443 | // This ensures that we aren't in the process of closing and have been |
| 1444 | // unattached already |
| 1445 | if (c != null) { |
James Kung | 1d1b1e4 | 2013-03-06 19:49:23 -0800 | [diff] [blame] | 1446 | Uri uri = ContentUris.withAppendedId(Events.CONTENT_URI, mEventId); |
| 1447 | Intent intent = new Intent(Intent.ACTION_EDIT, uri); |
| 1448 | intent.setClass(mActivity, EditEventActivity.class); |
| 1449 | intent.putExtra(EXTRA_EVENT_BEGIN_TIME, mStartMillis); |
| 1450 | intent.putExtra(EXTRA_EVENT_END_TIME, mEndMillis); |
| 1451 | intent.putExtra(EXTRA_EVENT_ALL_DAY, mAllDay); |
| 1452 | intent.putExtra(EditEventActivity.EXTRA_EVENT_COLOR, mCurrentColor); |
| 1453 | intent.putExtra(EditEventActivity.EXTRA_EVENT_REMINDERS, EventViewUtils |
| 1454 | .reminderItemsToReminders(mReminderViews, mReminderMinuteValues, |
| 1455 | mReminderMethodValues)); |
| 1456 | intent.putExtra(EVENT_EDIT_ON_LAUNCH, true); |
| 1457 | startActivity(intent); |
Erik | c41b99b | 2010-11-24 10:27:13 -0800 | [diff] [blame] | 1458 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1459 | } |
| 1460 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1461 | private void updateEvent(View view) { |
Isaac Katzenelson | b7762cf | 2011-06-09 14:04:42 -0700 | [diff] [blame] | 1462 | if (mEventCursor == null || view == null) { |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1463 | return; |
| 1464 | } |
| 1465 | |
Michael Chan | 5f5ef75 | 2012-05-24 17:00:21 -0700 | [diff] [blame] | 1466 | Context context = view.getContext(); |
| 1467 | if (context == null) { |
| 1468 | return; |
| 1469 | } |
| 1470 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1471 | String eventName = mEventCursor.getString(EVENT_INDEX_TITLE); |
| 1472 | if (eventName == null || eventName.length() == 0) { |
| 1473 | eventName = getActivity().getString(R.string.no_title_label); |
| 1474 | } |
| 1475 | |
Sara Ting | da3ee39 | 2012-12-10 15:18:26 -0800 | [diff] [blame] | 1476 | // 3rd parties might not have specified the start/end time when firing the |
| 1477 | // Events.CONTENT_URI intent. Update these with values read from the db. |
| 1478 | if (mStartMillis == 0 && mEndMillis == 0) { |
| 1479 | mStartMillis = mEventCursor.getLong(EVENT_INDEX_DTSTART); |
| 1480 | mEndMillis = mEventCursor.getLong(EVENT_INDEX_DTEND); |
| 1481 | if (mEndMillis == 0) { |
| 1482 | String duration = mEventCursor.getString(EVENT_INDEX_DURATION); |
| 1483 | if (!TextUtils.isEmpty(duration)) { |
| 1484 | try { |
| 1485 | Duration d = new Duration(); |
| 1486 | d.parse(duration); |
| 1487 | long endMillis = mStartMillis + d.getMillis(); |
| 1488 | if (endMillis >= mStartMillis) { |
| 1489 | mEndMillis = endMillis; |
| 1490 | } else { |
| 1491 | Log.d(TAG, "Invalid duration string: " + duration); |
| 1492 | } |
| 1493 | } catch (DateException e) { |
| 1494 | Log.d(TAG, "Error parsing duration string " + duration, e); |
| 1495 | } |
| 1496 | } |
| 1497 | if (mEndMillis == 0) { |
| 1498 | mEndMillis = mStartMillis; |
| 1499 | } |
| 1500 | } |
| 1501 | } |
| 1502 | |
Michael Chan | 8b1119b | 2012-01-06 16:04:55 -0800 | [diff] [blame] | 1503 | mAllDay = mEventCursor.getInt(EVENT_INDEX_ALL_DAY) != 0; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1504 | String location = mEventCursor.getString(EVENT_INDEX_EVENT_LOCATION); |
| 1505 | String description = mEventCursor.getString(EVENT_INDEX_DESCRIPTION); |
| 1506 | String rRule = mEventCursor.getString(EVENT_INDEX_RRULE); |
Isaac Katzenelson | f6f7977 | 2011-06-02 16:29:18 -0700 | [diff] [blame] | 1507 | String eventTimezone = mEventCursor.getString(EVENT_INDEX_EVENT_TIMEZONE); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1508 | |
James Kung | 497a625 | 2013-05-17 14:47:33 -0700 | [diff] [blame^] | 1509 | mHeadlines.setBackgroundColor(mCurrentColor); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1510 | |
Sara Ting | 4e92627 | 2012-04-19 10:41:56 -0700 | [diff] [blame] | 1511 | // What |
| 1512 | if (eventName != null) { |
| 1513 | setTextCommon(view, R.id.title, eventName); |
| 1514 | } |
| 1515 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1516 | // When |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 1517 | // Set the date and repeats (if any) |
Sara Ting | 75f5366 | 2012-04-09 15:37:10 -0700 | [diff] [blame] | 1518 | String localTimezone = Utils.getTimeZone(mActivity, mTZUpdater); |
Michael Chan | 5f5ef75 | 2012-05-24 17:00:21 -0700 | [diff] [blame] | 1519 | |
Sara Ting | 23acd26 | 2012-04-20 13:27:39 -0700 | [diff] [blame] | 1520 | Resources resources = context.getResources(); |
| 1521 | String displayedDatetime = Utils.getDisplayedDatetime(mStartMillis, mEndMillis, |
| 1522 | System.currentTimeMillis(), localTimezone, mAllDay, context); |
Michael Chan | e8e5572 | 2012-05-30 13:59:34 -0700 | [diff] [blame] | 1523 | |
| 1524 | String displayedTimezone = null; |
| 1525 | if (!mAllDay) { |
| 1526 | displayedTimezone = Utils.getDisplayedTimezone(mStartMillis, localTimezone, |
| 1527 | eventTimezone); |
Sara Ting | 23acd26 | 2012-04-20 13:27:39 -0700 | [diff] [blame] | 1528 | } |
| 1529 | // Display the datetime. Make the timezone (if any) transparent. |
| 1530 | if (displayedTimezone == null) { |
| 1531 | setTextCommon(view, R.id.when_datetime, displayedDatetime); |
| 1532 | } else { |
Michael Chan | e8e5572 | 2012-05-30 13:59:34 -0700 | [diff] [blame] | 1533 | int timezoneIndex = displayedDatetime.length(); |
| 1534 | displayedDatetime += " " + displayedTimezone; |
Sara Ting | 23acd26 | 2012-04-20 13:27:39 -0700 | [diff] [blame] | 1535 | SpannableStringBuilder sb = new SpannableStringBuilder(displayedDatetime); |
| 1536 | ForegroundColorSpan transparentColorSpan = new ForegroundColorSpan( |
| 1537 | resources.getColor(R.color.event_info_headline_transparent_color)); |
| 1538 | sb.setSpan(transparentColorSpan, timezoneIndex, displayedDatetime.length(), |
| 1539 | Spannable.SPAN_INCLUSIVE_INCLUSIVE); |
| 1540 | setTextCommon(view, R.id.when_datetime, sb); |
| 1541 | } |
Isaac Katzenelson | 74c9032 | 2011-06-02 15:20:29 -0700 | [diff] [blame] | 1542 | |
Sara Ting | 75f5366 | 2012-04-09 15:37:10 -0700 | [diff] [blame] | 1543 | // Display the repeat string (if any) |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 1544 | String repeatString = null; |
Michael Chan | bfa0e3f | 2010-12-20 12:36:55 -0800 | [diff] [blame] | 1545 | if (!TextUtils.isEmpty(rRule)) { |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1546 | EventRecurrence eventRecurrence = new EventRecurrence(); |
| 1547 | eventRecurrence.parse(rRule); |
Sara Ting | 75f5366 | 2012-04-09 15:37:10 -0700 | [diff] [blame] | 1548 | Time date = new Time(localTimezone); |
| 1549 | date.set(mStartMillis); |
Michael Chan | 8b1119b | 2012-01-06 16:04:55 -0800 | [diff] [blame] | 1550 | if (mAllDay) { |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1551 | date.timezone = Time.TIMEZONE_UTC; |
| 1552 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1553 | eventRecurrence.setStartDate(date); |
Michael Chan | b21c638 | 2013-03-14 02:53:30 -0700 | [diff] [blame] | 1554 | repeatString = EventRecurrenceFormatter.getRepeatString(mContext, resources, |
| 1555 | eventRecurrence, true); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1556 | } |
Sara Ting | 75f5366 | 2012-04-09 15:37:10 -0700 | [diff] [blame] | 1557 | if (repeatString == null) { |
| 1558 | view.findViewById(R.id.when_repeat).setVisibility(View.GONE); |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 1559 | } else { |
Sara Ting | 75f5366 | 2012-04-09 15:37:10 -0700 | [diff] [blame] | 1560 | setTextCommon(view, R.id.when_repeat, repeatString); |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 1561 | } |
| 1562 | |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 1563 | // Organizer view is setup in the updateCalendar method |
| 1564 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1565 | |
| 1566 | // Where |
Michael Chan | ddfb59d | 2011-01-12 15:41:21 -0800 | [diff] [blame] | 1567 | if (location == null || location.trim().length() == 0) { |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1568 | setVisibilityCommon(view, R.id.where, View.GONE); |
| 1569 | } else { |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 1570 | final TextView textView = mWhere; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1571 | if (textView != null) { |
Michael Chan | ddfb59d | 2011-01-12 15:41:21 -0800 | [diff] [blame] | 1572 | textView.setAutoLinkMask(0); |
| 1573 | textView.setText(location.trim()); |
Andy McFadden | af577fd | 2011-11-07 11:08:14 -0800 | [diff] [blame] | 1574 | try { |
Sam Blitzstein | 29dc76a | 2012-11-19 10:46:54 -0800 | [diff] [blame] | 1575 | textView.setText(Utils.extendedLinkify(textView.getText().toString(), true)); |
| 1576 | |
| 1577 | // Linkify.addLinks() sets the TextView movement method if it finds any links. |
Sara Ting | da3ee39 | 2012-12-10 15:18:26 -0800 | [diff] [blame] | 1578 | // We must do the same here, in case linkify by itself did not find any. |
Sam Blitzstein | 29dc76a | 2012-11-19 10:46:54 -0800 | [diff] [blame] | 1579 | // (This is cloned from Linkify.addLinkMovementMethod().) |
| 1580 | MovementMethod mm = textView.getMovementMethod(); |
| 1581 | if ((mm == null) || !(mm instanceof LinkMovementMethod)) { |
| 1582 | if (textView.getLinksClickable()) { |
| 1583 | textView.setMovementMethod(LinkMovementMethod.getInstance()); |
| 1584 | } |
| 1585 | } |
Andy McFadden | af577fd | 2011-11-07 11:08:14 -0800 | [diff] [blame] | 1586 | } catch (Exception ex) { |
| 1587 | // unexpected |
| 1588 | Log.e(TAG, "Linkification failed", ex); |
| 1589 | } |
Andy McFadden | 73b0765 | 2011-08-23 15:45:09 -0700 | [diff] [blame] | 1590 | |
Michael Chan | ddfb59d | 2011-01-12 15:41:21 -0800 | [diff] [blame] | 1591 | textView.setOnTouchListener(new OnTouchListener() { |
Andy McFadden | c928e3d | 2011-06-13 09:53:20 -0700 | [diff] [blame] | 1592 | @Override |
Michael Chan | ddfb59d | 2011-01-12 15:41:21 -0800 | [diff] [blame] | 1593 | public boolean onTouch(View v, MotionEvent event) { |
| 1594 | try { |
| 1595 | return v.onTouchEvent(event); |
| 1596 | } catch (ActivityNotFoundException e) { |
| 1597 | // ignore |
| 1598 | return true; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1599 | } |
Michael Chan | ddfb59d | 2011-01-12 15:41:21 -0800 | [diff] [blame] | 1600 | } |
| 1601 | }); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1602 | } |
| 1603 | } |
| 1604 | |
| 1605 | // Description |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 1606 | if (description != null && description.length() != 0) { |
Michael Chan | 99704a2 | 2011-11-11 10:24:37 -0800 | [diff] [blame] | 1607 | mDesc.setText(description); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1608 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1609 | |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 1610 | // Launch Custom App |
Sara Ting | fac2d15 | 2012-05-31 14:59:57 -0700 | [diff] [blame] | 1611 | if (Utils.isJellybeanOrLater()) { |
Michael Chan | 693ca60 | 2012-05-31 12:24:11 -0700 | [diff] [blame] | 1612 | updateCustomAppButton(); |
| 1613 | } |
Michael Chan | 2c8485c | 2012-05-09 10:23:45 -0700 | [diff] [blame] | 1614 | } |
| 1615 | |
| 1616 | private void updateCustomAppButton() { |
| 1617 | buttonSetup: { |
| 1618 | final Button launchButton = (Button) mView.findViewById(R.id.launch_custom_app_button); |
| 1619 | if (launchButton == null) |
| 1620 | break buttonSetup; |
| 1621 | |
| 1622 | final String customAppPackage = mEventCursor.getString(EVENT_INDEX_CUSTOM_APP_PACKAGE); |
| 1623 | final String customAppUri = mEventCursor.getString(EVENT_INDEX_CUSTOM_APP_URI); |
| 1624 | |
| 1625 | if (TextUtils.isEmpty(customAppPackage) || TextUtils.isEmpty(customAppUri)) |
| 1626 | break buttonSetup; |
| 1627 | |
| 1628 | PackageManager pm = mContext.getPackageManager(); |
| 1629 | if (pm == null) |
| 1630 | break buttonSetup; |
| 1631 | |
| 1632 | ApplicationInfo info; |
| 1633 | try { |
| 1634 | info = pm.getApplicationInfo(customAppPackage, 0); |
| 1635 | if (info == null) |
| 1636 | break buttonSetup; |
| 1637 | } catch (NameNotFoundException e) { |
| 1638 | break buttonSetup; |
| 1639 | } |
| 1640 | |
| 1641 | Uri uri = ContentUris.withAppendedId(Events.CONTENT_URI, mEventId); |
| 1642 | final Intent intent = new Intent(CalendarContract.ACTION_HANDLE_CUSTOM_EVENT, uri); |
| 1643 | intent.setPackage(customAppPackage); |
| 1644 | intent.putExtra(CalendarContract.EXTRA_CUSTOM_APP_URI, customAppUri); |
| 1645 | intent.putExtra(EXTRA_EVENT_BEGIN_TIME, mStartMillis); |
| 1646 | |
| 1647 | // See if we have a taker for our intent |
| 1648 | if (pm.resolveActivity(intent, 0) == null) |
| 1649 | break buttonSetup; |
| 1650 | |
| 1651 | Drawable icon = pm.getApplicationIcon(info); |
| 1652 | if (icon != null) { |
| 1653 | |
| 1654 | Drawable[] d = launchButton.getCompoundDrawables(); |
| 1655 | icon.setBounds(0, 0, mCustomAppIconSize, mCustomAppIconSize); |
| 1656 | launchButton.setCompoundDrawables(icon, d[1], d[2], d[3]); |
| 1657 | } |
| 1658 | |
| 1659 | CharSequence label = pm.getApplicationLabel(info); |
| 1660 | if (label != null && label.length() != 0) { |
| 1661 | launchButton.setText(label); |
| 1662 | } else if (icon == null) { |
| 1663 | // No icon && no label. Hide button? |
| 1664 | break buttonSetup; |
| 1665 | } |
| 1666 | |
| 1667 | // Launch custom app |
| 1668 | launchButton.setOnClickListener(new View.OnClickListener() { |
| 1669 | @Override |
| 1670 | public void onClick(View v) { |
| 1671 | try { |
| 1672 | startActivityForResult(intent, 0); |
| 1673 | } catch (ActivityNotFoundException e) { |
| 1674 | // Shouldn't happen as we checked it already |
| 1675 | setVisibilityCommon(mView, R.id.launch_custom_app_container, View.GONE); |
| 1676 | } |
| 1677 | } |
| 1678 | }); |
| 1679 | |
| 1680 | setVisibilityCommon(mView, R.id.launch_custom_app_container, View.VISIBLE); |
| 1681 | return; |
| 1682 | |
| 1683 | } |
| 1684 | |
| 1685 | setVisibilityCommon(mView, R.id.launch_custom_app_container, View.GONE); |
| 1686 | return; |
Isaac Katzenelson | 8f4d969 | 2012-02-23 17:34:07 -0800 | [diff] [blame] | 1687 | } |
Sara Ting | 75f5366 | 2012-04-09 15:37:10 -0700 | [diff] [blame] | 1688 | |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 1689 | private void sendAccessibilityEvent() { |
Andy McFadden | ef31a98 | 2011-06-09 07:38:56 -0700 | [diff] [blame] | 1690 | AccessibilityManager am = |
| 1691 | (AccessibilityManager) getActivity().getSystemService(Service.ACCESSIBILITY_SERVICE); |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 1692 | if (!am.isEnabled()) { |
| 1693 | return; |
| 1694 | } |
| 1695 | |
| 1696 | AccessibilityEvent event = AccessibilityEvent.obtain(AccessibilityEvent.TYPE_VIEW_FOCUSED); |
| 1697 | event.setClassName(getClass().getName()); |
| 1698 | event.setPackageName(getActivity().getPackageName()); |
| 1699 | List<CharSequence> text = event.getText(); |
| 1700 | |
Michael Chan | 99704a2 | 2011-11-11 10:24:37 -0800 | [diff] [blame] | 1701 | addFieldToAccessibilityEvent(text, mTitle, null); |
Sara Ting | 75f5366 | 2012-04-09 15:37:10 -0700 | [diff] [blame] | 1702 | addFieldToAccessibilityEvent(text, mWhenDateTime, null); |
Michael Chan | 99704a2 | 2011-11-11 10:24:37 -0800 | [diff] [blame] | 1703 | addFieldToAccessibilityEvent(text, mWhere, null); |
| 1704 | addFieldToAccessibilityEvent(text, null, mDesc); |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 1705 | |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 1706 | if (mResponseRadioGroup.getVisibility() == View.VISIBLE) { |
| 1707 | int id = mResponseRadioGroup.getCheckedRadioButtonId(); |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 1708 | if (id != View.NO_ID) { |
| 1709 | text.add(((TextView) getView().findViewById(R.id.response_label)).getText()); |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 1710 | text.add((((RadioButton) (mResponseRadioGroup.findViewById(id))) |
| 1711 | .getText() + PERIOD_SPACE)); |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 1712 | } |
| 1713 | } |
| 1714 | |
| 1715 | am.sendAccessibilityEvent(event); |
| 1716 | } |
| 1717 | |
Michael Chan | 99704a2 | 2011-11-11 10:24:37 -0800 | [diff] [blame] | 1718 | private void addFieldToAccessibilityEvent(List<CharSequence> text, TextView tv, |
| 1719 | ExpandableTextView etv) { |
Michael Chan | 3389397 | 2011-11-16 12:45:53 -0800 | [diff] [blame] | 1720 | CharSequence cs; |
Michael Chan | 99704a2 | 2011-11-11 10:24:37 -0800 | [diff] [blame] | 1721 | if (tv != null) { |
Michael Chan | 3389397 | 2011-11-16 12:45:53 -0800 | [diff] [blame] | 1722 | cs = tv.getText(); |
Michael Chan | 99704a2 | 2011-11-11 10:24:37 -0800 | [diff] [blame] | 1723 | } else if (etv != null) { |
Michael Chan | 3389397 | 2011-11-16 12:45:53 -0800 | [diff] [blame] | 1724 | cs = etv.getText(); |
Michael Chan | 99704a2 | 2011-11-11 10:24:37 -0800 | [diff] [blame] | 1725 | } else { |
Isaac Katzenelson | 9ceed1f | 2011-06-08 17:26:26 -0700 | [diff] [blame] | 1726 | return; |
| 1727 | } |
Michael Chan | 99704a2 | 2011-11-11 10:24:37 -0800 | [diff] [blame] | 1728 | |
Michael Chan | 3389397 | 2011-11-16 12:45:53 -0800 | [diff] [blame] | 1729 | if (!TextUtils.isEmpty(cs)) { |
| 1730 | cs = cs.toString().trim(); |
| 1731 | if (cs.length() > 0) { |
| 1732 | text.add(cs); |
| 1733 | text.add(PERIOD_SPACE); |
| 1734 | } |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 1735 | } |
| 1736 | } |
| 1737 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1738 | private void updateCalendar(View view) { |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1739 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1740 | mCalendarOwnerAccount = ""; |
| 1741 | if (mCalendarsCursor != null && mEventCursor != null) { |
| 1742 | mCalendarsCursor.moveToFirst(); |
| 1743 | String tempAccount = mCalendarsCursor.getString(CALENDARS_INDEX_OWNER_ACCOUNT); |
| 1744 | mCalendarOwnerAccount = (tempAccount == null) ? "" : tempAccount; |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 1745 | mOwnerCanRespond = mCalendarsCursor.getInt(CALENDARS_INDEX_OWNER_CAN_RESPOND) != 0; |
Sara Ting | 42896f7 | 2012-03-15 15:24:36 -0700 | [diff] [blame] | 1746 | mSyncAccountName = mCalendarsCursor.getString(CALENDARS_INDEX_ACCOUNT_NAME); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1747 | |
Sara Ting | 6aad0ff | 2012-08-02 10:55:52 -0700 | [diff] [blame] | 1748 | // start visible calendars query |
| 1749 | mHandler.startQuery(TOKEN_QUERY_VISIBLE_CALENDARS, null, Calendars.CONTENT_URI, |
| 1750 | CALENDARS_PROJECTION, CALENDARS_VISIBLE_WHERE, new String[] {"1"}, null); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1751 | |
Michael Chan | 83efa2d | 2012-04-24 17:42:21 -0700 | [diff] [blame] | 1752 | mEventOrganizerEmail = mEventCursor.getString(EVENT_INDEX_ORGANIZER); |
| 1753 | mIsOrganizer = mCalendarOwnerAccount.equalsIgnoreCase(mEventOrganizerEmail); |
| 1754 | |
Sara Ting | 0c0da94 | 2012-04-27 10:35:05 -0700 | [diff] [blame] | 1755 | if (!TextUtils.isEmpty(mEventOrganizerEmail) && |
| 1756 | !mEventOrganizerEmail.endsWith(Utils.MACHINE_GENERATED_ADDRESS)) { |
Michael Chan | 83efa2d | 2012-04-24 17:42:21 -0700 | [diff] [blame] | 1757 | mEventOrganizerDisplayName = mEventOrganizerEmail; |
| 1758 | } |
| 1759 | |
| 1760 | if (!mIsOrganizer && !TextUtils.isEmpty(mEventOrganizerDisplayName)) { |
| 1761 | setTextCommon(view, R.id.organizer, mEventOrganizerDisplayName); |
Isaac Katzenelson | b7762cf | 2011-06-09 14:04:42 -0700 | [diff] [blame] | 1762 | setVisibilityCommon(view, R.id.organizer_container, View.VISIBLE); |
| 1763 | } else { |
| 1764 | setVisibilityCommon(view, R.id.organizer_container, View.GONE); |
| 1765 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1766 | mHasAttendeeData = mEventCursor.getInt(EVENT_INDEX_HAS_ATTENDEE_DATA) != 0; |
RoboErik | 65eeb79 | 2011-08-08 12:54:00 -0700 | [diff] [blame] | 1767 | mCanModifyCalendar = mEventCursor.getInt(EVENT_INDEX_ACCESS_LEVEL) |
| 1768 | >= Calendars.CAL_ACCESS_CONTRIBUTOR; |
| 1769 | // TODO add "|| guestCanModify" after b/1299071 is fixed |
| 1770 | mCanModifyEvent = mCanModifyCalendar && mIsOrganizer; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1771 | mIsBusyFreeCalendar = |
RoboErik | ef2add9 | 2011-06-09 14:49:53 -0700 | [diff] [blame] | 1772 | mEventCursor.getInt(EVENT_INDEX_ACCESS_LEVEL) == Calendars.CAL_ACCESS_FREEBUSY; |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 1773 | |
| 1774 | if (!mIsBusyFreeCalendar) { |
Isaac Katzenelson | d4e45fa | 2012-06-04 16:38:11 -0700 | [diff] [blame] | 1775 | |
| 1776 | View b = mView.findViewById(R.id.edit); |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 1777 | b.setEnabled(true); |
Michael Chan | 8ce3b7d | 2010-09-01 15:41:01 -0700 | [diff] [blame] | 1778 | b.setOnClickListener(new OnClickListener() { |
| 1779 | @Override |
| 1780 | public void onClick(View v) { |
| 1781 | doEdit(); |
Isaac Katzenelson | 10b6021 | 2011-06-28 17:59:14 -0700 | [diff] [blame] | 1782 | // For dialogs, just close the fragment |
| 1783 | // For full screen, close activity on phone, leave it for tablet |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 1784 | if (mIsDialog) { |
| 1785 | EventInfoFragment.this.dismiss(); |
| 1786 | } |
Isaac Katzenelson | 10b6021 | 2011-06-28 17:59:14 -0700 | [diff] [blame] | 1787 | else if (!mIsTabletConfig){ |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 1788 | getActivity().finish(); |
| 1789 | } |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 1790 | } |
| 1791 | }); |
Michael Chan | 8ce3b7d | 2010-09-01 15:41:01 -0700 | [diff] [blame] | 1792 | } |
Mindy Pereira | dd15169 | 2011-08-29 14:05:26 -0700 | [diff] [blame] | 1793 | View button; |
Sara Ting | 42896f7 | 2012-03-15 15:24:36 -0700 | [diff] [blame] | 1794 | if (mCanModifyCalendar) { |
Mindy Pereira | dd15169 | 2011-08-29 14:05:26 -0700 | [diff] [blame] | 1795 | button = mView.findViewById(R.id.delete); |
| 1796 | if (button != null) { |
Sara Ting | 42896f7 | 2012-03-15 15:24:36 -0700 | [diff] [blame] | 1797 | button.setEnabled(true); |
| 1798 | button.setVisibility(View.VISIBLE); |
RoboErik | 65eeb79 | 2011-08-08 12:54:00 -0700 | [diff] [blame] | 1799 | } |
Mindy Pereira | dd15169 | 2011-08-29 14:05:26 -0700 | [diff] [blame] | 1800 | } |
Sara Ting | 42896f7 | 2012-03-15 15:24:36 -0700 | [diff] [blame] | 1801 | if (mCanModifyEvent) { |
Mindy Pereira | dd15169 | 2011-08-29 14:05:26 -0700 | [diff] [blame] | 1802 | button = mView.findViewById(R.id.edit); |
| 1803 | if (button != null) { |
Sara Ting | 42896f7 | 2012-03-15 15:24:36 -0700 | [diff] [blame] | 1804 | button.setEnabled(true); |
| 1805 | button.setVisibility(View.VISIBLE); |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 1806 | } |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 1807 | } |
Isaac Katzenelson | 7ef2981 | 2011-10-25 18:00:50 -0700 | [diff] [blame] | 1808 | if ((!mIsDialog && !mIsTabletConfig || |
| 1809 | mWindowStyle == EventInfoFragment.FULL_WINDOW_STYLE) && mMenu != null) { |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 1810 | mActivity.invalidateOptionsMenu(); |
RoboErik | 69be855 | 2011-02-14 16:51:59 -0800 | [diff] [blame] | 1811 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1812 | } else { |
Michael Chan | 71b221a | 2010-10-25 17:55:44 -0700 | [diff] [blame] | 1813 | setVisibilityCommon(view, R.id.calendar, View.GONE); |
Erik | 259b8f9 | 2011-01-12 14:01:12 -0800 | [diff] [blame] | 1814 | sendAccessibilityEventIfQueryDone(TOKEN_QUERY_DUPLICATE_CALENDARS); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1815 | } |
| 1816 | } |
| 1817 | |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 1818 | /** |
| 1819 | * |
| 1820 | */ |
| 1821 | private void updateMenu() { |
| 1822 | if (mMenu == null) { |
| 1823 | return; |
| 1824 | } |
| 1825 | MenuItem delete = mMenu.findItem(R.id.info_action_delete); |
| 1826 | MenuItem edit = mMenu.findItem(R.id.info_action_edit); |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1827 | MenuItem changeColor = mMenu.findItem(R.id.info_action_change_color); |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 1828 | if (delete != null) { |
| 1829 | delete.setVisible(mCanModifyCalendar); |
| 1830 | delete.setEnabled(mCanModifyCalendar); |
| 1831 | } |
| 1832 | if (edit != null) { |
RoboErik | 65eeb79 | 2011-08-08 12:54:00 -0700 | [diff] [blame] | 1833 | edit.setVisible(mCanModifyEvent); |
| 1834 | edit.setEnabled(mCanModifyEvent); |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 1835 | } |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 1836 | if (changeColor != null && mColors != null && mColors.length > 0) { |
| 1837 | changeColor.setVisible(mCanModifyCalendar); |
| 1838 | changeColor.setEnabled(mCanModifyCalendar); |
| 1839 | } |
RoboErik | d8353fb | 2011-07-21 11:28:11 -0700 | [diff] [blame] | 1840 | } |
| 1841 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1842 | private void updateAttendees(View view) { |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 1843 | if (mAcceptedAttendees.size() + mDeclinedAttendees.size() + |
| 1844 | mTentativeAttendees.size() + mNoResponseAttendees.size() > 0) { |
RoboErik | c7f3c38 | 2011-08-31 14:43:24 -0700 | [diff] [blame] | 1845 | mLongAttendees.clearAttendees(); |
RoboErik | 4acb2fd | 2011-07-18 15:39:49 -0700 | [diff] [blame] | 1846 | (mLongAttendees).addAttendees(mAcceptedAttendees); |
| 1847 | (mLongAttendees).addAttendees(mDeclinedAttendees); |
| 1848 | (mLongAttendees).addAttendees(mTentativeAttendees); |
| 1849 | (mLongAttendees).addAttendees(mNoResponseAttendees); |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 1850 | mLongAttendees.setEnabled(false); |
| 1851 | mLongAttendees.setVisibility(View.VISIBLE); |
Isaac Katzenelson | 60f01c2 | 2011-06-03 15:42:01 -0700 | [diff] [blame] | 1852 | } else { |
Isaac Katzenelson | fae6d5c | 2011-06-16 15:43:41 -0700 | [diff] [blame] | 1853 | mLongAttendees.setVisibility(View.GONE); |
Michael Chan | 71b221a | 2010-10-25 17:55:44 -0700 | [diff] [blame] | 1854 | } |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 1855 | |
Sara Ting | 7ffa24c | 2012-08-28 15:44:37 -0700 | [diff] [blame] | 1856 | if (hasEmailableAttendees()) { |
Sara Ting | 7da2767 | 2012-07-24 16:23:53 -0700 | [diff] [blame] | 1857 | setVisibilityCommon(mView, R.id.email_attendees_container, View.VISIBLE); |
Sara Ting | 7ffa24c | 2012-08-28 15:44:37 -0700 | [diff] [blame] | 1858 | if (emailAttendeesButton != null) { |
| 1859 | emailAttendeesButton.setText(R.string.email_guests_label); |
| 1860 | } |
| 1861 | } else if (hasEmailableOrganizer()) { |
| 1862 | setVisibilityCommon(mView, R.id.email_attendees_container, View.VISIBLE); |
| 1863 | if (emailAttendeesButton != null) { |
| 1864 | emailAttendeesButton.setText(R.string.email_organizer_label); |
| 1865 | } |
Sara Ting | 7da2767 | 2012-07-24 16:23:53 -0700 | [diff] [blame] | 1866 | } else { |
| 1867 | setVisibilityCommon(mView, R.id.email_attendees_container, View.GONE); |
| 1868 | } |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 1869 | } |
| 1870 | |
| 1871 | /** |
Sara Ting | 7da2767 | 2012-07-24 16:23:53 -0700 | [diff] [blame] | 1872 | * Returns true if there is at least 1 attendee that is not the viewer. |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 1873 | */ |
Sara Ting | 7ffa24c | 2012-08-28 15:44:37 -0700 | [diff] [blame] | 1874 | private boolean hasEmailableAttendees() { |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 1875 | for (Attendee attendee : mAcceptedAttendees) { |
Sara Ting | 7da2767 | 2012-07-24 16:23:53 -0700 | [diff] [blame] | 1876 | if (Utils.isEmailableFrom(attendee.mEmail, mSyncAccountName)) { |
| 1877 | return true; |
| 1878 | } |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 1879 | } |
| 1880 | for (Attendee attendee : mTentativeAttendees) { |
Sara Ting | 7da2767 | 2012-07-24 16:23:53 -0700 | [diff] [blame] | 1881 | if (Utils.isEmailableFrom(attendee.mEmail, mSyncAccountName)) { |
| 1882 | return true; |
| 1883 | } |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 1884 | } |
| 1885 | for (Attendee attendee : mNoResponseAttendees) { |
Sara Ting | 7da2767 | 2012-07-24 16:23:53 -0700 | [diff] [blame] | 1886 | if (Utils.isEmailableFrom(attendee.mEmail, mSyncAccountName)) { |
| 1887 | return true; |
| 1888 | } |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 1889 | } |
Sara Ting | 7da2767 | 2012-07-24 16:23:53 -0700 | [diff] [blame] | 1890 | for (Attendee attendee : mDeclinedAttendees) { |
| 1891 | if (Utils.isEmailableFrom(attendee.mEmail, mSyncAccountName)) { |
| 1892 | return true; |
| 1893 | } |
Sara Ting | cb5f568 | 2012-04-04 22:52:20 -0700 | [diff] [blame] | 1894 | } |
Sara Ting | 7ffa24c | 2012-08-28 15:44:37 -0700 | [diff] [blame] | 1895 | return false; |
| 1896 | } |
| 1897 | |
| 1898 | private boolean hasEmailableOrganizer() { |
Sara Ting | 7da2767 | 2012-07-24 16:23:53 -0700 | [diff] [blame] | 1899 | return mEventOrganizerEmail != null && |
| 1900 | Utils.isEmailableFrom(mEventOrganizerEmail, mSyncAccountName); |
Michael Chan | 8ce3b7d | 2010-09-01 15:41:01 -0700 | [diff] [blame] | 1901 | } |
| 1902 | |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1903 | public void initReminders(View view, Cursor cursor) { |
| 1904 | |
| 1905 | // Add reminders |
RoboErik | c7f3c38 | 2011-08-31 14:43:24 -0700 | [diff] [blame] | 1906 | mOriginalReminders.clear(); |
RoboErik | c08957b | 2011-09-09 13:43:38 -0700 | [diff] [blame] | 1907 | mUnsupportedReminders.clear(); |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1908 | while (cursor.moveToNext()) { |
| 1909 | int minutes = cursor.getInt(EditEventHelper.REMINDERS_INDEX_MINUTES); |
| 1910 | int method = cursor.getInt(EditEventHelper.REMINDERS_INDEX_METHOD); |
RoboErik | e35a032 | 2011-09-01 16:21:49 -0700 | [diff] [blame] | 1911 | |
RoboErik | c08957b | 2011-09-09 13:43:38 -0700 | [diff] [blame] | 1912 | if (method != Reminders.METHOD_DEFAULT && !mReminderMethodValues.contains(method)) { |
RoboErik | e35a032 | 2011-09-01 16:21:49 -0700 | [diff] [blame] | 1913 | // Stash unsupported reminder types separately so we don't alter |
| 1914 | // them in the UI |
| 1915 | mUnsupportedReminders.add(ReminderEntry.valueOf(minutes, method)); |
| 1916 | } else { |
| 1917 | mOriginalReminders.add(ReminderEntry.valueOf(minutes, method)); |
| 1918 | } |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1919 | } |
| 1920 | // Sort appropriately for display (by time, then type) |
| 1921 | Collections.sort(mOriginalReminders); |
| 1922 | |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 1923 | if (mUserModifiedReminders) { |
| 1924 | // If the user has changed the list of reminders don't change what's |
| 1925 | // shown. |
| 1926 | return; |
| 1927 | } |
| 1928 | |
RoboErik | 5d40a38 | 2011-09-02 14:33:09 -0700 | [diff] [blame] | 1929 | LinearLayout parent = (LinearLayout) mScrollView |
| 1930 | .findViewById(R.id.reminder_items_container); |
| 1931 | if (parent != null) { |
| 1932 | parent.removeAllViews(); |
| 1933 | } |
RoboErik | c08957b | 2011-09-09 13:43:38 -0700 | [diff] [blame] | 1934 | if (mReminderViews != null) { |
| 1935 | mReminderViews.clear(); |
| 1936 | } |
RoboErik | 5d40a38 | 2011-09-02 14:33:09 -0700 | [diff] [blame] | 1937 | |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1938 | if (mHasAlarm) { |
Sam Blitzstein | 94a1f1a | 2013-02-12 15:16:35 -0800 | [diff] [blame] | 1939 | ArrayList<ReminderEntry> reminders; |
| 1940 | // If applicable, use reminders saved in the bundle. |
| 1941 | if (mReminders != null) { |
| 1942 | reminders = mReminders; |
| 1943 | } else { |
| 1944 | reminders = mOriginalReminders; |
| 1945 | } |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1946 | // Insert any minute values that aren't represented in the minutes list. |
| 1947 | for (ReminderEntry re : reminders) { |
| 1948 | EventViewUtils.addMinutesToList( |
| 1949 | mActivity, mReminderMinuteValues, mReminderMinuteLabels, re.getMinutes()); |
| 1950 | } |
| 1951 | // Create a UI element for each reminder. We display all of the reminders we get |
| 1952 | // from the provider, even if the count exceeds the calendar maximum. (Also, for |
| 1953 | // a new event, we won't have a maxReminders value available.) |
| 1954 | for (ReminderEntry re : reminders) { |
RoboErik | e35a032 | 2011-09-01 16:21:49 -0700 | [diff] [blame] | 1955 | EventViewUtils.addReminder(mActivity, mScrollView, this, mReminderViews, |
| 1956 | mReminderMinuteValues, mReminderMinuteLabels, mReminderMethodValues, |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 1957 | mReminderMethodLabels, re, Integer.MAX_VALUE, mReminderChangeListener); |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1958 | } |
Sara Ting | 06f3d6d | 2012-03-23 17:19:22 -0700 | [diff] [blame] | 1959 | EventViewUtils.updateAddReminderButton(mView, mReminderViews, mMaxReminders); |
RoboErik | e35a032 | 2011-09-01 16:21:49 -0700 | [diff] [blame] | 1960 | // TODO show unsupported reminder types in some fashion. |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 1961 | } |
| 1962 | } |
| 1963 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1964 | void updateResponse(View view) { |
| 1965 | // we only let the user accept/reject/etc. a meeting if: |
| 1966 | // a) you can edit the event's containing calendar AND |
| 1967 | // b) you're not the organizer and only attendee AND |
| 1968 | // c) organizerCanRespond is enabled for the calendar |
| 1969 | // (if the attendee data has been hidden, the visible number of attendees |
| 1970 | // will be 1 -- the calendar owner's). |
| 1971 | // (there are more cases involved to be 100% accurate, such as |
| 1972 | // paying attention to whether or not an attendee status was |
| 1973 | // included in the feed, but we're currently omitting those corner cases |
| 1974 | // for simplicity). |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 1975 | |
| 1976 | // TODO Switch to EditEventHelper.canRespond when this class uses CalendarEventModel. |
Michael Chan | d785cd5 | 2010-09-03 13:57:19 -0700 | [diff] [blame] | 1977 | if (!mCanModifyCalendar || (mHasAttendeeData && mIsOrganizer && mNumOfAttendees <= 1) || |
Michael Chan | 352e1a2 | 2010-09-28 05:15:08 -0700 | [diff] [blame] | 1978 | (mIsOrganizer && !mOwnerCanRespond)) { |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1979 | setVisibilityCommon(view, R.id.response_container, View.GONE); |
| 1980 | return; |
| 1981 | } |
| 1982 | |
| 1983 | setVisibilityCommon(view, R.id.response_container, View.VISIBLE); |
| 1984 | |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1985 | |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 1986 | int response; |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 1987 | if (mTentativeUserSetResponse != Attendees.ATTENDEE_STATUS_NONE) { |
| 1988 | response = mTentativeUserSetResponse; |
| 1989 | } else if (mUserSetResponse != Attendees.ATTENDEE_STATUS_NONE) { |
RoboErik | 5afc083 | 2011-09-27 14:14:09 -0700 | [diff] [blame] | 1990 | response = mUserSetResponse; |
Isaac Katzenelson | 6bcafcf | 2012-05-02 18:25:36 -0700 | [diff] [blame] | 1991 | } else if (mAttendeeResponseFromIntent != Attendees.ATTENDEE_STATUS_NONE) { |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 1992 | response = mAttendeeResponseFromIntent; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1993 | } else { |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 1994 | response = mOriginalAttendeeResponse; |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 1995 | } |
Michael Chan | f92f46b | 2010-10-27 18:59:05 -0700 | [diff] [blame] | 1996 | |
| 1997 | int buttonToCheck = findButtonIdForResponse(response); |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 1998 | mResponseRadioGroup.check(buttonToCheck); // -1 clear all radio buttons |
| 1999 | mResponseRadioGroup.setOnCheckedChangeListener(this); |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 2000 | } |
| 2001 | |
| 2002 | private void setTextCommon(View view, int id, CharSequence text) { |
| 2003 | TextView textView = (TextView) view.findViewById(id); |
| 2004 | if (textView == null) |
| 2005 | return; |
| 2006 | textView.setText(text); |
| 2007 | } |
| 2008 | |
| 2009 | private void setVisibilityCommon(View view, int id, int visibility) { |
| 2010 | View v = view.findViewById(id); |
| 2011 | if (v != null) { |
| 2012 | v.setVisibility(visibility); |
| 2013 | } |
| 2014 | return; |
| 2015 | } |
| 2016 | |
| 2017 | /** |
| 2018 | * Taken from com.google.android.gm.HtmlConversationActivity |
| 2019 | * |
| 2020 | * Send the intent that shows the Contact info corresponding to the email address. |
| 2021 | */ |
| 2022 | public void showContactInfo(Attendee attendee, Rect rect) { |
| 2023 | // First perform lookup query to find existing contact |
| 2024 | final ContentResolver resolver = getActivity().getContentResolver(); |
| 2025 | final String address = attendee.mEmail; |
| 2026 | final Uri dataUri = Uri.withAppendedPath(CommonDataKinds.Email.CONTENT_FILTER_URI, |
| 2027 | Uri.encode(address)); |
| 2028 | final Uri lookupUri = ContactsContract.Data.getContactLookupUri(resolver, dataUri); |
| 2029 | |
| 2030 | if (lookupUri != null) { |
| 2031 | // Found matching contact, trigger QuickContact |
| 2032 | QuickContact.showQuickContact(getActivity(), rect, lookupUri, |
| 2033 | QuickContact.MODE_MEDIUM, null); |
| 2034 | } else { |
| 2035 | // No matching contact, ask user to create one |
| 2036 | final Uri mailUri = Uri.fromParts("mailto", address, null); |
| 2037 | final Intent intent = new Intent(Intents.SHOW_OR_CREATE_CONTACT, mailUri); |
| 2038 | |
| 2039 | // Pass along full E-mail string for possible create dialog |
| 2040 | Rfc822Token sender = new Rfc822Token(attendee.mName, attendee.mEmail, null); |
| 2041 | intent.putExtra(Intents.EXTRA_CREATE_DESCRIPTION, sender.toString()); |
| 2042 | |
| 2043 | // Only provide personal name hint if we have one |
| 2044 | final String senderPersonal = attendee.mName; |
| 2045 | if (!TextUtils.isEmpty(senderPersonal)) { |
| 2046 | intent.putExtra(Intents.Insert.NAME, senderPersonal); |
| 2047 | } |
| 2048 | |
| 2049 | startActivity(intent); |
| 2050 | } |
| 2051 | } |
Erik | cb81189 | 2010-09-28 13:44:19 -0700 | [diff] [blame] | 2052 | |
| 2053 | @Override |
RoboErik | 7c6236d | 2011-02-24 16:41:18 -0800 | [diff] [blame] | 2054 | public void onPause() { |
| 2055 | mIsPaused = true; |
| 2056 | mHandler.removeCallbacks(onDeleteRunnable); |
| 2057 | super.onPause(); |
Isaac Katzenelson | b0a313a | 2011-10-24 11:41:56 -0700 | [diff] [blame] | 2058 | // Remove event deletion alert box since it is being rebuild in the OnResume |
| 2059 | // This is done to get the same behavior on OnResume since the AlertDialog is gone on |
| 2060 | // rotation but not if you press the HOME key |
| 2061 | if (mDeleteDialogVisible && mDeleteHelper != null) { |
| 2062 | mDeleteHelper.dismissAlertDialog(); |
| 2063 | mDeleteHelper = null; |
| 2064 | } |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 2065 | if (mTentativeUserSetResponse != Attendees.ATTENDEE_STATUS_NONE |
| 2066 | && mEditResponseHelper != null) { |
| 2067 | mEditResponseHelper.dismissAlertDialog(); |
| 2068 | } |
RoboErik | 7c6236d | 2011-02-24 16:41:18 -0800 | [diff] [blame] | 2069 | } |
| 2070 | |
| 2071 | @Override |
| 2072 | public void onResume() { |
| 2073 | super.onResume(); |
Michael Chan | 363aa9c | 2012-05-17 10:31:32 -0700 | [diff] [blame] | 2074 | if (mIsDialog) { |
| 2075 | setDialogSize(getActivity().getResources()); |
| 2076 | applyDialogParams(); |
| 2077 | } |
RoboErik | 7c6236d | 2011-02-24 16:41:18 -0800 | [diff] [blame] | 2078 | mIsPaused = false; |
| 2079 | if (mDismissOnResume) { |
| 2080 | mHandler.post(onDeleteRunnable); |
| 2081 | } |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 2082 | // Display the "delete confirmation" or "edit response helper" dialog if needed |
Isaac Katzenelson | b0a313a | 2011-10-24 11:41:56 -0700 | [diff] [blame] | 2083 | if (mDeleteDialogVisible) { |
| 2084 | mDeleteHelper = new DeleteEventHelper( |
| 2085 | mContext, mActivity, |
| 2086 | !mIsDialog && !mIsTabletConfig /* exitWhenDone */); |
| 2087 | mDeleteHelper.setOnDismissListener(createDeleteOnDismissListener()); |
| 2088 | mDeleteHelper.delete(mStartMillis, mEndMillis, mEventId, -1, onDeleteRunnable); |
Sam Blitzstein | 3b91cc0 | 2013-02-11 17:01:11 -0800 | [diff] [blame] | 2089 | } else if (mTentativeUserSetResponse != Attendees.ATTENDEE_STATUS_NONE) { |
| 2090 | int buttonId = findButtonIdForResponse(mTentativeUserSetResponse); |
| 2091 | mResponseRadioGroup.check(buttonId); |
| 2092 | mEditResponseHelper.showDialog(mEditResponseHelper.getWhichEvents()); |
Isaac Katzenelson | b0a313a | 2011-10-24 11:41:56 -0700 | [diff] [blame] | 2093 | } |
RoboErik | 7c6236d | 2011-02-24 16:41:18 -0800 | [diff] [blame] | 2094 | } |
| 2095 | |
| 2096 | @Override |
Erik | cb81189 | 2010-09-28 13:44:19 -0700 | [diff] [blame] | 2097 | public void eventsChanged() { |
| 2098 | } |
| 2099 | |
| 2100 | @Override |
Erik | cb81189 | 2010-09-28 13:44:19 -0700 | [diff] [blame] | 2101 | public long getSupportedEventTypes() { |
| 2102 | return EventType.EVENTS_CHANGED; |
| 2103 | } |
| 2104 | |
| 2105 | @Override |
Erik | cb81189 | 2010-09-28 13:44:19 -0700 | [diff] [blame] | 2106 | public void handleEvent(EventInfo event) { |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 2107 | reloadEvents(); |
Erik | cb81189 | 2010-09-28 13:44:19 -0700 | [diff] [blame] | 2108 | } |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2109 | |
Isaac Katzenelson | 80d640f | 2012-04-20 09:21:28 -0700 | [diff] [blame] | 2110 | public void reloadEvents() { |
James Kung | 4afba18 | 2012-12-18 23:12:08 -0800 | [diff] [blame] | 2111 | if (mHandler != null) { |
| 2112 | mHandler.startQuery(TOKEN_QUERY_EVENT, null, mUri, EVENT_PROJECTION, |
| 2113 | null, null, null); |
| 2114 | } |
Isaac Katzenelson | 80d640f | 2012-04-20 09:21:28 -0700 | [diff] [blame] | 2115 | } |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2116 | |
| 2117 | @Override |
| 2118 | public void onClick(View view) { |
| 2119 | |
| 2120 | // This must be a click on one of the "remove reminder" buttons |
| 2121 | LinearLayout reminderItem = (LinearLayout) view.getParent(); |
| 2122 | LinearLayout parent = (LinearLayout) reminderItem.getParent(); |
| 2123 | parent.removeView(reminderItem); |
| 2124 | mReminderViews.remove(reminderItem); |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 2125 | mUserModifiedReminders = true; |
Sara Ting | 06f3d6d | 2012-03-23 17:19:22 -0700 | [diff] [blame] | 2126 | EventViewUtils.updateAddReminderButton(mView, mReminderViews, mMaxReminders); |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2127 | } |
| 2128 | |
| 2129 | |
| 2130 | /** |
| 2131 | * Add a new reminder when the user hits the "add reminder" button. We use the default |
| 2132 | * reminder time and method. |
| 2133 | */ |
| 2134 | private void addReminder() { |
| 2135 | // TODO: when adding a new reminder, make it different from the |
| 2136 | // last one in the list (if any). |
| 2137 | if (mDefaultReminderMinutes == GeneralPreferences.NO_REMINDER) { |
| 2138 | EventViewUtils.addReminder(mActivity, mScrollView, this, mReminderViews, |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 2139 | mReminderMinuteValues, mReminderMinuteLabels, mReminderMethodValues, |
| 2140 | mReminderMethodLabels, |
| 2141 | ReminderEntry.valueOf(GeneralPreferences.REMINDER_DEFAULT_TIME), mMaxReminders, |
| 2142 | mReminderChangeListener); |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2143 | } else { |
| 2144 | EventViewUtils.addReminder(mActivity, mScrollView, this, mReminderViews, |
RoboErik | 8b5743c | 2011-09-27 16:07:09 -0700 | [diff] [blame] | 2145 | mReminderMinuteValues, mReminderMinuteLabels, mReminderMethodValues, |
| 2146 | mReminderMethodLabels, ReminderEntry.valueOf(mDefaultReminderMinutes), |
| 2147 | mMaxReminders, mReminderChangeListener); |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2148 | } |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2149 | |
Sara Ting | 06f3d6d | 2012-03-23 17:19:22 -0700 | [diff] [blame] | 2150 | EventViewUtils.updateAddReminderButton(mView, mReminderViews, mMaxReminders); |
| 2151 | } |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2152 | |
RoboErik | e35a032 | 2011-09-01 16:21:49 -0700 | [diff] [blame] | 2153 | synchronized private void prepareReminders() { |
| 2154 | // Nothing to do if we've already built these lists _and_ we aren't |
| 2155 | // removing not allowed methods |
| 2156 | if (mReminderMinuteValues != null && mReminderMinuteLabels != null |
| 2157 | && mReminderMethodValues != null && mReminderMethodLabels != null |
| 2158 | && mCalendarAllowedReminders == null) { |
| 2159 | return; |
| 2160 | } |
| 2161 | // Load the labels and corresponding numeric values for the minutes and methods lists |
| 2162 | // from the assets. If we're switching calendars, we need to clear and re-populate the |
| 2163 | // lists (which may have elements added and removed based on calendar properties). This |
| 2164 | // is mostly relevant for "methods", since we shouldn't have any "minutes" values in a |
| 2165 | // new event that aren't in the default set. |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2166 | Resources r = mActivity.getResources(); |
| 2167 | mReminderMinuteValues = loadIntegerArray(r, R.array.reminder_minutes_values); |
| 2168 | mReminderMinuteLabels = loadStringArray(r, R.array.reminder_minutes_labels); |
| 2169 | mReminderMethodValues = loadIntegerArray(r, R.array.reminder_methods_values); |
| 2170 | mReminderMethodLabels = loadStringArray(r, R.array.reminder_methods_labels); |
RoboErik | e35a032 | 2011-09-01 16:21:49 -0700 | [diff] [blame] | 2171 | |
| 2172 | // Remove any reminder methods that aren't allowed for this calendar. If this is |
| 2173 | // a new event, mCalendarAllowedReminders may not be set the first time we're called. |
RoboErik | e35a032 | 2011-09-01 16:21:49 -0700 | [diff] [blame] | 2174 | if (mCalendarAllowedReminders != null) { |
| 2175 | EventViewUtils.reduceMethodList(mReminderMethodValues, mReminderMethodLabels, |
| 2176 | mCalendarAllowedReminders); |
| 2177 | } |
| 2178 | if (mView != null) { |
| 2179 | mView.invalidate(); |
| 2180 | } |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2181 | } |
| 2182 | |
| 2183 | |
| 2184 | private boolean saveReminders() { |
| 2185 | ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>(3); |
| 2186 | |
| 2187 | // Read reminders from UI |
| 2188 | mReminders = EventViewUtils.reminderItemsToReminders(mReminderViews, |
| 2189 | mReminderMinuteValues, mReminderMethodValues); |
RoboErik | e35a032 | 2011-09-01 16:21:49 -0700 | [diff] [blame] | 2190 | mOriginalReminders.addAll(mUnsupportedReminders); |
| 2191 | Collections.sort(mOriginalReminders); |
| 2192 | mReminders.addAll(mUnsupportedReminders); |
| 2193 | Collections.sort(mReminders); |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2194 | |
| 2195 | // Check if there are any changes in the reminder |
| 2196 | boolean changed = EditEventHelper.saveReminders(ops, mEventId, mReminders, |
| 2197 | mOriginalReminders, false /* no force save */); |
| 2198 | |
| 2199 | if (!changed) { |
| 2200 | return false; |
| 2201 | } |
| 2202 | |
| 2203 | // save new reminders |
| 2204 | AsyncQueryService service = new AsyncQueryService(getActivity()); |
| 2205 | service.startBatch(0, null, Calendars.CONTENT_URI.getAuthority(), ops, 0); |
Sam Blitzstein | 9d4a952 | 2012-10-17 14:39:38 -0700 | [diff] [blame] | 2206 | mOriginalReminders = mReminders; |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2207 | // Update the "hasAlarm" field for the event |
| 2208 | Uri uri = ContentUris.withAppendedId(Events.CONTENT_URI, mEventId); |
| 2209 | int len = mReminders.size(); |
| 2210 | boolean hasAlarm = len > 0; |
| 2211 | if (hasAlarm != mHasAlarm) { |
| 2212 | ContentValues values = new ContentValues(); |
| 2213 | values.put(Events.HAS_ALARM, hasAlarm ? 1 : 0); |
| 2214 | service.startUpdate(0, null, uri, values, null, null, 0); |
| 2215 | } |
| 2216 | return true; |
| 2217 | } |
| 2218 | |
| 2219 | /** |
Sara Ting | 42896f7 | 2012-03-15 15:24:36 -0700 | [diff] [blame] | 2220 | * Email all the attendees of the event, except for the viewer (so as to not email |
| 2221 | * himself) and resources like conference rooms. |
| 2222 | */ |
| 2223 | private void emailAttendees() { |
Sara Ting | 7da2767 | 2012-07-24 16:23:53 -0700 | [diff] [blame] | 2224 | Intent i = new Intent(getActivity(), QuickResponseActivity.class); |
| 2225 | i.putExtra(QuickResponseActivity.EXTRA_EVENT_ID, mEventId); |
| 2226 | i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| 2227 | startActivity(i); |
Sara Ting | 42896f7 | 2012-03-15 15:24:36 -0700 | [diff] [blame] | 2228 | } |
| 2229 | |
| 2230 | /** |
Isaac Katzenelson | 1ce35aa | 2011-07-05 10:03:28 -0700 | [diff] [blame] | 2231 | * Loads an integer array asset into a list. |
| 2232 | */ |
| 2233 | private static ArrayList<Integer> loadIntegerArray(Resources r, int resNum) { |
| 2234 | int[] vals = r.getIntArray(resNum); |
| 2235 | int size = vals.length; |
| 2236 | ArrayList<Integer> list = new ArrayList<Integer>(size); |
| 2237 | |
| 2238 | for (int i = 0; i < size; i++) { |
| 2239 | list.add(vals[i]); |
| 2240 | } |
| 2241 | |
| 2242 | return list; |
| 2243 | } |
| 2244 | /** |
| 2245 | * Loads a String array asset into a list. |
| 2246 | */ |
| 2247 | private static ArrayList<String> loadStringArray(Resources r, int resNum) { |
| 2248 | String[] labels = r.getStringArray(resNum); |
| 2249 | ArrayList<String> list = new ArrayList<String>(Arrays.asList(labels)); |
| 2250 | return list; |
| 2251 | } |
| 2252 | |
Michael Chan | 48bcc4c | 2012-12-12 11:38:16 -0800 | [diff] [blame] | 2253 | @Override |
Isaac Katzenelson | b33cdf4 | 2011-10-14 18:15:18 -0700 | [diff] [blame] | 2254 | public void onDeleteStarted() { |
| 2255 | mEventDeletionStarted = true; |
| 2256 | } |
| 2257 | |
Isaac Katzenelson | b0a313a | 2011-10-24 11:41:56 -0700 | [diff] [blame] | 2258 | private Dialog.OnDismissListener createDeleteOnDismissListener() { |
| 2259 | return new Dialog.OnDismissListener() { |
| 2260 | @Override |
| 2261 | public void onDismiss(DialogInterface dialog) { |
| 2262 | // Since OnPause will force the dialog to dismiss , do |
| 2263 | // not change the dialog status |
| 2264 | if (!mIsPaused) { |
| 2265 | mDeleteDialogVisible = false; |
| 2266 | } |
| 2267 | } |
| 2268 | }; |
| 2269 | } |
| 2270 | |
Isaac Katzenelson | 80d640f | 2012-04-20 09:21:28 -0700 | [diff] [blame] | 2271 | public long getEventId() { |
| 2272 | return mEventId; |
| 2273 | } |
| 2274 | |
| 2275 | public long getStartMillis() { |
| 2276 | return mStartMillis; |
| 2277 | } |
| 2278 | public long getEndMillis() { |
| 2279 | return mEndMillis; |
| 2280 | } |
Michael Chan | 363aa9c | 2012-05-17 10:31:32 -0700 | [diff] [blame] | 2281 | private void setDialogSize(Resources r) { |
| 2282 | mDialogWidth = (int)r.getDimension(R.dimen.event_info_dialog_width); |
| 2283 | mDialogHeight = (int)r.getDimension(R.dimen.event_info_dialog_height); |
| 2284 | } |
James Kung | b8904fb | 2013-02-14 14:37:42 -0800 | [diff] [blame] | 2285 | |
| 2286 | @Override |
| 2287 | public void onColorSelected(int color) { |
James Kung | 497a625 | 2013-05-17 14:47:33 -0700 | [diff] [blame^] | 2288 | mCurrentColor = color; |
| 2289 | mCurrentColorKey = mDisplayColorKeyMap.get(color); |
| 2290 | mHeadlines.setBackgroundColor(color); |
James Kung | b8904fb | 2013-02-14 14:37:42 -0800 | [diff] [blame] | 2291 | } |
Mason Tang | 2bebde7 | 2010-08-04 17:20:24 -0700 | [diff] [blame] | 2292 | } |