Add CalendarEventAttendeeProvider

src/googleplay/java/org/tasks/AccountManager.java

@@ -14,11 +14,12 @@ import com.google.common.base.Function;
 import com.google.common.base.Predicate;
 
 import org.tasks.injection.ForApplication;
+import org.tasks.preferences.PermissionChecker;
 
 import java.io.IOException;
+import java.util.Collections;
 import java.util.List;
 
-import javax.annotation.Nullable;
 import javax.inject.Inject;
 
 import timber.log.Timber;
@@ -49,18 +50,19 @@ public class AccountManager {
     public static final int REQUEST_AUTHORIZATION = 10987;
 
     private final Context context;
+    private final PermissionChecker permissionChecker;
     private final GoogleAccountManager googleAccountManager;
 
     @Inject
-    public AccountManager(@ForApplication Context context) {
+    public AccountManager(@ForApplication Context context, PermissionChecker permissionChecker) {
         this.context = context;
+        this.permissionChecker = permissionChecker;
 
         googleAccountManager = new GoogleAccountManager(context);
     }
 
     public List<String> getAccounts() {
         return transform(getAccountList(), new Function<Account, String>() {
-            @Nullable
             @Override
             public String apply(Account account) {
                 return account.name;
@@ -100,7 +102,9 @@ public class AccountManager {
     }
 
     private List<Account> getAccountList() {
-        return asList(googleAccountManager.getAccounts());
+        return permissionChecker.canAccessAccounts()
+                ? asList(googleAccountManager.getAccounts())
+                : Collections.<Account>emptyList();
     }
 
     public Account getAccount(final String name) {

src/main/java/com/todoroo/astrid/gcal/CalendarAlarmReceiver.java

@@ -1,47 +1,38 @@
 package com.todoroo.astrid.gcal;
 
-import android.accounts.Account;
-import android.accounts.AccountManager;
-import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
-import android.database.Cursor;
 import android.net.Uri;
-import android.provider.CalendarContract;
-import android.text.TextUtils;
 
 import com.todoroo.andlib.utility.DateUtilities;
 import com.todoroo.astrid.utility.Constants;
 
+import org.tasks.AccountManager;
 import org.tasks.R;
 import org.tasks.calendars.AndroidCalendarEvent;
+import org.tasks.calendars.AndroidCalendarEventAttendee;
 import org.tasks.calendars.CalendarEventProvider;
 import org.tasks.injection.InjectingBroadcastReceiver;
-import org.tasks.preferences.PermissionChecker;
 import org.tasks.preferences.Preferences;
 import org.tasks.scheduling.CalendarNotificationIntentService;
 
 import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.List;
 
 import javax.inject.Inject;
 
 import timber.log.Timber;
 
+import static com.google.common.base.Strings.isNullOrEmpty;
+
 public class CalendarAlarmReceiver extends InjectingBroadcastReceiver {
 
     public static final int REQUEST_CODE_CAL_REMINDER = 100;
     public static final String BROADCAST_CALENDAR_REMINDER = Constants.PACKAGE + ".CALENDAR_EVENT";
 
-    private static final String[] ATTENDEES_PROJECTION = {
-            CalendarContract.Attendees.ATTENDEE_NAME,
-            CalendarContract.Attendees.ATTENDEE_EMAIL,
-    };
-
     @Inject Preferences preferences;
-    @Inject PermissionChecker permissionChecker;
     @Inject CalendarEventProvider calendarEventProvider;
+    @Inject AccountManager accountManager;
 
     @Override
     public void onReceive(Context context, Intent intent) {
@@ -51,10 +42,6 @@ public class CalendarAlarmReceiver extends InjectingBroadcastReceiver {
             return;
         }
 
-        if (!permissionChecker.canAccessCalendars()) {
-            return;
-        }
-
         try {
             Uri data = intent.getData();
             if (data == null) {
@@ -69,8 +56,8 @@ public class CalendarAlarmReceiver extends InjectingBroadcastReceiver {
                 return;
             }
             long eventId = Long.parseLong(uriString.substring(pathIndex));
-            boolean fromPostpone = CalendarNotificationIntentService.URI_PREFIX_POSTPONE.equals(data.getScheme());
             if (eventId > 0) {
+                boolean fromPostpone = CalendarNotificationIntentService.URI_PREFIX_POSTPONE.equals(data.getScheme());
                 showCalReminder(context, eventId, fromPostpone);
             }
         } catch (IllegalArgumentException e) {
@@ -79,14 +66,11 @@ public class CalendarAlarmReceiver extends InjectingBroadcastReceiver {
         }
     }
 
-    private void showCalReminder(Context context, long eventId, boolean fromPostpone) {
-        AndroidCalendarEvent event = calendarEventProvider.getEvent(eventId);
+    private void showCalReminder(Context context, final long eventId, final boolean fromPostpone) {
+        final AndroidCalendarEvent event = calendarEventProvider.getEvent(eventId);
         if (event == null) {
             return;
         }
-
-        ContentResolver cr = context.getContentResolver();
-        String[] eventArg = new String[]{Long.toString(eventId)};
         boolean shouldShowReminder;
         if (fromPostpone) {
             long timeAfter = DateUtilities.now() - event.getEnd();
@@ -97,54 +81,32 @@ public class CalendarAlarmReceiver extends InjectingBroadcastReceiver {
         }
 
         if (shouldShowReminder) {
-            // Get attendees
-            Cursor attendees = cr.query(CalendarContract.Attendees.CONTENT_URI,
-                    ATTENDEES_PROJECTION,
-                    CalendarContract.Attendees.EVENT_ID + " = ? ",
-                    eventArg,
-                    null);
-            try {
-                // Do something with attendees
-                int emailIndex = attendees.getColumnIndexOrThrow(CalendarContract.Attendees.ATTENDEE_EMAIL);
-                int nameIndex = attendees.getColumnIndexOrThrow(CalendarContract.Attendees.ATTENDEE_NAME);
-
-                ArrayList<String> names = new ArrayList<>();
-                ArrayList<String> emails = new ArrayList<>();
-
-                Account[] accountArray = AccountManager.get(context).getAccounts();
-                Set<String> phoneAccounts = new HashSet<>();
-                for (Account a : accountArray) {
-                    phoneAccounts.add(a.name);
-                }
-
-                boolean includesMe = false;
-                for (attendees.moveToFirst(); !attendees.isAfterLast(); attendees.moveToNext()) {
-                    String name = attendees.getString(nameIndex);
-                    String email = attendees.getString(emailIndex);
-                    if (!TextUtils.isEmpty(email)) {
-                        if (phoneAccounts.contains(email)) {
-                            includesMe = true;
-                            continue;
-                        }
-                        names.add(name);
-                        emails.add(email);
+            final ArrayList<String> emails = new ArrayList<>();
+            final ArrayList<String> names = new ArrayList<>();
+            List<String> phoneAccounts = accountManager.getAccounts();
+            boolean includesMe = false;
+            for (AndroidCalendarEventAttendee attendee : event.getAttendees()) {
+                String email = attendee.getEmail();
+                if (!isNullOrEmpty(email)) {
+                    if (phoneAccounts.contains(email)) {
+                        includesMe = true;
+                        continue;
                     }
+                    emails.add(attendee.getEmail());
+                    names.add(attendee.getName());
                 }
-
-                if (emails.size() > 0 && includesMe) {
-                    Intent reminderActivity = new Intent(context, CalendarReminderActivity.class);
-                    reminderActivity.putStringArrayListExtra(CalendarReminderActivity.TOKEN_NAMES, names);
-                    reminderActivity.putStringArrayListExtra(CalendarReminderActivity.TOKEN_EMAILS, emails);
-                    reminderActivity.putExtra(CalendarReminderActivity.TOKEN_EVENT_ID, eventId);
-                    reminderActivity.putExtra(CalendarReminderActivity.TOKEN_EVENT_NAME, event.getTitle());
-                    reminderActivity.putExtra(CalendarReminderActivity.TOKEN_EVENT_START_TIME, event.getStart());
-                    reminderActivity.putExtra(CalendarReminderActivity.TOKEN_EVENT_END_TIME, event.getEnd());
-                    reminderActivity.putExtra(CalendarReminderActivity.TOKEN_FROM_POSTPONE, fromPostpone);
-                    reminderActivity.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
-                    context.startActivity(reminderActivity);
-                }
-            } finally {
-                attendees.close();
+            }
+            if (emails.size() > 0 && includesMe) {
+                context.startActivity(new Intent(context, CalendarReminderActivity.class) {{
+                    putStringArrayListExtra(CalendarReminderActivity.TOKEN_NAMES, names);
+                    putStringArrayListExtra(CalendarReminderActivity.TOKEN_EMAILS, emails);
+                    putExtra(CalendarReminderActivity.TOKEN_EVENT_ID, eventId);
+                    putExtra(CalendarReminderActivity.TOKEN_EVENT_NAME, event.getTitle());
+                    putExtra(CalendarReminderActivity.TOKEN_EVENT_START_TIME, event.getStart());
+                    putExtra(CalendarReminderActivity.TOKEN_EVENT_END_TIME, event.getEnd());
+                    putExtra(CalendarReminderActivity.TOKEN_FROM_POSTPONE, fromPostpone);
+                    setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
+                }});
             }
         }
     }

src/main/java/org/tasks/calendars/AndroidCalendarEvent.java

@@ -1,17 +1,21 @@
 package org.tasks.calendars;
 
+import java.util.List;
+
 public class AndroidCalendarEvent {
 
-    private long id;
+    private final long id;
     private final String title;
     private final long start;
     private final long end;
+    private final List<AndroidCalendarEventAttendee> attendees;
 
-    public AndroidCalendarEvent(long id, String title, long start, long end) {
+    public AndroidCalendarEvent(long id, String title, long start, long end, List<AndroidCalendarEventAttendee> attendees) {
         this.id = id;
         this.title = title;
         this.start = start;
         this.end = end;
+        this.attendees = attendees;
     }
 
     public long getId() {
@@ -30,6 +34,10 @@ public class AndroidCalendarEvent {
         return end;
     }
 
+    public List<AndroidCalendarEventAttendee> getAttendees() {
+        return attendees;
+    }
+
     @Override
     public String toString() {
         return "AndroidCalendarEvent{" +
@@ -37,6 +45,7 @@ public class AndroidCalendarEvent {
                 ", title='" + title + '\'' +
                 ", start=" + start +
                 ", end=" + end +
+                ", attendees=" + attendees +
                 '}';
     }
 }

src/main/java/org/tasks/calendars/AndroidCalendarEventAttendee.java

@@ -0,0 +1,28 @@
+package org.tasks.calendars;
+
+public class AndroidCalendarEventAttendee {
+
+    private final String name;
+    private final String email;
+
+    public AndroidCalendarEventAttendee(String name, String email) {
+        this.name = name;
+        this.email = email;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    @Override
+    public String toString() {
+        return "AndroidCalendarEventAttendee{" +
+                "name='" + name + '\'' +
+                ", email='" + email + '\'' +
+                '}';
+    }
+}

src/main/java/org/tasks/calendars/CalendarEventAttendeeProvider.java

@@ -0,0 +1,67 @@
+package org.tasks.calendars;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.Cursor;
+import android.provider.CalendarContract;
+
+import org.tasks.injection.ForApplication;
+import org.tasks.preferences.PermissionChecker;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javax.inject.Inject;
+
+import timber.log.Timber;
+
+public class CalendarEventAttendeeProvider {
+
+    private static final String[] COLUMNS = {
+            CalendarContract.Attendees.ATTENDEE_NAME,
+            CalendarContract.Attendees.ATTENDEE_EMAIL,
+    };
+
+    private final PermissionChecker permissionChecker;
+    private final ContentResolver contentResolver;
+
+    @Inject
+    public CalendarEventAttendeeProvider(@ForApplication Context context, PermissionChecker permissionChecker) {
+        this.permissionChecker = permissionChecker;
+        contentResolver = context.getContentResolver();
+    }
+
+    public List<AndroidCalendarEventAttendee> getAttendees(long id) {
+        if (!permissionChecker.canAccessCalendars()) {
+            return Collections.emptyList();
+        }
+
+        List<AndroidCalendarEventAttendee> attendees = new ArrayList<>();
+        Cursor cursor = null;
+        try {
+            //noinspection ResourceType
+            cursor = contentResolver.query(
+                    CalendarContract.Attendees.CONTENT_URI,
+                    COLUMNS,
+                    CalendarContract.Attendees.EVENT_ID + " = ? ",
+                    new String[] { Long.toString(id) }, null);
+            if (cursor != null && cursor.getCount() > 0) {
+                int emailIndex = cursor.getColumnIndexOrThrow(CalendarContract.Attendees.ATTENDEE_EMAIL);
+                int nameIndex = cursor.getColumnIndexOrThrow(CalendarContract.Attendees.ATTENDEE_NAME);
+                while (cursor.moveToNext()) {
+                    attendees.add(new AndroidCalendarEventAttendee(
+                            cursor.getString(nameIndex),
+                            cursor.getString(emailIndex)));
+                }
+            }
+        } catch (Exception e) {
+            Timber.e(e, e.getMessage());
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+        return attendees;
+    }
+}

src/main/java/org/tasks/calendars/CalendarEventProvider.java

@@ -31,10 +31,13 @@ public class CalendarEventProvider {
 
     private final ContentResolver contentResolver;
     private final PermissionChecker permissionChecker;
+    private final CalendarEventAttendeeProvider calendarEventAttendeeProvider;
 
     @Inject
-    public CalendarEventProvider(@ForApplication Context context, PermissionChecker permissionChecker) {
+    public CalendarEventProvider(@ForApplication Context context, PermissionChecker permissionChecker,
+                                 CalendarEventAttendeeProvider calendarEventAttendeeProvider) {
         this.permissionChecker = permissionChecker;
+        this.calendarEventAttendeeProvider = calendarEventAttendeeProvider;
         contentResolver = context.getContentResolver();
     }
 
@@ -67,11 +70,13 @@ public class CalendarEventProvider {
                 int endIndex = cursor.getColumnIndexOrThrow(CalendarContract.Events.DTEND);
                 int titleIndex = cursor.getColumnIndexOrThrow(CalendarContract.Events.TITLE);
                 while (cursor.moveToNext()) {
+                    long id = cursor.getLong(idIndex);
                     events.add(new AndroidCalendarEvent(
-                            cursor.getLong(idIndex),
+                            id,
                             cursor.getString(titleIndex),
                             cursor.getLong(startIndex),
-                            cursor.getLong(endIndex)));
+                            cursor.getLong(endIndex),
+                            calendarEventAttendeeProvider.getAttendees(id)));
                 }
             }
         } catch (Exception e) {