1/*
2 * Copyright (C) 2011 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.selectcalendars;
18
19import android.accounts.AccountManager;
20import android.accounts.AuthenticatorDescription;
21import android.app.FragmentManager;
22import android.content.AsyncQueryHandler;
23import android.content.ContentResolver;
24import android.content.ContentUris;
25import android.content.ContentValues;
26import android.content.Context;
27import android.content.pm.PackageManager;
28import android.database.Cursor;
29import android.database.MatrixCursor;
30import android.graphics.Rect;
31import android.net.Uri;
32import android.provider.CalendarContract.Calendars;
33import android.text.TextUtils;
34import android.util.Log;
35import android.view.LayoutInflater;
36import android.view.TouchDelegate;
37import android.view.View;
38import android.view.View.OnClickListener;
39import android.view.ViewGroup;
40import android.widget.CheckBox;
41import android.widget.CursorTreeAdapter;
42import android.widget.TextView;
43
44import com.android.calendar.CalendarColorPickerDialog;
45import com.android.calendar.R;
46import com.android.calendar.Utils;
47import com.android.calendar.selectcalendars.CalendarColorCache.OnCalendarColorsLoadedListener;
48
49import java.util.HashMap;
50import java.util.Iterator;
51import java.util.Map;
52
53public class SelectSyncedCalendarsMultiAccountAdapter extends CursorTreeAdapter implements
54        View.OnClickListener, OnCalendarColorsLoadedListener {
55
56    private static final String TAG = "Calendar";
57    private static final String COLOR_PICKER_DIALOG_TAG = "ColorPickerDialog";
58
59    private static final String IS_PRIMARY = "\"primary\"";
60    private static final String CALENDARS_ORDERBY = IS_PRIMARY + " DESC,"
61            + Calendars.CALENDAR_DISPLAY_NAME + " COLLATE NOCASE";
62    private static final String ACCOUNT_SELECTION = Calendars.ACCOUNT_NAME + "=?"
63            + " AND " + Calendars.ACCOUNT_TYPE + "=?";
64
65    private final LayoutInflater mInflater;
66    private final ContentResolver mResolver;
67    private final SelectSyncedCalendarsMultiAccountActivity mActivity;
68    private final FragmentManager mFragmentManager;
69    private final boolean mIsTablet;
70    private CalendarColorPickerDialog mColorPickerDialog;
71    private final View mView;
72    private final static Runnable mStopRefreshing = new Runnable() {
73        @Override
74        public void run() {
75            mRefresh = false;
76        }
77    };
78    private Map<String, AuthenticatorDescription> mTypeToAuthDescription
79        = new HashMap<String, AuthenticatorDescription>();
80    protected AuthenticatorDescription[] mAuthDescs;
81
82    // These track changes to the synced state of calendars
83    private Map<Long, Boolean> mCalendarChanges
84        = new HashMap<Long, Boolean>();
85    private Map<Long, Boolean> mCalendarInitialStates
86        = new HashMap<Long, Boolean>();
87
88    // Flag for when the cursors have all been closed to ensure no race condition with queries.
89    private boolean mClosedCursorsFlag;
90
91    // This is for keeping MatrixCursor copies so that we can requery in the background.
92    private Map<String, Cursor> mChildrenCursors
93        = new HashMap<String, Cursor>();
94
95    private AsyncCalendarsUpdater mCalendarsUpdater;
96    // This is to keep our update tokens separate from other tokens. Since we cancel old updates
97    // when a new update comes in, we'd like to leave a token space that won't be canceled.
98    private static final int MIN_UPDATE_TOKEN = 1000;
99    private static int mUpdateToken = MIN_UPDATE_TOKEN;
100    // How long to wait between requeries of the calendars to see if anything has changed.
101    private static final int REFRESH_DELAY = 5000;
102    // How long to keep refreshing for
103    private static final int REFRESH_DURATION = 60000;
104    private static boolean mRefresh = true;
105
106    private static String mSyncedText;
107    private static String mNotSyncedText;
108
109    // This is to keep track of whether or not multiple calendars have the same display name
110    private static HashMap<String, Boolean> mIsDuplicateName = new HashMap<String, Boolean>();
111
112    private int mColorViewTouchAreaIncrease;
113
114    private static final String[] PROJECTION = new String[] {
115      Calendars._ID,
116      Calendars.ACCOUNT_NAME,
117      Calendars.OWNER_ACCOUNT,
118      Calendars.CALENDAR_DISPLAY_NAME,
119      Calendars.CALENDAR_COLOR,
120      Calendars.VISIBLE,
121      Calendars.SYNC_EVENTS,
122      "(" + Calendars.ACCOUNT_NAME + "=" + Calendars.OWNER_ACCOUNT + ") AS " + IS_PRIMARY,
123      Calendars.ACCOUNT_TYPE
124    };
125    //Keep these in sync with the projection
126    private static final int ID_COLUMN = 0;
127    private static final int ACCOUNT_COLUMN = 1;
128    private static final int OWNER_COLUMN = 2;
129    private static final int NAME_COLUMN = 3;
130    private static final int COLOR_COLUMN = 4;
131    private static final int SELECTED_COLUMN = 5;
132    private static final int SYNCED_COLUMN = 6;
133    private static final int PRIMARY_COLUMN = 7;
134    private static final int ACCOUNT_TYPE_COLUMN = 8;
135
136    private static final int TAG_ID_CALENDAR_ID = R.id.calendar;
137    private static final int TAG_ID_SYNC_CHECKBOX = R.id.sync;
138
139    private CalendarColorCache mCache;
140
141    private class AsyncCalendarsUpdater extends AsyncQueryHandler {
142
143        public AsyncCalendarsUpdater(ContentResolver cr) {
144            super(cr);
145        }
146
147        @Override
148        protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
149            if(cursor == null) {
150                return;
151            }
152            synchronized(mChildrenCursors) {
153                if (mClosedCursorsFlag || (mActivity != null && mActivity.isFinishing())) {
154                    cursor.close();
155                    return;
156                }
157            }
158
159            Cursor currentCursor = mChildrenCursors.get(cookie);
160            // Check if the new cursor has the same content as our old cursor
161            if (currentCursor != null) {
162                if (Utils.compareCursors(currentCursor, cursor)) {
163                    cursor.close();
164                    return;
165                }
166            }
167            // If not then make a new matrix cursor for our Map
168            MatrixCursor newCursor = Utils.matrixCursorFromCursor(cursor);
169            cursor.close();
170            // And update our list of duplicated names
171            Utils.checkForDuplicateNames(mIsDuplicateName, newCursor, NAME_COLUMN);
172
173            mChildrenCursors.put((String)cookie, newCursor);
174            try {
175                setChildrenCursor(token, newCursor);
176            } catch (NullPointerException e) {
177                Log.w(TAG, "Adapter expired, try again on the next query: " + e);
178            }
179            // Clean up our old cursor if we had one. We have to do this after setting the new
180            // cursor so that our view doesn't throw on an invalid cursor.
181            if (currentCursor != null) {
182                currentCursor.close();
183            }
184        }
185    }
186
187    /**
188     * Method for changing the sync state when a calendar's button is pressed.
189     *
190     * This gets called when the CheckBox for a calendar is clicked. It toggles
191     * the sync state for the associated calendar and saves a change of state to
192     * a hashmap. It also compares against the original value and removes any
193     * changes from the hashmap if this is back at its initial state.
194     */
195    @Override
196    public void onClick(View v) {
197        long id = (Long) v.getTag(TAG_ID_CALENDAR_ID);
198        boolean newState;
199        boolean initialState = mCalendarInitialStates.get(id);
200        if (mCalendarChanges.containsKey(id)) {
201            // Negate to reflect the click
202            newState = !mCalendarChanges.get(id);
203        } else {
204            // Negate to reflect the click
205            newState = !initialState;
206        }
207
208        if (newState == initialState) {
209            mCalendarChanges.remove(id);
210        } else {
211            mCalendarChanges.put(id, newState);
212        }
213
214        ((CheckBox) v.getTag(TAG_ID_SYNC_CHECKBOX)).setChecked(newState);
215        setText(v, R.id.status, newState ? mSyncedText : mNotSyncedText);
216    }
217
218    public SelectSyncedCalendarsMultiAccountAdapter(Context context, Cursor acctsCursor,
219            SelectSyncedCalendarsMultiAccountActivity act) {
220        super(acctsCursor, context);
221        mSyncedText = context.getString(R.string.synced);
222        mNotSyncedText = context.getString(R.string.not_synced);
223
224        mCache = new CalendarColorCache(context, this);
225
226        mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
227        mResolver = context.getContentResolver();
228        mActivity = act;
229        mFragmentManager = act.getFragmentManager();
230        mColorPickerDialog = (CalendarColorPickerDialog)
231                mFragmentManager.findFragmentByTag(COLOR_PICKER_DIALOG_TAG);
232        mIsTablet = Utils.getConfigBool(context, R.bool.tablet_config);
233
234        if (mCalendarsUpdater == null) {
235            mCalendarsUpdater = new AsyncCalendarsUpdater(mResolver);
236        }
237
238        if (acctsCursor == null || acctsCursor.getCount() == 0) {
239            Log.i(TAG, "SelectCalendarsAdapter: No accounts were returned!");
240        }
241        // Collect proper description for account types
242        mAuthDescs = AccountManager.get(context).getAuthenticatorTypes();
243        for (int i = 0; i < mAuthDescs.length; i++) {
244            mTypeToAuthDescription.put(mAuthDescs[i].type, mAuthDescs[i]);
245        }
246        mView = mActivity.getExpandableListView();
247        mRefresh = true;
248        mClosedCursorsFlag = false;
249
250        mColorViewTouchAreaIncrease = context.getResources()
251                .getDimensionPixelSize(R.dimen.color_view_touch_area_increase);
252    }
253
254    public void startRefreshStopDelay() {
255        mRefresh = true;
256        mView.postDelayed(mStopRefreshing, REFRESH_DURATION);
257    }
258
259    public void cancelRefreshStopDelay() {
260        mView.removeCallbacks(mStopRefreshing);
261    }
262
263    /*
264     * Write back the changes that have been made. The sync code will pick up any changes and
265     * do updates on its own.
266     */
267    public void doSaveAction() {
268        // Cancel the previous operation
269        mCalendarsUpdater.cancelOperation(mUpdateToken);
270        mUpdateToken++;
271        // This is to allow us to do queries and updates with the same AsyncQueryHandler without
272        // accidently canceling queries.
273        if(mUpdateToken < MIN_UPDATE_TOKEN) {
274            mUpdateToken = MIN_UPDATE_TOKEN;
275        }
276
277        Iterator<Long> changeKeys = mCalendarChanges.keySet().iterator();
278        while (changeKeys.hasNext()) {
279            long id = changeKeys.next();
280            boolean newSynced = mCalendarChanges.get(id);
281
282            Uri uri = ContentUris.withAppendedId(Calendars.CONTENT_URI, id);
283            ContentValues values = new ContentValues();
284            values.put(Calendars.VISIBLE, newSynced ? 1 : 0);
285            values.put(Calendars.SYNC_EVENTS, newSynced ? 1 : 0);
286            mCalendarsUpdater.startUpdate(mUpdateToken, id, uri, values, null, null);
287        }
288    }
289
290    private static void setText(View view, int id, String text) {
291        if (TextUtils.isEmpty(text)) {
292            return;
293        }
294        TextView textView = (TextView) view.findViewById(id);
295        textView.setText(text);
296    }
297
298    /**
299     * Gets the label associated with a particular account type. If none found, return null.
300     * @param accountType the type of account
301     * @return a CharSequence for the label or null if one cannot be found.
302     */
303    protected CharSequence getLabelForType(final String accountType) {
304        CharSequence label = null;
305        if (mTypeToAuthDescription.containsKey(accountType)) {
306             try {
307                 AuthenticatorDescription desc = mTypeToAuthDescription.get(accountType);
308                 Context authContext = mActivity.createPackageContext(desc.packageName, 0);
309                 label = authContext.getResources().getText(desc.labelId);
310             } catch (PackageManager.NameNotFoundException e) {
311                 Log.w(TAG, "No label for account type " + ", type " + accountType);
312             }
313        }
314        return label;
315    }
316
317    @Override
318    protected void bindChildView(View view, Context context, Cursor cursor, boolean isLastChild) {
319        final long id = cursor.getLong(ID_COLUMN);
320        String name = cursor.getString(NAME_COLUMN);
321        String owner = cursor.getString(OWNER_COLUMN);
322        final String accountName = cursor.getString(ACCOUNT_COLUMN);
323        final String accountType = cursor.getString(ACCOUNT_TYPE_COLUMN);
324        int color = Utils.getDisplayColorFromColor(cursor.getInt(COLOR_COLUMN));
325
326        final View colorSquare = view.findViewById(R.id.color);
327        colorSquare.setEnabled(mCache.hasColors(accountName, accountType));
328        colorSquare.setBackgroundColor(color);
329        final View delegateParent = (View) colorSquare.getParent();
330        delegateParent.post(new Runnable() {
331
332            @Override
333            public void run() {
334                final Rect r = new Rect();
335                colorSquare.getHitRect(r);
336                r.top -= mColorViewTouchAreaIncrease;
337                r.bottom += mColorViewTouchAreaIncrease;
338                r.left -= mColorViewTouchAreaIncrease;
339                r.right += mColorViewTouchAreaIncrease;
340                delegateParent.setTouchDelegate(new TouchDelegate(r, colorSquare));
341            }
342        });
343        colorSquare.setOnClickListener(new OnClickListener() {
344
345            @Override
346            public void onClick(View v) {
347                if (!mCache.hasColors(accountName, accountType)) {
348                    return;
349                }
350                if (mColorPickerDialog == null) {
351                    mColorPickerDialog = CalendarColorPickerDialog.newInstance(id, mIsTablet);
352                } else {
353                    mColorPickerDialog.setCalendarId(id);
354                }
355                mFragmentManager.executePendingTransactions();
356                if (!mColorPickerDialog.isAdded()) {
357                    mColorPickerDialog.show(mFragmentManager, COLOR_PICKER_DIALOG_TAG);
358                }
359            }
360        });
361        if (mIsDuplicateName.containsKey(name) && mIsDuplicateName.get(name) &&
362                !name.equalsIgnoreCase(owner)) {
363            name = new StringBuilder(name)
364                    .append(Utils.OPEN_EMAIL_MARKER)
365                    .append(owner)
366                    .append(Utils.CLOSE_EMAIL_MARKER)
367                    .toString();
368        }
369        setText(view, R.id.calendar, name);
370
371        // First see if the user has already changed the state of this calendar
372        Boolean sync = mCalendarChanges.get(id);
373        if (sync == null) {
374            sync = cursor.getInt(SYNCED_COLUMN) == 1;
375            mCalendarInitialStates.put(id, sync);
376        }
377
378        CheckBox button = (CheckBox) view.findViewById(R.id.sync);
379        button.setChecked(sync);
380        setText(view, R.id.status, sync ? mSyncedText : mNotSyncedText);
381
382        view.setTag(TAG_ID_CALENDAR_ID, id);
383        view.setTag(TAG_ID_SYNC_CHECKBOX, button);
384        view.setOnClickListener(this);
385    }
386
387    @Override
388    protected void bindGroupView(View view, Context context, Cursor cursor, boolean isExpanded) {
389        int accountColumn = cursor.getColumnIndexOrThrow(Calendars.ACCOUNT_NAME);
390        int accountTypeColumn = cursor.getColumnIndexOrThrow(Calendars.ACCOUNT_TYPE);
391        String account = cursor.getString(accountColumn);
392        String accountType = cursor.getString(accountTypeColumn);
393        CharSequence accountLabel = getLabelForType(accountType);
394        setText(view, R.id.account, account);
395        if (accountLabel != null) {
396            setText(view, R.id.account_type, accountLabel.toString());
397        }
398    }
399
400    @Override
401    protected Cursor getChildrenCursor(Cursor groupCursor) {
402        int accountColumn = groupCursor.getColumnIndexOrThrow(Calendars.ACCOUNT_NAME);
403        int accountTypeColumn = groupCursor.getColumnIndexOrThrow(Calendars.ACCOUNT_TYPE);
404        String account = groupCursor.getString(accountColumn);
405        String accountType = groupCursor.getString(accountTypeColumn);
406        //Get all the calendars for just this account.
407        Cursor childCursor = mChildrenCursors.get(accountType + "#" + account);
408        new RefreshCalendars(groupCursor.getPosition(), account, accountType).run();
409        return childCursor;
410    }
411
412    @Override
413    protected View newChildView(Context context, Cursor cursor, boolean isLastChild,
414            ViewGroup parent) {
415        return mInflater.inflate(R.layout.calendar_sync_item, parent, false);
416    }
417
418    @Override
419    protected View newGroupView(Context context, Cursor cursor, boolean isExpanded,
420            ViewGroup parent) {
421        return mInflater.inflate(R.layout.account_item, parent, false);
422    }
423
424    public void closeChildrenCursors() {
425        synchronized (mChildrenCursors) {
426            for (String key : mChildrenCursors.keySet()) {
427                Cursor cursor = mChildrenCursors.get(key);
428                if (!cursor.isClosed()) {
429                    cursor.close();
430                }
431            }
432            mChildrenCursors.clear();
433            mClosedCursorsFlag = true;
434        }
435    }
436
437    private class RefreshCalendars implements Runnable {
438
439        int mToken;
440        String mAccount;
441        String mAccountType;
442
443        public RefreshCalendars(int token, String account, String accountType) {
444            mToken = token;
445            mAccount = account;
446            mAccountType = accountType;
447        }
448
449        @Override
450        public void run() {
451            mCalendarsUpdater.cancelOperation(mToken);
452            // Set up a refresh for some point in the future if we haven't stopped updates yet
453            if(mRefresh) {
454                mView.postDelayed(new RefreshCalendars(mToken, mAccount, mAccountType),
455                        REFRESH_DELAY);
456            }
457            mCalendarsUpdater.startQuery(mToken,
458                    mAccountType + "#" + mAccount,
459                    Calendars.CONTENT_URI, PROJECTION,
460                    ACCOUNT_SELECTION,
461                    new String[] { mAccount, mAccountType } /*selectionArgs*/,
462                    CALENDARS_ORDERBY);
463        }
464    }
465
466    @Override
467    public void onCalendarColorsLoaded() {
468        notifyDataSetChanged();
469    }
470}
471