Java Reminders类代码示例

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
@Override
public void onInsertComplete(int token, Object object, Uri uri)
{
    if (uri != null)
    {
        if (BuildConfig.DEBUG)
            Log.d(TAG, "Insert complete " + uri.getLastPathSegment());

        switch (token)
        {
        case EVENT:
            long eventID = Long.parseLong(uri.getLastPathSegment());
            ContentValues values = new ContentValues();
            values.put(Reminders.MINUTES, 10);
            values.put(Reminders.EVENT_ID, eventID);
            values.put(Reminders.METHOD, Reminders.METHOD_ALERT);
            startInsert(REMINDER, null, Reminders.CONTENT_URI, values);
            break;
        }
    }
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
private void addExpectedMinutes(ArrayList<ContentProviderOperation> expectedOps) {
    ContentProviderOperation.Builder b;
    mValues = new ContentValues();

    mValues.clear();
    mValues.put(Reminders.MINUTES, 5);
    mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
    mValues.put(Reminders.EVENT_ID, TEST_EVENT_ID);
    b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
    expectedOps.add(b.build());

    mValues.clear();
    mValues.put(Reminders.MINUTES, 10);
    mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
    mValues.put(Reminders.EVENT_ID, TEST_EVENT_ID);
    b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
    expectedOps.add(b.build());

    mValues.clear();
    mValues.put(Reminders.MINUTES, 15);
    mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
    mValues.put(Reminders.EVENT_ID, TEST_EVENT_ID);
    b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
    expectedOps.add(b.build());
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
private void addExpectedMinutesWithBackRef(ArrayList<ContentProviderOperation> expectedOps) {
    ContentProviderOperation.Builder b;
    mValues = new ContentValues();

    mValues.clear();
    mValues.put(Reminders.MINUTES, 5);
    mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
    b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
    b.withValueBackReference(Reminders.EVENT_ID, TEST_EVENT_INDEX_ID);
    expectedOps.add(b.build());

    mValues.clear();
    mValues.put(Reminders.MINUTES, 10);
    mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
    b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
    b.withValueBackReference(Reminders.EVENT_ID, TEST_EVENT_INDEX_ID);
    expectedOps.add(b.build());

    mValues.clear();
    mValues.put(Reminders.MINUTES, 15);
    mValues.put(Reminders.METHOD, Reminders.METHOD_DEFAULT);
    b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(mValues);
    b.withValueBackReference(Reminders.EVENT_ID, TEST_EVENT_INDEX_ID);
    expectedOps.add(b.build());
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
/** Fetch all the reminders of the specified event,
   and put them in a JSONArray.
*/
private JSONArray getReminders(long eventId) {
    Cursor c = Reminders.query(
        context.getContentResolver(),
        eventId,
        REMINDER_COLUMNS
    );

    JSONArray result = Tools.rows2JSONArray(c, REMINDER_COLUMNS);
    c.close();
    return result;
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
void populateReminders(Event e) throws RemoteException {
	// reminders
	Uri remindersUri = Reminders.CONTENT_URI.buildUpon()
			.appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, "true")
			.build();
	@Cleanup Cursor c = providerClient.query(remindersUri, new String[]{
			/* 0 */ Reminders.MINUTES, Reminders.METHOD
	}, Reminders.EVENT_ID + "=?", new String[]{String.valueOf(e.getLocalID())}, null);
	while (c != null && c.moveToNext()) {
		//Duration duration = new Duration.Builder().prior(true).minutes(c.getInt(0)).build();
		Duration duration = new Duration.Builder().minutes(c.getInt(0)).build();
		Trigger trigger = new Trigger(duration, Related.START);
		VAlarm alarm = VAlarm.display(trigger, e.getSummary());
		e.addAlarm(alarm);
	}
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
@Override
protected void addDataRows(Resource resource, long localID, int backrefIdx) {
	Event event = (Event)resource;
	for (Attendee attendee : event.getAttendees())
		pendingOperations.add(buildAttendee(newDataInsertBuilder(Attendees.CONTENT_URI, Attendees.EVENT_ID, localID, backrefIdx), attendee).build());
	for (VAlarm alarm : event.getAlarms())
		pendingOperations.add(buildReminder(newDataInsertBuilder(Reminders.CONTENT_URI, Reminders.EVENT_ID, localID, backrefIdx), alarm).build());
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
@Override
protected void removeDataRows(Resource resource) {
	Event event = (Event)resource;
	pendingOperations.add(ContentProviderOperation.newDelete(syncAdapterURI(Attendees.CONTENT_URI))
			.withSelection(Attendees.EVENT_ID + "=?",
			new String[] { String.valueOf(event.getLocalID()) }).build());
	pendingOperations.add(ContentProviderOperation.newDelete(syncAdapterURI(Reminders.CONTENT_URI))
			.withSelection(Reminders.EVENT_ID + "=?",
					new String[]{String.valueOf(event.getLocalID())}).build());
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
protected Builder buildReminder(Builder builder, VAlarm alarm) {
	int minutes = 0;

	if (alarm.getTrigger() != null && alarm.getTrigger().getDuration() != null)
		//minutes = duration.getDays() * 24*60 + duration.getHours()*60 + duration.getMinutes();
		minutes = (int)(alarm.getTrigger().getDuration().toMillis()/60000);

	Log.d(TAG, "Adding alarm " + minutes + " min before");
	
	return builder
			.withValue(Reminders.METHOD, Reminders.METHOD_ALERT)
			.withValue(Reminders.MINUTES, minutes);
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
/**
 * Saves the reminders, if they changed. Returns true if operations to
 * update the database were added.
 *
 * @param ops the array of ContentProviderOperations
 * @param eventId the id of the event whose reminders are being updated
 * @param reminders the array of reminders set by the user
 * @param originalReminders the original array of reminders
 * @param forceSave if true, then save the reminders even if they didn't change
 * @return true if operations to update the database were added
 */
public static boolean saveReminders(ArrayList<ContentProviderOperation> ops, long eventId,
        ArrayList<ReminderEntry> reminders, ArrayList<ReminderEntry> originalReminders,
        boolean forceSave) {
    // If the reminders have not changed, then don't update the database
    if (reminders.equals(originalReminders) && !forceSave) {
        return false;
    }

    // Delete all the existing reminders for this event
    String where = Reminders.EVENT_ID + "=?";
    String[] args = new String[] {Long.toString(eventId)};
    ContentProviderOperation.Builder b = ContentProviderOperation
            .newDelete(Reminders.CONTENT_URI);
    b.withSelection(where, args);
    ops.add(b.build());

    ContentValues values = new ContentValues();
    int len = reminders.size();

    // Insert the new reminders, if any
    for (int i = 0; i < len; i++) {
        ReminderEntry re = reminders.get(i);

        values.clear();
        values.put(Reminders.MINUTES, re.getMinutes());
        values.put(Reminders.METHOD, re.getMethod());
        values.put(Reminders.EVENT_ID, eventId);
        b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(values);
        ops.add(b.build());
    }
    return true;
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
/**
 * Saves the reminders, if they changed. Returns true if operations to
 * update the database were added. Uses a reference id since an id isn't
 * created until the row is added.
 *
 * @param ops the array of ContentProviderOperations
 * @param eventId the id of the event whose reminders are being updated
 * @param reminderMinutes the array of reminders set by the user
 * @param originalMinutes the original array of reminders
 * @param forceSave if true, then save the reminders even if they didn't change
 * @return true if operations to update the database were added
 */
public static boolean saveRemindersWithBackRef(ArrayList<ContentProviderOperation> ops,
        int eventIdIndex, ArrayList<ReminderEntry> reminders,
        ArrayList<ReminderEntry> originalReminders, boolean forceSave) {
    // If the reminders have not changed, then don't update the database
    if (reminders.equals(originalReminders) && !forceSave) {
        return false;
    }

    // Delete all the existing reminders for this event
    ContentProviderOperation.Builder b = ContentProviderOperation
            .newDelete(Reminders.CONTENT_URI);
    b.withSelection(Reminders.EVENT_ID + "=?", new String[1]);
    b.withSelectionBackReference(0, eventIdIndex);
    ops.add(b.build());

    ContentValues values = new ContentValues();
    int len = reminders.size();

    // Insert the new reminders, if any
    for (int i = 0; i < len; i++) {
        ReminderEntry re = reminders.get(i);

        values.clear();
        values.put(Reminders.MINUTES, re.getMinutes());
        values.put(Reminders.METHOD, re.getMethod());
        b = ContentProviderOperation.newInsert(Reminders.CONTENT_URI).withValues(values);
        b.withValueBackReference(Reminders.EVENT_ID, eventIdIndex);
        ops.add(b.build());
    }
    return true;
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
@Override
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (!(obj instanceof ReminderEntry)) {
        return false;
    }

    ReminderEntry re = (ReminderEntry) obj;

    if (re.mMinutes != mMinutes) {
        return false;
    }

    // Treat ALERT and DEFAULT as equivalent.  This is useful during the "has anything
    // "changed" test, so that if DEFAULT is present, but we don't change anything,
    // the internal conversion of DEFAULT to ALERT doesn't force a database update.
    return re.mMethod == mMethod ||
        (re.mMethod == Reminders.METHOD_DEFAULT && mMethod == Reminders.METHOD_ALERT) ||
        (re.mMethod == Reminders.METHOD_ALERT && mMethod == Reminders.METHOD_DEFAULT);
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
private void addOwnerAttendeeToOps(ArrayList<ContentProviderOperation> expectedOps, int id) {
    addOwnerAttendee();
    ContentProviderOperation.Builder b;
    b = ContentProviderOperation.newInsert(Attendees.CONTENT_URI).withValues(mExpectedValues);
    b.withValueBackReference(Reminders.EVENT_ID, id);
    expectedOps.add(b.build());
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
protected void syncReminders(DbCalendarSensor event) {

        if (event == null) {
            return;
        }

        boolean hasAlarm = event.getHasAlarm();

        if (hasAlarm) {

            long eventId = event.getEventId();
            LongSparseArray<DbCalendarReminderSensor> mapExistingReminders = getExistingReminders(eventId);

            // optional reminderSelection
            String[] selectionArgs = {String.valueOf(eventId)};

            Cursor cur = null;

            try {

                long deviceId = PreferenceProvider.getInstance(context).getCurrentDeviceId();

                cur = contentResolver.query(URI_REMINDER, PROJECTION_REMINDERS, reminderSelection, selectionArgs, null);

                if (cur == null || cur.getCount() <= 0) {
                    return;
                }

                List<DbCalendarReminderSensor> entriesToInsert = new ArrayList<>(cur.getCount());
                String created = DateUtils.dateToISO8601String(new Date(), Locale.getDefault());

                // Iterate over event
                while (cur.moveToNext() && isRunning()) {

                    DbCalendarReminderSensor reminder = new DbCalendarReminderSensor();

                    reminder.setReminderId(getLongByColumnName(cur, Reminders._ID));
                    reminder.setEventId(eventId);
                    reminder.setMethod(getIntByColumnName(cur, Reminders.METHOD));
                    reminder.setMinutes(getIntByColumnName(cur, Reminders.MINUTES));
                    reminder.setIsNew(Boolean.TRUE);
                    reminder.setIsDeleted(Boolean.FALSE);
                    reminder.setIsUpdated(Boolean.TRUE);
                    reminder.setDeviceId(deviceId);
                    reminder.setCreated(created);

                    if (checkForReminderChange(mapExistingReminders, reminder)) {
                        entriesToInsert.add(reminder);
                    }
                }

                if (!entriesToInsert.isEmpty()) {
                    calendarReminderSensorDao.insert(entriesToInsert);
                }

            } finally {
                if (cur != null) {
                    cur.close();
                }
            }

        }
    }
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
/**
 * Initialize the multithread handler manager for ContentObservers and
 * initialize the context observers for the sensors
 */
@SuppressLint("NewApi")
public void startContentObservers(){
	//Register the sensor handler thread with the handler managers
	
	//Multitasking
	thread_multitasking.start();
	thread_sensor_multi = new Handler(thread_multitasking.getLooper());
	multitask_observer = new MultitaskingObserver(thread_sensor_multi, this);
	MultitaskingObserver.lastMultiESM = screenOnTime;
	MultitaskingObserver.lastEmailESM = screenOnTime;
	
	//Phone 
	thread_phone.start();
	thread_sensor_phone = new Handler(thread_phone.getLooper());
	phone_observer = new VoiceCallObserver(thread_sensor_phone, this);
	VoiceCallObserver.lastVoiceESM = screenOnTime;
	
	//Text Messaging
	thread_messages.start();
	thread_sensor_messages = new Handler(thread_messages.getLooper());
	messages_observer = new MessageObserver(thread_sensor_messages, this);
	MessageObserver.lastMessageESM = screenOnTime;
	
	//Installations
	thread_install.start();
	thread_sensor_install = new Handler(thread_install.getLooper());
	install_observer = new InstallationsObserver(thread_sensor_install, this);
	
	//ESM
	thread_esm.start();
	thread_sensor_esm = new Handler(thread_esm.getLooper());
	esm_observer = new ESMObserver(thread_sensor_esm, this);
	
	//Calendar
	thread_calendar.start();
	thread_observer_calendar = new Handler(thread_calendar.getLooper());
	calendar_observer = new CalendarObserver(thread_observer_calendar, this);
	
	//Screen
	thread_screen.start();
	thread_sensor_screen = new Handler(thread_screen.getLooper());
	//create a context filter for screen
	IntentFilter screenFilter = new IntentFilter();
	screenFilter.addAction(Screen.ACTION_AWARE_SCREEN_ON);
	screenFilter.addAction(Screen.ACTION_AWARE_SCREEN_OFF);
	screenListener = new ScreenObserver(this);
	
	//Create a context filter for Activity
	thread_activity.start();
	thread_sensor_activity = new Handler(thread_activity.getLooper());
	IntentFilter activityFilter = new IntentFilter();
	activityFilter.addAction(ActivityObserver.ACTION_AWARE_GOOGLE_ACTIVITY_RECOGNITION);
	activityListener = new ActivityObserver(this);
	ActivityObserver.lastActivityESM = screenOnTime;
	
	//Ambient noise
	thread_ambient_noise.start();
	thread_sensor_ambient_noise = new Handler(thread_ambient_noise.getLooper());
	ambient_noise_observer = new AmbientNoiseObserver(thread_sensor_ambient_noise, this);
	AmbientNoiseObserver.lastAmbientESM = screenOnTime;
	
	//Ask Android to register our context receiver
	registerReceiver(screenListener, screenFilter, null, thread_sensor_screen);
	registerReceiver(activityListener, activityFilter, null, thread_sensor_activity);
	//Start listening to changes on the Applications_Foreground, MoT, and NoiseLevel databases
	getContentResolver().registerContentObserver(Applications_Foreground.CONTENT_URI, true, multitask_observer);
	getContentResolver().registerContentObserver(Installations_Data.CONTENT_URI, true, install_observer);
	getContentResolver().registerContentObserver(AmbientNoise_Data.CONTENT_URI, true, ambient_noise_observer);
	getContentResolver().registerContentObserver(Calls_Data.CONTENT_URI, true, phone_observer);
	getContentResolver().registerContentObserver(Messages_Data.CONTENT_URI, true, messages_observer);
	getContentResolver().registerContentObserver(ESM_Data.CONTENT_URI, true, esm_observer);
	getContentResolver().registerContentObserver(Reminders.CONTENT_URI, true, calendar_observer);
}
 

import android.provider.CalendarContract.Reminders; //导入依赖的package包/类
@Override
public void run() {
	clearAllEvents();
	cal = new GregorianCalendar();
	Calendar newCal = new GregorianCalendar();
	//Reset at 12:30am
	int hourOfDay = cal.get(Calendar.HOUR_OF_DAY);
	int minOfDay = cal.get(Calendar.MINUTE);
	if(hourOfDay == 0 && minOfDay < 30){
		newCal.set(Calendar.HOUR_OF_DAY, 0);
		newCal.set(Calendar.MINUTE, 30);
		newCal.set(Calendar.SECOND, 0);	
	} else{
		newCal.add(Calendar.DAY_OF_WEEK, 1); //recalculates calendar if at the end
		newCal.set(Calendar.HOUR_OF_DAY, 0);
		newCal.set(Calendar.MINUTE, 30);
		newCal.set(Calendar.SECOND, 0);
	}
	String[] mSelectionArgs = new String[3];
	String mSelection = "DELETED = ? AND hasAlarm = ? AND allDay = ?";
	long start = cal.getTimeInMillis(); //current time
	long stop = newCal.getTimeInMillis(); //end of day
	mSelectionArgs[0] = "0"; 
	mSelectionArgs[1] = "1"; 
	mSelectionArgs[2] = "0"; 
	Cursor calendar = getContentResolver().query(Events.CONTENT_URI, null, mSelection, mSelectionArgs, Events.DTSTART+" ASC");
	//Go through and grab all events with reminders with our time constraint
	if(calendar != null && calendar.moveToFirst()){
		do{
			String repeating = calendar.getString(calendar.getColumnIndex("rrule"));
			long begin = calendar.getLong(calendar.getColumnIndex(Events.DTSTART));
			long end = calendar.getLong(calendar.getColumnIndex(Events.DTEND));
			if((repeating == null && begin >= start && end <= stop) || (repeating != null)){
				String id = calendar.getString(calendar.getColumnIndex(Events._ID));
				String name = calendar.getString(calendar.getColumnIndex(Events.TITLE));
				//Filter out deleted instances and grab repeating events
				String[] INSTANCE_PROJECTION = new String[] {
				    Instances.EVENT_ID,      // 0
				    Instances.BEGIN,         // 1
				    Instances.END,			 // 2
				    Instances.TITLE          // 3
				};
				String selection = Instances.EVENT_ID + " = ?";
				String[] selectionArgs = new String[] {id};
				Cursor instances = null;
				//Uri for events withing start and stop
				Uri.Builder builder = Instances.CONTENT_URI.buildUpon();
				ContentUris.appendId(builder, start);
				ContentUris.appendId(builder, stop);
				instances = getContentResolver().query(builder.build(), INSTANCE_PROJECTION, selection, selectionArgs, null);
				if(instances == null || instances.getCount() > 0 && instances.moveToNext()){
					//Make sure the instance's begin is after current time (since we didn't check it before)
					if(instances.getLong(instances.getColumnIndex((Instances.BEGIN))) >= start){
						begin = instances.getLong(instances.getColumnIndex(Instances.BEGIN));
						end = instances.getLong(instances.getColumnIndex(Instances.END));
						String[] toReturn = {""};
						toReturn[0] = ""+id;
						int maxReminder = 0;
						Cursor reminders = getContentResolver().query(Reminders.CONTENT_URI, null, "event_id = ?", toReturn, null);
						if(reminders != null && reminders.moveToLast()){
							do{
								int rem = reminders.getInt(reminders.getColumnIndex(Reminders.MINUTES)) ;
								if(rem > maxReminder)
									maxReminder = rem; 
							}while(reminders.moveToPrevious());
						}
						if(maxReminder >= 1 && maxReminder <= 60){
							CalendarEvent e = new CalendarEvent(id,name,begin,end,maxReminder);
							eventList.add(e);
						}
					}
				} if(instances != null && ! instances.isClosed() ) instances.close(); 
			}
		}while(calendar.moveToNext());
	} if(calendar != null && ! calendar.isClosed() ) calendar.close();
	//Run this again when you reach 12:30am either today or the next day
	long current = System.currentTimeMillis();
	if(eventList.size() > 0)
		startCalendarAlarm(0);
	thread_calSetup.postDelayed(this, (stop-current));
}