calendar/alerts/GlobalDismissManager.java

/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License
 */

package com.android.calendar.alerts;

import android.content.BroadcastReceiver;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.database.Cursor;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Bundle;
import android.provider.CalendarContract.CalendarAlerts;
import android.provider.CalendarContract.Calendars;
import android.provider.CalendarContract.Events;
import android.util.Log;
import android.util.Pair;

import com.android.calendar.CloudNotificationBackplane;
import com.android.calendar.ExtensionsFactory;
import com.android.calendar.R;

import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Utilities for managing notification dismissal across devices.
 */
public class GlobalDismissManager extends BroadcastReceiver {
    private static class GlobalDismissId {
        public final String mAccountName;
        public final String mSyncId;
        public final long mStartTime;

        private GlobalDismissId(String accountName, String syncId, long startTime) {
            // TODO(psliwowski): Add guava library to use Preconditions class
            if (accountName == null) {
                throw new IllegalArgumentException("Account Name can not be set to null");
            } else if (syncId == null) {
                throw new IllegalArgumentException("SyncId can not be set to null");
            }
            mAccountName = accountName;
            mSyncId = syncId;
            mStartTime = startTime;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }

            GlobalDismissId that = (GlobalDismissId) o;

            if (mStartTime != that.mStartTime) {
                return false;
            }
            if (!mAccountName.equals(that.mAccountName)) {
                return false;
            }
            if (!mSyncId.equals(that.mSyncId)) {
                return false;
            }

            return true;
        }

