AllInOneActivity.java revision 07d9fee87bc02849c0dd7b66326a320d53cf5479 
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
17package com.android.calendar;
18
19import static android.provider.CalendarContract.EXTRA_EVENT_BEGIN_TIME;
20import static android.provider.CalendarContract.EXTRA_EVENT_END_TIME;
21import static android.provider.CalendarContract.Attendees.ATTENDEE_STATUS;
22import static com.android.calendar.CalendarController.EVENT_ATTENDEE_RESPONSE;
23
24import com.android.calendar.CalendarController.EventHandler;
25import com.android.calendar.CalendarController.EventInfo;
26import com.android.calendar.CalendarController.EventType;
27import com.android.calendar.CalendarController.ViewType;
28import com.android.calendar.agenda.AgendaFragment;
29import com.android.calendar.month.MonthByWeekFragment;
30import com.android.calendar.selectcalendars.SelectVisibleCalendarsFragment;
31
32import android.animation.Animator;
33import android.animation.Animator.AnimatorListener;
34import android.animation.ObjectAnimator;
35import android.app.ActionBar;
36import android.app.ActionBar.Tab;
37import android.app.Activity;
38import android.app.Fragment;
39import android.app.FragmentManager;
40import android.app.FragmentTransaction;
41import android.content.ContentResolver;
42import android.content.ContentUris;
43import android.content.Intent;
44import android.content.SharedPreferences;
45import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
46import android.content.res.Resources;
47import android.database.ContentObserver;
48import android.net.Uri;
49import android.os.Bundle;
50import android.os.Handler;
51import android.provider.CalendarContract;
52import android.provider.CalendarContract.Events;
53import android.text.TextUtils;
54import android.text.format.DateFormat;
55import android.text.format.DateUtils;
56import android.text.format.Time;
57import android.util.Log;
58import android.view.Menu;
59import android.view.MenuItem;
60import android.view.View;
61import android.view.accessibility.AccessibilityEvent;
62import android.widget.RelativeLayout;
63import android.widget.RelativeLayout.LayoutParams;
64import android.widget.SearchView;
65import android.widget.SearchView.OnCloseListener;
66import android.widget.TextView;
67
68import java.util.List;
69import java.util.Locale;
70import java.util.TimeZone;
71
72public class AllInOneActivity extends Activity implements EventHandler,
73        OnSharedPreferenceChangeListener, SearchView.OnQueryTextListener, ActionBar.TabListener,
74        ActionBar.OnNavigationListener, OnCloseListener {
75    private static final String TAG = "AllInOneActivity";
76    private static final boolean DEBUG = false;
77    private static final String EVENT_INFO_FRAGMENT_TAG = "EventInfoFragment";
78    private static final String BUNDLE_KEY_RESTORE_TIME = "key_restore_time";
79    private static final String BUNDLE_KEY_EVENT_ID = "key_event_id";
80    private static final String BUNDLE_KEY_RESTORE_VIEW = "key_restore_view";
81    private static final int HANDLER_KEY = 0;
82    private static final long CONTROLS_ANIMATE_DURATION = 400;
83    private static int CONTROLS_ANIMATE_WIDTH = 280;
84    private static float mScale = 0;
85
86    // Indices of buttons for the drop down menu (tabs replacement)
87    // Must match the strings in the array buttons_list in arrays.xml and the
88    // OnNavigationListener
89    private static final int BUTTON_DAY_INDEX = 0;
90    private static final int BUTTON_WEEK_INDEX = 1;
91    private static final int BUTTON_MONTH_INDEX = 2;
92    private static final int BUTTON_AGENDA_INDEX = 3;
93
94    private static CalendarController mController;
95    private static boolean mIsMultipane;
96    private static boolean mIsTabletConfig;
97    private static boolean mShowAgendaWithMonth;
98    private static boolean mShowEventDetailsWithAgenda;
99    private boolean mOnSaveInstanceStateCalled = false;
100    private ContentResolver mContentResolver;
101    private int mPreviousView;
102    private int mCurrentView;
103    private boolean mPaused = true;
104    private boolean mUpdateOnResume = false;
105    private boolean mHideControls = false;
106    private boolean mShowSideViews = true;
107    private boolean mShowWeekNum = false;
108    private TextView mHomeTime;
109    private TextView mDateRange;
110    private TextView mWeekTextView;
111    private View mMiniMonth;
112    private View mCalendarsList;
113    private View mMiniMonthContainer;
114    private View mSecondaryPane;
115    private String mTimeZone;
116    private boolean mShowCalendarControls;
117    private boolean mShowEventInfoFullScreen;
118    private int mWeekNum;
119
120    private long mViewEventId = -1;
121    private long mIntentEventStartMillis = -1;
122    private long mIntentEventEndMillis = -1;
123    private int mIntentAttendeeResponse = CalendarController.ATTENDEE_NO_RESPONSE;
124
125    // Action bar and Navigation bar (left side of Action bar)
126    private ActionBar mActionBar;
127    private ActionBar.Tab mDayTab;
128    private ActionBar.Tab mWeekTab;
129    private ActionBar.Tab mMonthTab;
130    private ActionBar.Tab mAgendaTab;
131    private SearchView mSearchView;
132    private MenuItem mSearchMenu;
133    private MenuItem mControlsMenu;
134    private Menu mOptionsMenu;
135    private CalendarViewAdapter mActionBarMenuSpinnerAdapter;
136
137    private String mHideString;
138    private String mShowString;
139
140    // Params for animating the controls on the right
141    private LayoutParams mControlsParams = new LayoutParams(CONTROLS_ANIMATE_WIDTH, 0);
142
143    private AnimatorListener mSlideAnimationDoneListener = new AnimatorListener() {
144
145        @Override
146        public void onAnimationCancel(Animator animation) {
147        }
148
149        @Override
150        public void onAnimationEnd(android.animation.Animator animation) {
151            int visibility = mShowSideViews ? View.VISIBLE : View.GONE;
152            mMiniMonth.setVisibility(visibility);
153            mCalendarsList.setVisibility(visibility);
154            mMiniMonthContainer.setVisibility(visibility);
155        }
156
157        @Override
158        public void onAnimationRepeat(android.animation.Animator animation) {
159        }
160
161        @Override
162        public void onAnimationStart(android.animation.Animator animation) {
163        }
164    };
165
166    private Runnable mHomeTimeUpdater = new Runnable() {
167        @Override
168        public void run() {
169            updateHomeClockAndWeekNum(-1);
170        }
171    };
172
173    // Create an observer so that we can update the views whenever a
174    // Calendar event changes.
175    private ContentObserver mObserver = new ContentObserver(new Handler()) {
176        @Override
177        public boolean deliverSelfNotifications() {
178            return true;
179        }
180
181        @Override
182        public void onChange(boolean selfChange) {
183            eventsChanged();
184        }
185    };
186
187    @Override
188    protected void onNewIntent(Intent intent) {
189        String action = intent.getAction();
190        if (Intent.ACTION_VIEW.equals(action)) {
191            parseViewAction(intent);
192        }
193    }
194
195    @Override
196    protected void onCreate(Bundle icicle) {
197        if (Utils.getSharedPreference(this, OtherPreferences.KEY_OTHER_1, false)) {
198            setTheme(R.style.CalendarTheme_WithActionBarWallpaper);
199        }
200        super.onCreate(icicle);
201
202        // This needs to be created before setContentView
203        mController = CalendarController.getInstance(this);
204        // Get time from intent or icicle
205        long timeMillis = -1;
206        int viewType = -1;
207        final Intent intent = getIntent();
208        if (icicle != null) {
209            timeMillis = icicle.getLong(BUNDLE_KEY_RESTORE_TIME);
210            viewType = icicle.getInt(BUNDLE_KEY_RESTORE_VIEW, -1);
211        } else {
212            String action = intent.getAction();
213            if (Intent.ACTION_VIEW.equals(action)) {
214                // Open EventInfo later
215                timeMillis = parseViewAction(intent);
216            }
217
218            if (timeMillis == -1) {
219                timeMillis = Utils.timeFromIntentInMillis(intent);
220            }
221        }
222
223        if (viewType == -1) {
224            viewType = Utils.getViewTypeFromIntentAndSharedPref(this);
225        }
226        mTimeZone = Utils.getTimeZone(this, mHomeTimeUpdater);
227        Time t = new Time(mTimeZone);
228        t.set(timeMillis);
229
230        if (icicle != null && intent != null) {
231            Log.d(TAG, "both, icicle:" + icicle.toString() + "  intent:" + intent.toString());
232        } else {
233            Log.d(TAG, "not both, icicle:" + icicle + " intent:" + intent);
234        }
235
236        Resources res = getResources();
237        if (mScale == 0) {
238            mScale = res.getDisplayMetrics().density;
239            CONTROLS_ANIMATE_WIDTH *= mScale;
240        }
241        mHideString = res.getString(R.string.hide_controls);
242        mShowString = res.getString(R.string.show_controls);
243        mControlsParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
244
245        mIsMultipane = Utils.isMultiPaneConfiguration(this);
246        mIsTabletConfig = Utils.getConfigBool(this, R.bool.tablet_config);
247        mShowAgendaWithMonth = Utils.getConfigBool(this, R.bool.show_agenda_with_month);
248        mShowCalendarControls = Utils.getConfigBool(this, R.bool.show_calendar_controls);
249        mShowEventDetailsWithAgenda =
250            Utils.getConfigBool(this, R.bool.show_event_details_with_agenda);
251        mShowEventInfoFullScreen =
252            Utils.getConfigBool(this, R.bool.show_event_info_full_screen);
253
254        Utils.setAllowWeekForDetailView(mIsMultipane);
255
256        // setContentView must be called before configureActionBar
257        setContentView(R.layout.all_in_one);
258
259        if (mIsTabletConfig) {
260            mDateRange = (TextView) findViewById(R.id.date_bar);
261            mWeekTextView = (TextView) findViewById(R.id.week_num);
262        } else {
263            mDateRange = (TextView) getLayoutInflater().inflate(R.layout.date_range_title, null);
264        }
265
266        // configureActionBar auto-selects the first tab you add, so we need to
267        // call it before we set up our own fragments to make sure it doesn't
268        // overwrite us
269        configureActionBar(viewType);
270
271        // Must be the first to register because this activity can modify the
272        // list of event handlers in it's handle method. This affects who the
273        // rest of the handlers the controller dispatches to are.
274        mController.registerEventHandler(HANDLER_KEY, this);
275
276        mHomeTime = (TextView) findViewById(R.id.home_time);
277        mMiniMonth = findViewById(R.id.mini_month);
278        mCalendarsList = findViewById(R.id.calendar_list);
279        mMiniMonthContainer = findViewById(R.id.mini_month_container);
280        mSecondaryPane = findViewById(R.id.secondary_pane);
281
282        initFragments(timeMillis, viewType, icicle);
283
284        // Listen for changes that would require this to be refreshed
285        SharedPreferences prefs = GeneralPreferences.getSharedPreferences(this);
286        prefs.registerOnSharedPreferenceChangeListener(this);
287
288        mContentResolver = getContentResolver();
289    }
290
291    private long parseViewAction(final Intent intent) {
292        long timeMillis = -1;
293        Uri data = intent.getData();
294        if (data != null && data.isHierarchical()) {
295            List<String> path = data.getPathSegments();
296            if (path.size() == 2 && path.get(0).equals("events")) {
297                try {
298                    mViewEventId = Long.valueOf(data.getLastPathSegment());
299                    if (mViewEventId != -1) {
300                        mIntentEventStartMillis = intent.getLongExtra(EXTRA_EVENT_BEGIN_TIME, 0);
301                        mIntentEventEndMillis = intent.getLongExtra(EXTRA_EVENT_END_TIME, 0);
302                        mIntentAttendeeResponse = intent.getIntExtra(
303                                ATTENDEE_STATUS, CalendarController.ATTENDEE_NO_RESPONSE);
304                        timeMillis = mIntentEventStartMillis;
305                    }
306                } catch (NumberFormatException e) {
307                    // Ignore if mViewEventId can't be parsed
308                }
309            }
310        }
311        return timeMillis;
312    }
313
314    private void configureActionBar(int viewType) {
315        if (mIsTabletConfig) {
316            createTabs();
317        } else {
318            createButtonsSpinner(viewType);
319            mActionBar.setCustomView(mDateRange);
320        }
321        if (mIsMultipane) {
322            mActionBar.setDisplayOptions(
323                    ActionBar.DISPLAY_SHOW_CUSTOM | ActionBar.DISPLAY_SHOW_HOME);
324        } else {
325            mActionBar.setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM);
326        }
327    }
328
329    private void createTabs() {
330        mActionBar = getActionBar();
331        if (mActionBar == null) {
332            Log.w(TAG, "ActionBar is null.");
333        } else {
334            mActionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
335            mDayTab = mActionBar.newTab();
336            mDayTab.setText(getString(R.string.day_view));
337            mDayTab.setTabListener(this);
338            mActionBar.addTab(mDayTab);
339            mWeekTab = mActionBar.newTab();
340            mWeekTab.setText(getString(R.string.week_view));
341            mWeekTab.setTabListener(this);
342            mActionBar.addTab(mWeekTab);
343            mMonthTab = mActionBar.newTab();
344            mMonthTab.setText(getString(R.string.month_view));
345            mMonthTab.setTabListener(this);
346            mActionBar.addTab(mMonthTab);
347            mAgendaTab = mActionBar.newTab();
348            mAgendaTab.setText(getString(R.string.agenda_view));
349            mAgendaTab.setTabListener(this);
350            mActionBar.addTab(mAgendaTab);
351        }
352    }
353
354    private void createButtonsSpinner(int viewType) {
355        mActionBarMenuSpinnerAdapter = new CalendarViewAdapter (this, viewType);
356        mActionBar = getActionBar();
357        mActionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_LIST);
358        mActionBar.setDisplayOptions(0, ActionBar.DISPLAY_SHOW_HOME|ActionBar.DISPLAY_USE_LOGO|
359                ActionBar.DISPLAY_SHOW_TITLE);
360        mActionBar.setListNavigationCallbacks(mActionBarMenuSpinnerAdapter, this);
361        switch (viewType) {
362            case ViewType.AGENDA:
363                mActionBar.setSelectedNavigationItem(BUTTON_AGENDA_INDEX);
364                break;
365            case ViewType.DAY:
366                mActionBar.setSelectedNavigationItem(BUTTON_DAY_INDEX);
367                break;
368            case ViewType.WEEK:
369                mActionBar.setSelectedNavigationItem(BUTTON_WEEK_INDEX);
370                break;
371            case ViewType.MONTH:
372                mActionBar.setSelectedNavigationItem(BUTTON_MONTH_INDEX);
373                break;
374            default:
375                mActionBar.setSelectedNavigationItem(BUTTON_DAY_INDEX);
376                break;
377       }
378    }
379    // Clear buttons used in the agenda view
380    private void clearOptionsMenu() {
381        if (mOptionsMenu == null) {
382            return;
383        }
384        MenuItem cancelItem = mOptionsMenu.findItem(R.id.action_cancel);
385        MenuItem editItem = mOptionsMenu.findItem(R.id.action_edit);
386        if (cancelItem != null) {
387            cancelItem.setVisible(false);
388        }
389        if (editItem != null) {
390            editItem.setVisible(false);
391        }
392    }
393
394    @Override
395    protected void onResume() {
396        super.onResume();
397        mContentResolver.registerContentObserver(CalendarContract.Events.CONTENT_URI,
398                true, mObserver);
399        if (mUpdateOnResume) {
400            initFragments(mController.getTime(), mController.getViewType(), null);
401            mUpdateOnResume = false;
402        }
403        updateHomeClockAndWeekNum(mController.getTime());
404        // Make sure the drop-down menu will get its date updated at midnight
405        if (mActionBarMenuSpinnerAdapter != null) {
406            mActionBarMenuSpinnerAdapter.setMidnightHandler();
407        }
408
409        if (mControlsMenu != null) {
410            mControlsMenu.setTitle(mHideControls ? mShowString : mHideString);
411        }
412        mPaused = false;
413        mOnSaveInstanceStateCalled = false;
414
415        if (mViewEventId != -1 && mIntentEventStartMillis != -1 && mIntentEventEndMillis != -1) {
416            long currentMillis = System.currentTimeMillis();
417            long selectedTime = -1;
418            if (currentMillis > mIntentEventStartMillis && currentMillis < mIntentEventEndMillis) {
419                selectedTime = currentMillis;
420            }
421            mController.sendEventRelatedEventWithResponse(this, EventType.VIEW_EVENT, mViewEventId,
422                    mIntentEventStartMillis, mIntentEventEndMillis, -1, -1,
423                    mIntentAttendeeResponse, selectedTime);
424            mViewEventId = -1;
425            mIntentEventStartMillis = -1;
426            mIntentEventEndMillis = -1;
427        }
428    }
429
430    @Override
431    protected void onPause() {
432        super.onPause();
433        mPaused = true;
434        mHomeTime.removeCallbacks(mHomeTimeUpdater);
435        if (mActionBarMenuSpinnerAdapter != null) {
436            mActionBarMenuSpinnerAdapter.resetMidnightHandler();
437        }
438        mContentResolver.unregisterContentObserver(mObserver);
439        if (isFinishing()) {
440            // Stop listening for changes that would require this to be refreshed
441            SharedPreferences prefs = GeneralPreferences.getSharedPreferences(this);
442            prefs.unregisterOnSharedPreferenceChangeListener(this);
443        }
444        // FRAG_TODO save highlighted days of the week;
445        if (mController.getViewType() != ViewType.EDIT) {
446            Utils.setDefaultView(this, mController.getViewType());
447        }
448    }
449
450    @Override
451    protected void onUserLeaveHint() {
452        mController.sendEvent(this, EventType.USER_HOME, null, null, -1, ViewType.CURRENT);
453        super.onUserLeaveHint();
454    }
455
456    @Override
457    public void onSaveInstanceState(Bundle outState) {
458        mOnSaveInstanceStateCalled = true;
459        super.onSaveInstanceState(outState);
460
461        outState.putLong(BUNDLE_KEY_RESTORE_TIME, mController.getTime());
462        if (mCurrentView == ViewType.EDIT) {
463            outState.putInt(BUNDLE_KEY_RESTORE_VIEW, mCurrentView);
464            outState.putLong(BUNDLE_KEY_EVENT_ID, mController.getEventId());
465        }
466    }
467
468    @Override
469    protected void onDestroy() {
470        super.onDestroy();
471
472        SharedPreferences prefs = GeneralPreferences.getSharedPreferences(this);
473        prefs.unregisterOnSharedPreferenceChangeListener(this);
474        CalendarController.removeInstance(this);
475    }
476
477    private void initFragments(long timeMillis, int viewType, Bundle icicle) {
478        if (DEBUG) {
479            Log.d(TAG, "Initializing to " + timeMillis + " for view " + viewType);
480        }
481        FragmentTransaction ft = getFragmentManager().beginTransaction();
482
483        if (mShowCalendarControls) {
484            Fragment miniMonthFrag = new MonthByWeekFragment(timeMillis, true);
485            ft.replace(R.id.mini_month, miniMonthFrag);
486            mController.registerEventHandler(R.id.mini_month, (EventHandler) miniMonthFrag);
487
488            Fragment selectCalendarsFrag = new SelectVisibleCalendarsFragment();
489            ft.replace(R.id.calendar_list, selectCalendarsFrag);
490            mController.registerEventHandler(
491                    R.id.calendar_list, (EventHandler) selectCalendarsFrag);
492        }
493        if (!mShowCalendarControls || viewType == ViewType.EDIT) {
494            mMiniMonth.setVisibility(View.GONE);
495            mCalendarsList.setVisibility(View.GONE);
496        }
497
498        EventInfo info = null;
499        if (viewType == ViewType.EDIT) {
500            mPreviousView = GeneralPreferences.getSharedPreferences(this).getInt(
501                    GeneralPreferences.KEY_START_VIEW, GeneralPreferences.DEFAULT_START_VIEW);
502
503            long eventId = -1;
504            Intent intent = getIntent();
505            Uri data = intent.getData();
506            if (data != null) {
507                try {
508                    eventId = Long.parseLong(data.getLastPathSegment());
509                } catch (NumberFormatException e) {
510                    if (DEBUG) {
511                        Log.d(TAG, "Create new event");
512                    }
513                }
514            } else if (icicle != null && icicle.containsKey(BUNDLE_KEY_EVENT_ID)) {
515                eventId = icicle.getLong(BUNDLE_KEY_EVENT_ID);
516            }
517
518            long begin = intent.getLongExtra(EXTRA_EVENT_BEGIN_TIME, -1);
519            long end = intent.getLongExtra(EXTRA_EVENT_END_TIME, -1);
520            info = new EventInfo();
521            if (end != -1) {
522                info.endTime = new Time();
523                info.endTime.set(end);
524            }
525            if (begin != -1) {
526                info.startTime = new Time();
527                info.startTime.set(begin);
528            }
529            info.id = eventId;
530            // We set the viewtype so if the user presses back when they are
531            // done editing the controller knows we were in the Edit Event
532            // screen. Likewise for eventId
533            mController.setViewType(viewType);
534            mController.setEventId(eventId);
535        } else {
536            mPreviousView = viewType;
537        }
538
539        setMainPane(ft, R.id.main_pane, viewType, timeMillis, true);
540        ft.commit(); // this needs to be after setMainPane()
541
542        Time t = new Time(mTimeZone);
543        t.set(timeMillis);
544        if (viewType != ViewType.EDIT) {
545            mController.sendEvent(this, EventType.GO_TO, t, null, -1, viewType);
546        }
547    }
548
549    @Override
550    public void onBackPressed() {
551        if (mCurrentView == ViewType.EDIT || mCurrentView == ViewType.DETAIL) {
552            mController.sendEvent(this, EventType.GO_TO, null, null, -1, mPreviousView);
553        } else {
554            super.onBackPressed();
555        }
556    }
557
558    @Override
559    public boolean onCreateOptionsMenu(Menu menu) {
560        super.onCreateOptionsMenu(menu);
561        mOptionsMenu = menu;
562        getMenuInflater().inflate(R.menu.all_in_one_title_bar, menu);
563
564        mSearchMenu = menu.findItem(R.id.action_search);
565        mSearchView = (SearchView) mSearchMenu.getActionView();
566        if (mSearchView != null) {
567            mSearchView.setIconifiedByDefault(true);
568            mSearchView.setOnQueryTextListener(this);
569            mSearchView.setSubmitButtonEnabled(true);
570            mSearchView.setOnCloseListener(this);
571        }
572
573        // Hide the "show/hide controls" button if this is a phone
574        // or the view type is "Month" or "Agenda".
575
576        mControlsMenu = menu.findItem(R.id.action_hide_controls);
577        if (!mShowCalendarControls) {
578            if (mControlsMenu != null) {
579                mControlsMenu.setVisible(false);
580                mControlsMenu.setEnabled(false);
581            }
582        } else if (mControlsMenu != null && mController != null
583                    && (mController.getViewType() == ViewType.MONTH ||
584                        mController.getViewType() == ViewType.AGENDA)) {
585            mControlsMenu.setVisible(false);
586            mControlsMenu.setEnabled(false);
587        } else if (mControlsMenu != null){
588            mControlsMenu.setTitle(mHideControls ? mShowString : mHideString);
589        }
590        return true;
591    }
592
593    @Override
594    public boolean onOptionsItemSelected(MenuItem item) {
595        Time t = null;
596        int viewType = ViewType.CURRENT;
597        switch (item.getItemId()) {
598            case R.id.action_refresh:
599                mController.refreshCalendars();
600                return true;
601            case R.id.action_today:
602                viewType = ViewType.CURRENT;
603                t = new Time(mTimeZone);
604                t.setToNow();
605                break;
606            case R.id.action_create_event:
607                t = new Time();
608                t.set(mController.getTime());
609                if (t.minute >= 30) {
610                    t.hour++;
611                    t.minute = 0;
612                } else {
613                    t.minute = 30;
614                }
615                mController.sendEventRelatedEvent(
616                        this, EventType.CREATE_EVENT, -1, t.toMillis(true), 0, 0, 0, -1);
617                return true;
618            case R.id.action_select_visible_calendars:
619                mController.sendEvent(this, EventType.LAUNCH_SELECT_VISIBLE_CALENDARS, null, null,
620                        0, 0);
621                return true;
622            case R.id.action_settings:
623                mController.sendEvent(this, EventType.LAUNCH_SETTINGS, null, null, 0, 0);
624                return true;
625            case R.id.action_hide_controls:
626                mHideControls = !mHideControls;
627                item.setTitle(mHideControls ? mShowString : mHideString);
628                final ObjectAnimator slideAnimation = ObjectAnimator.ofInt(this, "controlsOffset",
629                        mHideControls ? 0 : CONTROLS_ANIMATE_WIDTH,
630                        mHideControls ? CONTROLS_ANIMATE_WIDTH : 0);
631                slideAnimation.setDuration(CONTROLS_ANIMATE_DURATION);
632                ObjectAnimator.setFrameDelay(0);
633                slideAnimation.start();
634                return true;
635            case R.id.action_search:
636                if (!mIsMultipane && mSearchView != null) {
637                    item.setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS);
638                    mSearchView.setActivated(true);
639                    mSearchView.setIconified(false);
640                }
641            default:
642                return false;
643        }
644        mController.sendEvent(this, EventType.GO_TO, t, null, -1, viewType);
645        return true;
646    }
647
648    /**
649     * Sets the offset of the controls on the right for animating them off/on
650     * screen. ProGuard strips this if it's not in proguard.flags
651     *
652     * @param controlsOffset The current offset in pixels
653     */
654    public void setControlsOffset(int controlsOffset) {
655        mMiniMonth.setTranslationX(controlsOffset);
656        mCalendarsList.setTranslationX(controlsOffset);
657        mControlsParams.width = Math.max(0, CONTROLS_ANIMATE_WIDTH - controlsOffset);
658        mMiniMonthContainer.setLayoutParams(mControlsParams);
659    }
660
661    @Override
662    public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
663        if (key.equals(GeneralPreferences.KEY_WEEK_START_DAY)) {
664            if (mPaused) {
665                mUpdateOnResume = true;
666            } else {
667                initFragments(mController.getTime(), mController.getViewType(), null);
668            }
669        }
670    }
671
672    private void setMainPane(
673            FragmentTransaction ft, int viewId, int viewType, long timeMillis, boolean force) {
674        if (mOnSaveInstanceStateCalled) {
675            return;
676        }
677        if (!force && mCurrentView == viewType) {
678            return;
679        }
680
681        // Remove this when transition to and from month view looks fine.
682        boolean doTransition = viewType != ViewType.MONTH && mCurrentView != ViewType.MONTH;
683        FragmentManager fragmentManager = getFragmentManager();
684        // Check if our previous view was an Agenda view
685        // TODO remove this if framework ever supports nested fragments
686        if (mCurrentView == ViewType.AGENDA) {
687            // If it was, we need to do some cleanup on it to prevent the
688            // edit/delete buttons from coming back on a rotation.
689            Fragment oldFrag = fragmentManager.findFragmentById(viewId);
690            if (oldFrag instanceof AgendaFragment) {
691                ((AgendaFragment) oldFrag).removeFragments(fragmentManager);
692            }
693        }
694
695        if (viewType != mCurrentView) {
696            // The rules for this previous view are different than the
697            // controller's and are used for intercepting the back button.
698            if (mCurrentView != ViewType.EDIT && mCurrentView > 0) {
699                mPreviousView = mCurrentView;
700            }
701            mCurrentView = viewType;
702        }
703        // Create new fragment
704        Fragment frag = null;
705        Fragment secFrag = null;
706        switch (viewType) {
707            case ViewType.AGENDA:
708                if (mActionBar != null && (mActionBar.getSelectedTab() != mAgendaTab)) {
709                    mActionBar.selectTab(mAgendaTab);
710                }
711                if (mActionBarMenuSpinnerAdapter != null) {
712                    mActionBar.setSelectedNavigationItem(CalendarViewAdapter.AGENDA_BUTTON_INDEX);
713                }
714                frag = new AgendaFragment(timeMillis, false);
715                break;
716            case ViewType.DAY:
717                if (mActionBar != null && (mActionBar.getSelectedTab() != mDayTab)) {
718                    mActionBar.selectTab(mDayTab);
719                }
720                if (mActionBarMenuSpinnerAdapter != null) {
721                    mActionBar.setSelectedNavigationItem(CalendarViewAdapter.DAY_BUTTON_INDEX);
722                }
723                frag = new DayFragment(timeMillis, 1);
724                break;
725            case ViewType.WEEK:
726                if (mActionBar != null && (mActionBar.getSelectedTab() != mWeekTab)) {
727                    mActionBar.selectTab(mWeekTab);
728                }
729                if (mActionBarMenuSpinnerAdapter != null) {
730                    mActionBar.setSelectedNavigationItem(CalendarViewAdapter.WEEK_BUTTON_INDEX);
731                }
732                frag = new DayFragment(timeMillis, 7);
733                break;
734            case ViewType.MONTH:
735                if (mActionBar != null && (mActionBar.getSelectedTab() != mMonthTab)) {
736                    mActionBar.selectTab(mMonthTab);
737                }
738                if (mActionBarMenuSpinnerAdapter != null) {
739                    mActionBar.setSelectedNavigationItem(CalendarViewAdapter.MONTH_BUTTON_INDEX);
740                }
741                frag = new MonthByWeekFragment(timeMillis, false);
742                if (mShowAgendaWithMonth) {
743                    secFrag = new AgendaFragment(timeMillis, false);
744                }
745                break;
746            default:
747                throw new IllegalArgumentException(
748                        "Must be Agenda, Day, Week, or Month ViewType, not " + viewType);
749        }
750
751        // Update the current view so that the menu can update its look according to the
752        // current view.
753        if (!mIsTabletConfig && mActionBarMenuSpinnerAdapter != null) {
754            mActionBarMenuSpinnerAdapter.setMainView(viewType);
755        }
756
757
758        // Show date only on tablet configurations in views different than Agenda
759        if (!mIsTabletConfig) {
760            mDateRange.setVisibility(View.GONE);
761        } else if (viewType != ViewType.AGENDA) {
762            mDateRange.setVisibility(View.VISIBLE);
763        } else {
764            mDateRange.setVisibility(View.GONE);
765        }
766
767        // Clear unnecessary buttons from the option menu when switching from the agenda view
768        if (viewType != ViewType.AGENDA) {
769            clearOptionsMenu();
770        }
771
772        boolean doCommit = false;
773        if (ft == null) {
774            doCommit = true;
775            ft = fragmentManager.beginTransaction();
776        }
777
778        if (doTransition) {
779            ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
780        }
781
782        ft.replace(viewId, frag);
783        if (mShowAgendaWithMonth) {
784
785            // Show/hide secondary fragment
786
787            if (secFrag != null) {
788                ft.replace(R.id.secondary_pane, secFrag);
789                mSecondaryPane.setVisibility(View.VISIBLE);
790            } else {
791                mSecondaryPane.setVisibility(View.GONE);
792                Fragment f = fragmentManager.findFragmentById(R.id.secondary_pane);
793                if (f != null) {
794                    ft.remove(f);
795                }
796                mController.deregisterEventHandler(R.id.secondary_pane);
797            }
798        }
799        if (DEBUG) {
800            Log.d(TAG, "Adding handler with viewId " + viewId + " and type " + viewType);
801        }
802        // If the key is already registered this will replace it
803        mController.registerEventHandler(viewId, (EventHandler) frag);
804        if (secFrag != null) {
805            mController.registerEventHandler(viewId, (EventHandler) secFrag);
806        }
807
808        if (doCommit) {
809            Log.d(TAG, "setMainPane AllInOne=" + this + " finishing:" + this.isFinishing());
810            ft.commit();
811        }
812    }
813
814    private void setTitleInActionBar(EventInfo event) {
815        if (event.eventType != EventType.UPDATE_TITLE || mActionBar == null) {
816            return;
817        }
818
819        final long start = event.startTime.toMillis(false /* use isDst */);
820        final long end;
821        if (event.endTime != null) {
822            end = event.endTime.toMillis(false /* use isDst */);
823        } else {
824            end = start;
825        }
826
827        final String msg = Utils.formatDateRange(this, start, end, (int) event.extraLong);
828        CharSequence oldDate = mDateRange.getText();
829        mDateRange.setText(msg);
830        updateHomeClockAndWeekNum(start);
831        if (!TextUtils.equals(oldDate, msg)) {
832            mDateRange.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
833            if (mShowWeekNum && mWeekTextView != null) {
834                mWeekTextView.sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_FOCUSED);
835            }
836        }
837    }
838
839    private void updateHomeClockAndWeekNum(long visibleMillisSinceEpoch) {
840        mShowWeekNum = Utils.getShowWeekNumber(this);
841        mTimeZone = Utils.getTimeZone(this, mHomeTimeUpdater);
842        if (visibleMillisSinceEpoch != -1) {
843            int weekNum = Utils.getWeekNumberFromTime(visibleMillisSinceEpoch, this);
844            mWeekNum = weekNum;
845        }
846
847        if (mShowWeekNum && (mCurrentView == ViewType.WEEK) && mIsTabletConfig
848                && mWeekTextView != null) {
849            String weekString = getResources().getQuantityString(R.plurals.weekN, mWeekNum,
850                    mWeekNum);
851            mWeekTextView.setText(weekString);
852            mWeekTextView.setVisibility(View.VISIBLE);
853        } else if (mWeekTextView != null) {
854            mWeekTextView.setVisibility(View.GONE);
855        }
856        if (mHomeTime != null
857                && (mCurrentView == ViewType.DAY || mCurrentView == ViewType.WEEK
858                        || mCurrentView == ViewType.AGENDA)
859                && !TextUtils.equals(mTimeZone, Time.getCurrentTimezone())) {
860            Time time = new Time(mTimeZone);
861            time.setToNow();
862            long millis = time.toMillis(true);
863            boolean isDST = time.isDst != 0;
864            int flags = DateUtils.FORMAT_SHOW_TIME;
865            if (DateFormat.is24HourFormat(this)) {
866                flags |= DateUtils.FORMAT_24HOUR;
867            }
868            // Formats the time as
869            String timeString = (new StringBuilder(
870                    Utils.formatDateRange(this, millis, millis, flags))).append(" ").append(
871                    TimeZone.getTimeZone(mTimeZone).getDisplayName(
872                            isDST, TimeZone.SHORT, Locale.getDefault())).toString();
873            mHomeTime.setText(timeString);
874            mHomeTime.setVisibility(View.VISIBLE);
875            // Update when the minute changes
876            mHomeTime.postDelayed(
877                    mHomeTimeUpdater,
878                    DateUtils.MINUTE_IN_MILLIS - (millis % DateUtils.MINUTE_IN_MILLIS));
879        } else if (mHomeTime != null) {
880            mHomeTime.setVisibility(View.GONE);
881        }
882    }
883
884    @Override
885    public long getSupportedEventTypes() {
886        return EventType.GO_TO | EventType.VIEW_EVENT | EventType.UPDATE_TITLE;
887    }
888
889    @Override
890    public void handleEvent(EventInfo event) {
891        long displayTime = -1;
892        if (event.eventType == EventType.GO_TO) {
893            setMainPane(
894                    null, R.id.main_pane, event.viewType, event.startTime.toMillis(false), false);
895            if (mSearchView != null) {
896                mSearchView.clearFocus();
897            }
898
899            if (mShowCalendarControls) {
900                if (event.viewType == ViewType.MONTH || event.viewType == ViewType.AGENDA) {
901                    // hide minimonth and calendar frag
902                    mShowSideViews = false;
903                    if (mControlsMenu != null) {
904                        mControlsMenu.setVisible(false);
905                        mControlsMenu.setEnabled(false);
906
907                        if (!mHideControls) {
908                            final ObjectAnimator slideAnimation = ObjectAnimator.ofInt(this,
909                                    "controlsOffset", 0, CONTROLS_ANIMATE_WIDTH);
910                            slideAnimation.addListener(mSlideAnimationDoneListener);
911                            slideAnimation.setDuration(220);
912                            ObjectAnimator.setFrameDelay(0);
913                            slideAnimation.start();
914                        }
915                    } else {
916                        mMiniMonth.setVisibility(View.GONE);
917                        mCalendarsList.setVisibility(View.GONE);
918                        mMiniMonthContainer.setVisibility(View.GONE);
919                    }
920                } else {
921                    // show minimonth and calendar frag
922                    mShowSideViews = true;
923                    mMiniMonth.setVisibility(View.VISIBLE);
924                    mCalendarsList.setVisibility(View.VISIBLE);
925                    mMiniMonthContainer.setVisibility(View.VISIBLE);
926                    if (mControlsMenu != null) {
927                        mControlsMenu.setVisible(true);
928                        mControlsMenu.setEnabled(true);
929                        if (!mHideControls &&
930                                (mController.getPreviousViewType() == ViewType.MONTH ||
931                                 mController.getPreviousViewType() == ViewType.AGENDA)) {
932                            final ObjectAnimator slideAnimation = ObjectAnimator.ofInt(this,
933                                    "controlsOffset", CONTROLS_ANIMATE_WIDTH, 0);
934                            slideAnimation.setDuration(220);
935                            ObjectAnimator.setFrameDelay(0);
936                            slideAnimation.start();
937                        }
938                    }
939                }
940            }
941            displayTime = event.startTime.toMillis(true);
942        } else if (event.eventType == EventType.VIEW_EVENT) {
943
944            // If in Agenda view and "show_event_details_with_agenda" is "true",
945            // do not create the event info fragment here, it will be created by the Agenda
946            // fragment
947
948            if (mCurrentView == ViewType.AGENDA && mShowEventDetailsWithAgenda) {
949                if (event.startTime != null && event.endTime != null) {
950                    mController.sendEvent(this, EventType.GO_TO, event.startTime, event.endTime,
951                            event.id, ViewType.AGENDA);
952                } else if (event.selectedTime != null) {
953                    mController.sendEvent(this, EventType.GO_TO, event.selectedTime,
954                        event.selectedTime, event.id, ViewType.AGENDA);
955                }
956            } else {
957                if (mShowEventInfoFullScreen) {
958                    // start event info as activity
959                    Intent intent = new Intent(Intent.ACTION_VIEW);
960                    Uri eventUri = ContentUris.withAppendedId(Events.CONTENT_URI, event.id);
961                    intent.setData(eventUri);
962                    intent.setClass(this, EventInfoActivity.class);
963                    intent.setFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT |
964                            Intent.FLAG_ACTIVITY_SINGLE_TOP);
965                    intent.putExtra(EXTRA_EVENT_BEGIN_TIME, event.startTime.toMillis(false));
966                    intent.putExtra(EXTRA_EVENT_END_TIME, event.endTime.toMillis(false));
967                    intent.putExtra(EVENT_ATTENDEE_RESPONSE, (int)event.extraLong);
968                    startActivity(intent);
969                } else {
970                    // start event info as a dialog
971                    EventInfoFragment fragment = new EventInfoFragment(this,
972                            event.id, event.startTime.toMillis(false),
973                            event.endTime.toMillis(false), (int) event.extraLong, true);
974                    // TODO Fix the temp hack below: && mCurrentView !=
975                    // ViewType.AGENDA
976                    if (event.selectedTime != null && mCurrentView != ViewType.AGENDA) {
977                        mController.sendEvent(this, EventType.GO_TO, event.selectedTime,
978                                event.selectedTime, -1, ViewType.DETAIL);
979                    }
980                    fragment.setDialogParams(event.x, event.y);
981                    FragmentManager fm = getFragmentManager();
982                    FragmentTransaction ft = fm.beginTransaction();
983                    // if we have an old popup close it
984                    Fragment fOld = fm.findFragmentByTag(EVENT_INFO_FRAGMENT_TAG);
985                    if (fOld != null && fOld.isAdded()) {
986                        ft.remove(fOld);
987                    }
988                    ft.add(fragment, EVENT_INFO_FRAGMENT_TAG);
989                    ft.commit();
990                }
991            }
992            displayTime = event.startTime.toMillis(true);
993        } else if (event.eventType == EventType.UPDATE_TITLE) {
994            setTitleInActionBar(event);
995            if (!mIsTabletConfig) {
996                mActionBarMenuSpinnerAdapter.setTime(event.startTime.toMillis(false));
997            }
998        }
999        updateHomeClockAndWeekNum(displayTime);
1000    }
1001
1002    // Needs to be in proguard whitelist
1003    // Specified as listener via android:onClick in a layout xml
1004    public void handleSelectSyncedCalendarsClicked(View v) {
1005        mController.sendEvent(this, EventType.LAUNCH_SETTINGS, null, null, null, 0, 0,
1006                CalendarController.EXTRA_GOTO_TIME, null,
1007                null);
1008    }
1009
1010    @Override
1011    public void eventsChanged() {
1012        mController.sendEvent(this, EventType.EVENTS_CHANGED, null, null, -1, ViewType.CURRENT);
1013    }
1014
1015    @Override
1016    public boolean onQueryTextChange(String newText) {
1017        return false;
1018    }
1019
1020    @Override
1021    public boolean onQueryTextSubmit(String query) {
1022        if ("TARDIS".equalsIgnoreCase(query)) {
1023            Utils.tardis();
1024        }
1025        mSearchView.clearFocus();
1026        mController.sendEvent(this, EventType.SEARCH, null, null, -1, ViewType.CURRENT, -1, query,
1027                getComponentName());
1028        return false;
1029    }
1030
1031    @Override
1032    public void onTabSelected(Tab tab, FragmentTransaction ft) {
1033        Log.w(TAG, "TabSelected AllInOne=" + this + " finishing:" + this.isFinishing());
1034        if (tab == mDayTab && mCurrentView != ViewType.DAY) {
1035            mController.sendEvent(this, EventType.GO_TO, null, null, -1, ViewType.DAY);
1036        } else if (tab == mWeekTab && mCurrentView != ViewType.WEEK) {
1037            mController.sendEvent(this, EventType.GO_TO, null, null, -1, ViewType.WEEK);
1038        } else if (tab == mMonthTab && mCurrentView != ViewType.MONTH) {
1039            mController.sendEvent(this, EventType.GO_TO, null, null, -1, ViewType.MONTH);
1040        } else if (tab == mAgendaTab && mCurrentView != ViewType.AGENDA) {
1041            mController.sendEvent(this, EventType.GO_TO, null, null, -1, ViewType.AGENDA);
1042        } else {
1043            Log.w(TAG, "TabSelected event from unknown tab: "
1044                    + (tab == null ? "null" : tab.getText()));
1045            Log.w(TAG, "CurrentView:" + mCurrentView + " Tab:" + tab.toString() + " Day:" + mDayTab
1046                    + " Week:" + mWeekTab + " Month:" + mMonthTab + " Agenda:" + mAgendaTab);
1047        }
1048    }
1049
1050    @Override
1051    public void onTabReselected(Tab tab, FragmentTransaction ft) {
1052    }
1053
1054    @Override
1055    public void onTabUnselected(Tab tab, FragmentTransaction ft) {
1056    }
1057
1058
1059    @Override
1060    public boolean onNavigationItemSelected(int itemPosition, long itemId) {
1061        switch (itemPosition) {
1062            case CalendarViewAdapter.DAY_BUTTON_INDEX:
1063                if (mCurrentView != ViewType.DAY) {
1064                    mController.sendEvent(this, EventType.GO_TO, null, null, -1, ViewType.DAY);
1065                }
1066                break;
1067            case CalendarViewAdapter.WEEK_BUTTON_INDEX:
1068                if (mCurrentView != ViewType.WEEK) {
1069                    mController.sendEvent(this, EventType.GO_TO, null, null, -1, ViewType.WEEK);
1070                }
1071                break;
1072            case CalendarViewAdapter.MONTH_BUTTON_INDEX:
1073                if (mCurrentView != ViewType.MONTH) {
1074                    mController.sendEvent(this, EventType.GO_TO, null, null, -1, ViewType.MONTH);
1075                }
1076                break;
1077            case CalendarViewAdapter.AGENDA_BUTTON_INDEX:
1078                if (mCurrentView != ViewType.AGENDA) {
1079                    mController.sendEvent(this, EventType.GO_TO, null, null, -1, ViewType.AGENDA);
1080                }
1081                break;
1082            default:
1083                Log.w(TAG, "ItemSelected event from unknown button: " + itemPosition);
1084                Log.w(TAG, "CurrentView:" + mCurrentView + " Button:" + itemPosition +
1085                        " Day:" + mDayTab + " Week:" + mWeekTab + " Month:" + mMonthTab +
1086                        " Agenda:" + mAgendaTab);
1087                break;
1088        }
1089        return false;
1090    }
1091
1092    /*
1093     * Handles the search view being closed.
1094     */
1095    @Override
1096    public boolean onClose() {
1097        if (!mIsMultipane) {
1098            mSearchMenu.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
1099            invalidateOptionsMenu();
1100        }
1101        return false;
1102    }
1103}
1104