        @Override
        public int hashCode() {
            int result = mAccountName.hashCode();
            result = 31 * result + mSyncId.hashCode();
            result = 31 * result + (int) (mStartTime ^ (mStartTime >>> 32));
            return result;
        }
    }

    public static class LocalDismissId {
        public final String mAccountType;
        public final String mAccountName;
        public final long mEventId;
        public final long mStartTime;

        public LocalDismissId(String accountType, String accountName, long eventId,
                long startTime) {
            if (accountType == null) {
                throw new IllegalArgumentException("Account Type can not be null");
            } else if (accountName == null) {
                throw new IllegalArgumentException("Account Name can not be null");
            }

            mAccountType = accountType;
            mAccountName = accountName;
            mEventId = eventId;
            mStartTime = startTime;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }

            LocalDismissId that = (LocalDismissId) o;

            if (mEventId != that.mEventId) {
                return false;
            }
            if (mStartTime != that.mStartTime) {
                return false;
            }
            if (!mAccountName.equals(that.mAccountName)) {
                return false;
            }
            if (!mAccountType.equals(that.mAccountType)) {
                return false;
            }

            return true;
        }

        @Override
        public int hashCode() {
            int result = mAccountType.hashCode();
            result = 31 * result + mAccountName.hashCode();
            result = 31 * result + (int) (mEventId ^ (mEventId >>> 32));
            result = 31 * result + (int) (mStartTime ^ (mStartTime >>> 32));
            return result;
        }
    }

    public static class AlarmId {
        public long mEventId;
        public long mStart;

        public AlarmId(long id, long start) {
            mEventId = id;
            mStart = start;
        }
    }

    private static final long TIME_TO_LIVE = 1 * 60 * 60 * 1000; // 1 hour

    private static final String TAG = "GlobalDismissManager";
    private static final String GOOGLE_ACCOUNT_TYPE = "com.google";
    private static final String GLOBAL_DISMISS_MANAGER_PREFS = "com.android.calendar.alerts.GDM";
    private static final String ACCOUNT_KEY = "known_accounts";

    static final String[] EVENT_PROJECTION = new String[] {
            Events._ID,
            Events.CALENDAR_ID
    };
    static final String[] EVENT_SYNC_PROJECTION = new String[] {
            Events._ID,
            Events._SYNC_ID
    };
    static final String[] CALENDARS_PROJECTION = new String[] {
            Calendars._ID,
            Calendars.ACCOUNT_NAME,
            Calendars.ACCOUNT_TYPE
    };

    public static final String KEY_PREFIX = "com.android.calendar.alerts.";
    public static final String SYNC_ID = KEY_PREFIX + "sync_id";
    public static final String START_TIME = KEY_PREFIX + "start_time";
    public static final String ACCOUNT_NAME = KEY_PREFIX + "account_name";
    public static final String DISMISS_INTENT = KEY_PREFIX + "DISMISS";

    // TODO(psliwowski): Look into persisting these like AlertUtils.ALERTS_SHARED_PREFS_NAME
    private static HashMap<GlobalDismissId, Long> sReceiverDismissCache =
            new HashMap<GlobalDismissId, Long>();
    private static HashMap<LocalDismissId, Long> sSenderDismissCache =
            new HashMap<LocalDismissId, Long>();

    /**
     * Look for unknown accounts in a set of events and associate with them.
     * Must not be called on main thread.
     *
     * @param context application context
     * @param eventIds IDs for events that have posted notifications that may be
     *            dismissed.
     */
    public static void processEventIds(Context context, Set<Long> eventIds) {
        final String senderId = context.getResources().getString(R.string.notification_sender_id);
        if (senderId == null || senderId.isEmpty()) {
            Log.i(TAG, "no sender configured");
            return;
        }
        Map<Long, Long> eventsToCalendars = lookupEventToCalendarMap(context, eventIds);
        Set<Long> calendars = new LinkedHashSet<Long>();
        calendars.addAll(eventsToCalendars.values());
        if (calendars.isEmpty()) {
            Log.d(TAG, "found no calendars for events");
            return;
        }

        Map<Long, Pair<String, String>> calendarsToAccounts =
                lookupCalendarToAccountMap(context, calendars);

        if (calendarsToAccounts.isEmpty()) {
            Log.d(TAG, "found no accounts for calendars");
            return;
        }

        // filter out non-google accounts (necessary?)
        Set<String> accounts = new LinkedHashSet<String>();
        for (Pair<String, String> accountPair : calendarsToAccounts.values()) {
            if (GOOGLE_ACCOUNT_TYPE.equals(accountPair.first)) {
                accounts.add(accountPair.second);
            }
        }

        // filter out accounts we already know about
        SharedPreferences prefs =
                context.getSharedPreferences(GLOBAL_DISMISS_MANAGER_PREFS,
                        Context.MODE_PRIVATE);
        Set<String> existingAccounts = prefs.getStringSet(ACCOUNT_KEY,
                new HashSet<String>());
        accounts.removeAll(existingAccounts);

        if (accounts.isEmpty()) {
            // nothing to do, we've already registered all the accounts.
            return;
        }

        // subscribe to remaining accounts
        CloudNotificationBackplane cnb =
                ExtensionsFactory.getCloudNotificationBackplane();
        if (cnb.open(context)) {
            for (String account : accounts) {
                try {
                    if (cnb.subscribeToGroup(senderId, account, account)) {
                        existingAccounts.add(account);
                    }
                } catch (IOException e) {
                    // Try again, next time the account triggers and alert.
                }
            }
            cnb.close();
            prefs.edit()
            .putStringSet(ACCOUNT_KEY, existingAccounts)
            .commit();
        }
    }

    /**
     * Some events don't have a global sync_id when they are dismissed. We need to wait
     * until the data provider is updated before we can send the global dismiss message.
     */
    public static void syncSenderDismissCache(Context context) {
        final String senderId = context.getResources().getString(R.string.notification_sender_id);
        if ("".equals(senderId)) {
            Log.i(TAG, "no sender configured");
            return;
        }
        CloudNotificationBackplane cnb = ExtensionsFactory.getCloudNotificationBackplane();
        if (!cnb.open(context)) {
            Log.i(TAG, "Unable to open cloud notification backplane");

        }

        long currentTime = System.currentTimeMillis();
        ContentResolver resolver = context.getContentResolver();
        synchronized (sSenderDismissCache) {
            Iterator<Map.Entry<LocalDismissId, Long>> it =
                    sSenderDismissCache.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry<LocalDismissId, Long> entry = it.next();
                LocalDismissId dismissId = entry.getKey();

                Uri uri = asSync(Events.CONTENT_URI, dismissId.mAccountType,
                        dismissId.mAccountName);
                Cursor cursor = resolver.query(uri, EVENT_SYNC_PROJECTION,
                        Events._ID + " = " + dismissId.mEventId, null, null);
                try {
                    cursor.moveToPosition(-1);
                    int sync_id_idx = cursor.getColumnIndex(Events._SYNC_ID);
                    if (sync_id_idx != -1) {
                        while (cursor.moveToNext()) {
                            String syncId = cursor.getString(sync_id_idx);
                            if (syncId != null) {
                                Bundle data = new Bundle();
                                long startTime = dismissId.mStartTime;
                                String accountName = dismissId.mAccountName;
                                data.putString(SYNC_ID, syncId);
                                data.putString(START_TIME, Long.toString(startTime));
                                data.putString(ACCOUNT_NAME, accountName);
                                try {
                                    cnb.send(accountName, syncId + ":" + startTime, data);
                                    it.remove();
                                } catch (IOException e) {
                                    // If we couldn't send, then leave dismissal in cache
                                }
                            }
                        }
                    }
                } finally {
                    cursor.close();
                }

                // Remove old dismissals from cache after a certain time period
                if (currentTime - entry.getValue() > TIME_TO_LIVE) {
                    it.remove();
                }
            }
        }

        cnb.close();
    }

    /**
     * Globally dismiss notifications that are backed by the same events.
     *
     * @param context application context
     * @param alarmIds Unique identifiers for events that have been dismissed by the user.
     * @return true if notification_sender_id is available
     */
    public static void dismissGlobally(Context context, List<AlarmId> alarmIds) {
        Set<Long> eventIds = new HashSet<Long>(alarmIds.size());
        for (AlarmId alarmId: alarmIds) {
            eventIds.add(alarmId.mEventId);
        }
        // find the mapping between calendars and events
        Map<Long, Long> eventsToCalendars = lookupEventToCalendarMap(context, eventIds);
        if (eventsToCalendars.isEmpty()) {
            Log.d(TAG, "found no calendars for events");
            return;
        }

        Set<Long> calendars = new LinkedHashSet<Long>();
        calendars.addAll(eventsToCalendars.values());

        // find the accounts associated with those calendars
        Map<Long, Pair<String, String>> calendarsToAccounts =
                lookupCalendarToAccountMap(context, calendars);
        if (calendarsToAccounts.isEmpty()) {
            Log.d(TAG, "found no accounts for calendars");
            return;
        }

        long currentTime = System.currentTimeMillis();
        for (AlarmId alarmId : alarmIds) {
            Long calendar = eventsToCalendars.get(alarmId.mEventId);
            Pair<String, String> account = calendarsToAccounts.get(calendar);
            if (GOOGLE_ACCOUNT_TYPE.equals(account.first)) {
                LocalDismissId dismissId = new LocalDismissId(account.first, account.second,
                        alarmId.mEventId, alarmId.mStart);
                synchronized (sSenderDismissCache) {
                    sSenderDismissCache.put(dismissId, currentTime);
                }
            }
        }
        syncSenderDismissCache(context);
    }

    private static Uri asSync(Uri uri, String accountType, String account) {
        return uri
                .buildUpon()
                .appendQueryParameter(
                        android.provider.CalendarContract.CALLER_IS_SYNCADAPTER, "true")
                .appendQueryParameter(Calendars.ACCOUNT_NAME, account)
                .appendQueryParameter(Calendars.ACCOUNT_TYPE, accountType).build();
    }

    /**
     * Build a selection over a set of row IDs
     *
     * @param ids row IDs to select
     * @param key row name for the table
     * @return a selection string suitable for a resolver query.
     */
    private static String buildMultipleIdQuery(Set<Long> ids, String key) {
        StringBuilder selection = new StringBuilder();
        boolean first = true;
        for (Long id : ids) {
            if (first) {
                first = false;
            } else {
                selection.append(" OR ");
            }
            selection.append(key);
            selection.append("=");
            selection.append(id);
        }
        return selection.toString();
    }

    /**
     * @param context application context
     * @param eventIds Event row IDs to query.
     * @return a map from event to calendar
     */
    private static Map<Long, Long> lookupEventToCalendarMap(Context context, Set<Long> eventIds) {
        Map<Long, Long> eventsToCalendars = new HashMap<Long, Long>();
        ContentResolver resolver = context.getContentResolver();
        String eventSelection = buildMultipleIdQuery(eventIds, Events._ID);
        Cursor eventCursor = resolver.query(Events.CONTENT_URI, EVENT_PROJECTION,
                eventSelection, null, null);
        try {
            eventCursor.moveToPosition(-1);
            int calendar_id_idx = eventCursor.getColumnIndex(Events.CALENDAR_ID);
            int event_id_idx = eventCursor.getColumnIndex(Events._ID);
            if (calendar_id_idx != -1 && event_id_idx != -1) {
                while (eventCursor.moveToNext()) {
                    eventsToCalendars.put(eventCursor.getLong(event_id_idx),
                            eventCursor.getLong(calendar_id_idx));
                }
            }
        } finally {
            eventCursor.close();
        }
        return eventsToCalendars;
    }

    /**
     * @param context application context
     * @param calendars Calendar row IDs to query.
     * @return a map from Calendar to a pair (account type, account name)
     */
    private static Map<Long, Pair<String, String>> lookupCalendarToAccountMap(Context context,
            Set<Long> calendars) {
        Map<Long, Pair<String, String>> calendarsToAccounts =
                new HashMap<Long, Pair<String, String>>();
        ContentResolver resolver = context.getContentResolver();
        String calendarSelection = buildMultipleIdQuery(calendars, Calendars._ID);
        Cursor calendarCursor = resolver.query(Calendars.CONTENT_URI, CALENDARS_PROJECTION,
                calendarSelection, null, null);
        try {
            calendarCursor.moveToPosition(-1);
            int calendar_id_idx = calendarCursor.getColumnIndex(Calendars._ID);
            int account_name_idx = calendarCursor.getColumnIndex(Calendars.ACCOUNT_NAME);
            int account_type_idx = calendarCursor.getColumnIndex(Calendars.ACCOUNT_TYPE);
            if (calendar_id_idx != -1 && account_name_idx != -1 && account_type_idx != -1) {
                while (calendarCursor.moveToNext()) {
                    Long id = calendarCursor.getLong(calendar_id_idx);
                    String name = calendarCursor.getString(account_name_idx);
                    String type = calendarCursor.getString(account_type_idx);
                    if (name != null && type != null) {
                        calendarsToAccounts.put(id, new Pair<String, String>(type, name));
                    }
                }
            }
        } finally {
            calendarCursor.close();
        }
        return calendarsToAccounts;
    }

    /**
     * We can get global dismisses for events we don't know exists yet, so sync our cache
     * with the data provider whenever it updates.
     */
    public static void syncReceiverDismissCache(Context context) {
        ContentResolver resolver = context.getContentResolver();
        long currentTime = System.currentTimeMillis();
        synchronized (sReceiverDismissCache) {
            Iterator<Map.Entry<GlobalDismissId, Long>> it =
                    sReceiverDismissCache.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry<GlobalDismissId, Long> entry = it.next();
                GlobalDismissId globalDismissId = entry.getKey();
                Uri uri = GlobalDismissManager.asSync(Events.CONTENT_URI,
                        GlobalDismissManager.GOOGLE_ACCOUNT_TYPE, globalDismissId.mAccountName);
                Cursor cursor = resolver.query(uri, GlobalDismissManager.EVENT_SYNC_PROJECTION,
                        Events._SYNC_ID + " = '" + globalDismissId.mSyncId + "'",
                        null, null);
                try {
                    int event_id_idx = cursor.getColumnIndex(Events._ID);
                    cursor.moveToFirst();
                    if (event_id_idx != -1 && !cursor.isAfterLast()) {
                        long eventId = cursor.getLong(event_id_idx);
                        ContentValues values = new ContentValues();
                        String selection = "(" + CalendarAlerts.STATE + "=" +
                                CalendarAlerts.STATE_FIRED + " OR " +
                                CalendarAlerts.STATE + "=" +
                                CalendarAlerts.STATE_SCHEDULED + ") AND " +
                                CalendarAlerts.EVENT_ID + "=" + eventId + " AND " +
                                CalendarAlerts.BEGIN + "=" + globalDismissId.mStartTime;
                        values.put(CalendarAlerts.STATE, CalendarAlerts.STATE_DISMISSED);
                        int rows = resolver.update(CalendarAlerts.CONTENT_URI, values,
                                selection, null);
                        if (rows > 0) {
                            it.remove();
                        }
                    }
                } finally {
                    cursor.close();
                }

                if (currentTime - entry.getValue() > TIME_TO_LIVE) {
                    it.remove();
                }
            }
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public void onReceive(Context context, Intent intent) {
        new AsyncTask<Pair<Context, Intent>, Void, Void>() {
            @Override
            protected Void doInBackground(Pair<Context, Intent>... params) {
                Context context = params[0].first;
                Intent intent = params[0].second;
                if (intent.hasExtra(SYNC_ID) && intent.hasExtra(ACCOUNT_NAME)
                        && intent.hasExtra(START_TIME)) {
                    synchronized (sReceiverDismissCache) {
                        sReceiverDismissCache.put(new GlobalDismissId(
                                intent.getStringExtra(ACCOUNT_NAME),
                                intent.getStringExtra(SYNC_ID),
                                Long.parseLong(intent.getStringExtra(START_TIME))
                        ), System.currentTimeMillis());
                    }
                    AlertService.updateAlertNotification(context);
                }
                return null;
            }
        }.execute(new Pair<Context, Intent>(context, intent));
    }
}