src/com/android/calendar/DeleteEventHelper.java - platform/packages/apps/Calendar - Git at Google

 /*
  * Copyright (C) 2008 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;

 import android.app.Activity;
 import android.app.AlertDialog;
 import android.content.ContentResolver;
 import android.content.ContentUris;
 import android.content.ContentValues;
 import android.content.DialogInterface;
 import android.database.Cursor;
 import android.net.Uri;
 import android.pim.EventRecurrence;
 import android.provider.Calendar;
 import android.provider.Calendar.Events;
 import android.text.format.Time;
 import android.widget.Button;

 /**
  * A helper class for deleting events.  If a normal event is selected for
  * deletion, then this pops up a confirmation dialog.  If the user confirms,
  * then the normal event is deleted.
  *
  * <p>
  * If a repeating event is selected for deletion, then this pops up dialog
  * asking if the user wants to delete just this one instance, or all the
  * events in the series, or this event plus all following events.  The user
  * may also cancel the delete.
  * </p>
  *
  * <p>
  * To use this class, create an instance, passing in the parent activity
  * and a boolean that determines if the parent activity should exit if the
  * event is deleted.  Then to use the instance, call one of the
  * {@link delete()} methods on this class.
  *
  * An instance of this class may be created once and reused (by calling
  * {@link #delete()} multiple times).
  */
 public class DeleteEventHelper {

     private static final String TAG = "DeleteEventHelper";
     private final Activity mParent;
     private final ContentResolver mContentResolver;

     private long mStartMillis;
     private long mEndMillis;
     private Cursor mCursor;

     /**
      * If true, then call finish() on the parent activity when done.
      */
     private boolean mExitWhenDone;

     /**
      * These are the corresponding indices into the array of strings
      * "R.array.delete_repeating_labels" in the resource file.
      */
     static final int DELETE_SELECTED = 0;
     static final int DELETE_ALL_FOLLOWING = 1;
     static final int DELETE_ALL = 2;

     private int mWhichDelete;
     private AlertDialog mAlertDialog;

     private static final String[] EVENT_PROJECTION = new String[] {
         Events._ID,
         Events.TITLE,
         Events.ALL_DAY,
         Events.CALENDAR_ID,
         Events.RRULE,
         Events.DTSTART,
         Events._SYNC_ID,
         Events.EVENT_TIMEZONE,
     };

     private int mEventIndexId;
     private int mEventIndexRrule;
     private String mSyncId;

     public DeleteEventHelper(Activity parent, boolean exitWhenDone) {
         mParent = parent;
         mContentResolver = mParent.getContentResolver();
         mExitWhenDone = exitWhenDone;
     }

     public void setExitWhenDone(boolean exitWhenDone) {
         mExitWhenDone = exitWhenDone;
     }

     /**
      * This callback is used when a normal event is deleted.
      */
     private DialogInterface.OnClickListener mDeleteNormalDialogListener =
             new DialogInterface.OnClickListener() {
         public void onClick(DialogInterface dialog, int button) {
             long id = mCursor.getInt(mEventIndexId);
             Uri uri = ContentUris.withAppendedId(Calendar.Events.CONTENT_URI, id);
             mContentResolver.delete(uri, null /* where */, null /* selectionArgs */);
             if (mExitWhenDone) {
                 mParent.finish();
             }
         }
     };

     /**
      * This callback is used when a list item for a repeating event is selected
      */
     private DialogInterface.OnClickListener mDeleteListListener =
             new DialogInterface.OnClickListener() {
         public void onClick(DialogInterface dialog, int button) {
             mWhichDelete = button;

             // Enable the "ok" button now that the user has selected which
             // events in the series to delete.
             Button ok = mAlertDialog.getButton(DialogInterface.BUTTON_POSITIVE);
             ok.setEnabled(true);
         }
     };

     /**
      * This callback is used when a repeating event is deleted.
      */
     private DialogInterface.OnClickListener mDeleteRepeatingDialogListener =
             new DialogInterface.OnClickListener() {
         public void onClick(DialogInterface dialog, int button) {
             if (mWhichDelete != -1) {
                 deleteRepeatingEvent(mWhichDelete);
             }
         }
     };

     /**
      * Does the required processing for deleting an event, which includes
      * first popping up a dialog asking for confirmation (if the event is
      * a normal event) or a dialog asking which events to delete (if the
      * event is a repeating event).  The "which" parameter is used to check
      * the initial selection and is only used for repeating events.  Set
      * "which" to -1 to have nothing selected initially.
      *
      * @param begin the begin time of the event, in UTC milliseconds
      * @param end the end time of the event, in UTC milliseconds
      * @param eventId the event id
      * @param which one of the values {@link DELETE_SELECTED},
      *  {@link DELETE_ALL_FOLLOWING}, {@link DELETE_ALL}, or -1
      */
     public void delete(long begin, long end, long eventId, int which) {
         Uri uri = ContentUris.withAppendedId(Calendar.Events.CONTENT_URI, eventId);
         Cursor cursor = mParent.managedQuery(uri, EVENT_PROJECTION, null, null);
         if (cursor == null) {
             return;
         }
         cursor.moveToFirst();
         delete(begin, end, cursor, which);
     }

     /**
      * Does the required processing for deleting an event.  This method
      * takes a {@link Cursor} object as a parameter, which must point to
      * a row in the Events table containing the required database fields.
      * The required fields for a normal event are:
      *
      * <ul>
      *   <li> Events._ID </li>
      *   <li> Events.TITLE </li>
      *   <li> Events.RRULE </li>
      * </ul>
      *
      * The required fields for a repeating event include the above plus the
      * following fields:
      *
      * <ul>
      *   <li> Events.ALL_DAY </li>
      *   <li> Events.CALENDAR_ID </li>
      *   <li> Events.DTSTART </li>
      *   <li> Events._SYNC_ID </li>
      *   <li> Events.EVENT_TIMEZONE </li>
      * </ul>
      *
      * @param begin the begin time of the event, in UTC milliseconds
      * @param end the end time of the event, in UTC milliseconds
      * @param cursor the database cursor containing the required fields
      * @param which one of the values {@link DELETE_SELECTED},
      *  {@link DELETE_ALL_FOLLOWING}, {@link DELETE_ALL}, or -1
      */
     public void delete(long begin, long end, Cursor cursor, int which) {
         mWhichDelete = which;
         mStartMillis = begin;
         mEndMillis = end;
         mCursor = cursor;
         mEventIndexId = mCursor.getColumnIndexOrThrow(Events._ID);
         mEventIndexRrule = mCursor.getColumnIndexOrThrow(Events.RRULE);
         int eventIndexSyncId = mCursor.getColumnIndexOrThrow(Events._SYNC_ID);
         mSyncId = mCursor.getString(eventIndexSyncId);

         // If this is a repeating event, then pop up a dialog asking the
         // user if they want to delete all of the repeating events or
         // just some of them.
         String rRule = mCursor.getString(mEventIndexRrule);
         if (rRule == null) {
             // This is a normal event. Pop up a confirmation dialog.
             new AlertDialog.Builder(mParent)
             .setTitle(R.string.delete_title)
             .setMessage(R.string.delete_this_event_title)
             .setIcon(android.R.drawable.ic_dialog_alert)
             .setPositiveButton(android.R.string.ok, mDeleteNormalDialogListener)
             .setNegativeButton(android.R.string.cancel, null)
             .show();
         } else {
             // This is a repeating event.  Pop up a dialog asking which events
             // to delete.
             int labelsArrayId = R.array.delete_repeating_labels;
             if (mSyncId == null) {
                 labelsArrayId = R.array.delete_repeating_labels_no_selected;
             }
             AlertDialog dialog = new AlertDialog.Builder(mParent)
             .setTitle(R.string.delete_title)
             .setIcon(android.R.drawable.ic_dialog_alert)
             .setSingleChoiceItems(labelsArrayId, which, mDeleteListListener)
             .setPositiveButton(android.R.string.ok, mDeleteRepeatingDialogListener)
             .setNegativeButton(android.R.string.cancel, null)
             .show();
             mAlertDialog = dialog;

             if (which == -1) {
                 // Disable the "Ok" button until the user selects which events
                 // to delete.
                 Button ok = dialog.getButton(DialogInterface.BUTTON_POSITIVE);
                 ok.setEnabled(false);
             }
         }
     }

     private void deleteRepeatingEvent(int which) {
         int indexDtstart = mCursor.getColumnIndexOrThrow(Events.DTSTART);
         int indexAllDay = mCursor.getColumnIndexOrThrow(Events.ALL_DAY);
         int indexTitle = mCursor.getColumnIndexOrThrow(Events.TITLE);
         int indexTimezone = mCursor.getColumnIndexOrThrow(Events.EVENT_TIMEZONE);
         int indexCalendarId = mCursor.getColumnIndexOrThrow(Events.CALENDAR_ID);

         String rRule = mCursor.getString(mEventIndexRrule);
         boolean allDay = mCursor.getInt(indexAllDay) != 0;
         long dtstart = mCursor.getLong(indexDtstart);
         long id = mCursor.getInt(mEventIndexId);

         // If the repeating event has not been given a sync id from the server
         // yet, then we can't delete a single instance of this event.  (This is
         // a deficiency in the CalendarProvider and sync code.) We checked for
         // that when creating the list of items in the dialog and we removed
         // the first element ("DELETE_SELECTED") from the dialog in that case.
         // The "which" value is a 0-based index into the list of items, where
         // the "DELETE_SELECTED" item is at index 0.
         if (mSyncId == null) {
             which += 1;
         }

         switch (which) {
             case DELETE_SELECTED:
             {
                 // If we are deleting the first event in the series, then
                 // instead of creating a recurrence exception, just change
                 // the start time of the recurrence.
                 if (dtstart == mStartMillis) {
                     // TODO
                 }

                 // Create a recurrence exception by creating a new event
                 // with the status "cancelled".
                 ContentValues values = new ContentValues();

                 // The title might not be necessary, but it makes it easier
                 // to find this entry in the database when there is a problem.
                 String title = mCursor.getString(indexTitle);
                 values.put(Events.TITLE, title);

                 String timezone = mCursor.getString(indexTimezone);
                 int calendarId = mCursor.getInt(indexCalendarId);
                 values.put(Events.EVENT_TIMEZONE, timezone);
                 values.put(Events.ALL_DAY, allDay ? 1 : 0);
                 values.put(Events.CALENDAR_ID, calendarId);
                 values.put(Events.DTSTART, mStartMillis);
                 values.put(Events.DTEND, mEndMillis);
                 values.put(Events.ORIGINAL_EVENT, mSyncId);
                 values.put(Events.ORIGINAL_INSTANCE_TIME, mStartMillis);
                 values.put(Events.STATUS, Events.STATUS_CANCELED);

                 mContentResolver.insert(Events.CONTENT_URI, values);
                 break;
             }
             case DELETE_ALL: {
                 Uri uri = ContentUris.withAppendedId(Calendar.Events.CONTENT_URI, id);
                 mContentResolver.delete(uri, null /* where */, null /* selectionArgs */);
                 break;
             }
             case DELETE_ALL_FOLLOWING: {
                 // If we are deleting the first event in the series and all
                 // following events, then delete them all.
                 if (dtstart == mStartMillis) {
                     Uri uri = ContentUris.withAppendedId(Calendar.Events.CONTENT_URI, id);
                     mContentResolver.delete(uri, null /* where */, null /* selectionArgs */);
                     break;
                 }

                 // Modify the repeating event to end just before this event time
                 EventRecurrence eventRecurrence = new EventRecurrence();
                 eventRecurrence.parse(rRule);
                 Time date = new Time();
                 if (allDay) {
                     date.timezone = Time.TIMEZONE_UTC;
                 }
                 date.set(mStartMillis);
                 date.second--;
                 date.normalize(false);

                 // Google calendar seems to require the UNTIL string to be
                 // in UTC.
                 date.switchTimezone(Time.TIMEZONE_UTC);
                 eventRecurrence.until = date.format2445();

                 ContentValues values = new ContentValues();
                 values.put(Events.DTSTART, dtstart);
                 values.put(Events.RRULE, eventRecurrence.toString());
                 Uri uri = ContentUris.withAppendedId(Calendar.Events.CONTENT_URI, id);
                 mContentResolver.update(uri, values, null, null);
                 break;
             }
         }
         if (mExitWhenDone) {
             mParent.finish();
         }
     }
 }
	/*
	* Copyright (C) 2008 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;

	import android.app.Activity;
	import android.app.AlertDialog;
	import android.content.ContentResolver;
	import android.content.ContentUris;
	import android.content.ContentValues;
	import android.content.DialogInterface;
	import android.database.Cursor;
	import android.net.Uri;
	import android.pim.EventRecurrence;
	import android.provider.Calendar;
	import android.provider.Calendar.Events;
	import android.text.format.Time;
	import android.widget.Button;

	/**
	* A helper class for deleting events. If a normal event is selected for
	* deletion, then this pops up a confirmation dialog. If the user confirms,
	* then the normal event is deleted.
	*
	* <p>
	* If a repeating event is selected for deletion, then this pops up dialog
	* asking if the user wants to delete just this one instance, or all the
	* events in the series, or this event plus all following events. The user
	* may also cancel the delete.
	* </p>
	*
	* <p>
	* To use this class, create an instance, passing in the parent activity
	* and a boolean that determines if the parent activity should exit if the
	* event is deleted. Then to use the instance, call one of the
	* {@link delete()} methods on this class.
	*
	* An instance of this class may be created once and reused (by calling
	* {@link #delete()} multiple times).
	*/
	public class DeleteEventHelper {

	private static final String TAG = "DeleteEventHelper";
	private final Activity mParent;
	private final ContentResolver mContentResolver;

	private long mStartMillis;
	private long mEndMillis;
	private Cursor mCursor;

	/**
	* If true, then call finish() on the parent activity when done.
	*/
	private boolean mExitWhenDone;

	/**
	* These are the corresponding indices into the array of strings
	* "R.array.delete_repeating_labels" in the resource file.
	*/
	static final int DELETE_SELECTED = 0;
	static final int DELETE_ALL_FOLLOWING = 1;
	static final int DELETE_ALL = 2;

	private int mWhichDelete;
	private AlertDialog mAlertDialog;

	private static final String[] EVENT_PROJECTION = new String[] {
	Events._ID,
	Events.TITLE,
	Events.ALL_DAY,
	Events.CALENDAR_ID,
	Events.RRULE,
	Events.DTSTART,
	Events._SYNC_ID,
	Events.EVENT_TIMEZONE,
	};

	private int mEventIndexId;
	private int mEventIndexRrule;
	private String mSyncId;

	public DeleteEventHelper(Activity parent, boolean exitWhenDone) {
	mParent = parent;
	mContentResolver = mParent.getContentResolver();
	mExitWhenDone = exitWhenDone;
	}

	public void setExitWhenDone(boolean exitWhenDone) {
	mExitWhenDone = exitWhenDone;
	}

	/**
	* This callback is used when a normal event is deleted.
	*/
	private DialogInterface.OnClickListener mDeleteNormalDialogListener =
	new DialogInterface.OnClickListener() {
	public void onClick(DialogInterface dialog, int button) {
	long id = mCursor.getInt(mEventIndexId);
	Uri uri = ContentUris.withAppendedId(Calendar.Events.CONTENT_URI, id);
	mContentResolver.delete(uri, null /* where /, null / selectionArgs */);
	if (mExitWhenDone) {
	mParent.finish();
	}
	}
	};

	/**
	* This callback is used when a list item for a repeating event is selected
	*/
	private DialogInterface.OnClickListener mDeleteListListener =
	new DialogInterface.OnClickListener() {
	public void onClick(DialogInterface dialog, int button) {
	mWhichDelete = button;

	// Enable the "ok" button now that the user has selected which
	// events in the series to delete.
	Button ok = mAlertDialog.getButton(DialogInterface.BUTTON_POSITIVE);
	ok.setEnabled(true);
	}
	};

	/**
	* This callback is used when a repeating event is deleted.
	*/
	private DialogInterface.OnClickListener mDeleteRepeatingDialogListener =
	new DialogInterface.OnClickListener() {
	public void onClick(DialogInterface dialog, int button) {
	if (mWhichDelete != -1) {
	deleteRepeatingEvent(mWhichDelete);
	}
	}
	};

	/**
	* Does the required processing for deleting an event, which includes
	* first popping up a dialog asking for confirmation (if the event is
	* a normal event) or a dialog asking which events to delete (if the
	* event is a repeating event). The "which" parameter is used to check
	* the initial selection and is only used for repeating events. Set
	* "which" to -1 to have nothing selected initially.
	*
	* @param begin the begin time of the event, in UTC milliseconds
	* @param end the end time of the event, in UTC milliseconds
	* @param eventId the event id
	* @param which one of the values {@link DELETE_SELECTED},
	* {@link DELETE_ALL_FOLLOWING}, {@link DELETE_ALL}, or -1
	*/
	public void delete(long begin, long end, long eventId, int which) {
	Uri uri = ContentUris.withAppendedId(Calendar.Events.CONTENT_URI, eventId);
	Cursor cursor = mParent.managedQuery(uri, EVENT_PROJECTION, null, null);
	if (cursor == null) {
	return;
	}
	cursor.moveToFirst();
	delete(begin, end, cursor, which);
	}

	/**
	* Does the required processing for deleting an event. This method
	* takes a {@link Cursor} object as a parameter, which must point to
	* a row in the Events table containing the required database fields.
	* The required fields for a normal event are:
	*
	* <ul>
	* <li> Events._ID </li>
	* <li> Events.TITLE </li>
	* <li> Events.RRULE </li>
	* </ul>
	*
	* The required fields for a repeating event include the above plus the
	* following fields:
	*
	* <ul>
	* <li> Events.ALL_DAY </li>
	* <li> Events.CALENDAR_ID </li>
	* <li> Events.DTSTART </li>
	* <li> Events._SYNC_ID </li>
	* <li> Events.EVENT_TIMEZONE </li>
	* </ul>
	*
	* @param begin the begin time of the event, in UTC milliseconds
	* @param end the end time of the event, in UTC milliseconds
	* @param cursor the database cursor containing the required fields
	* @param which one of the values {@link DELETE_SELECTED},
	* {@link DELETE_ALL_FOLLOWING}, {@link DELETE_ALL}, or -1
	*/
	public void delete(long begin, long end, Cursor cursor, int which) {
	mWhichDelete = which;
	mStartMillis = begin;
	mEndMillis = end;
	mCursor = cursor;
	mEventIndexId = mCursor.getColumnIndexOrThrow(Events._ID);
	mEventIndexRrule = mCursor.getColumnIndexOrThrow(Events.RRULE);
	int eventIndexSyncId = mCursor.getColumnIndexOrThrow(Events._SYNC_ID);
	mSyncId = mCursor.getString(eventIndexSyncId);

	// If this is a repeating event, then pop up a dialog asking the
	// user if they want to delete all of the repeating events or
	// just some of them.
	String rRule = mCursor.getString(mEventIndexRrule);
	if (rRule == null) {
	// This is a normal event. Pop up a confirmation dialog.
	new AlertDialog.Builder(mParent)
	.setTitle(R.string.delete_title)
	.setMessage(R.string.delete_this_event_title)
	.setIcon(android.R.drawable.ic_dialog_alert)
	.setPositiveButton(android.R.string.ok, mDeleteNormalDialogListener)
	.setNegativeButton(android.R.string.cancel, null)
	.show();
	} else {
	// This is a repeating event. Pop up a dialog asking which events
	// to delete.
	int labelsArrayId = R.array.delete_repeating_labels;
	if (mSyncId == null) {
	labelsArrayId = R.array.delete_repeating_labels_no_selected;
	}
	AlertDialog dialog = new AlertDialog.Builder(mParent)
	.setTitle(R.string.delete_title)
	.setIcon(android.R.drawable.ic_dialog_alert)
	.setSingleChoiceItems(labelsArrayId, which, mDeleteListListener)
	.setPositiveButton(android.R.string.ok, mDeleteRepeatingDialogListener)
	.setNegativeButton(android.R.string.cancel, null)
	.show();
	mAlertDialog = dialog;

	if (which == -1) {
	// Disable the "Ok" button until the user selects which events
	// to delete.
	Button ok = dialog.getButton(DialogInterface.BUTTON_POSITIVE);
	ok.setEnabled(false);
	}
	}
	}

	private void deleteRepeatingEvent(int which) {
	int indexDtstart = mCursor.getColumnIndexOrThrow(Events.DTSTART);
	int indexAllDay = mCursor.getColumnIndexOrThrow(Events.ALL_DAY);
	int indexTitle = mCursor.getColumnIndexOrThrow(Events.TITLE);
	int indexTimezone = mCursor.getColumnIndexOrThrow(Events.EVENT_TIMEZONE);
	int indexCalendarId = mCursor.getColumnIndexOrThrow(Events.CALENDAR_ID);

	String rRule = mCursor.getString(mEventIndexRrule);
	boolean allDay = mCursor.getInt(indexAllDay) != 0;
	long dtstart = mCursor.getLong(indexDtstart);
	long id = mCursor.getInt(mEventIndexId);

	// If the repeating event has not been given a sync id from the server
	// yet, then we can't delete a single instance of this event. (This is
	// a deficiency in the CalendarProvider and sync code.) We checked for
	// that when creating the list of items in the dialog and we removed
	// the first element ("DELETE_SELECTED") from the dialog in that case.
	// The "which" value is a 0-based index into the list of items, where
	// the "DELETE_SELECTED" item is at index 0.
	if (mSyncId == null) {
	which += 1;
	}

	switch (which) {
	case DELETE_SELECTED:
	{
	// If we are deleting the first event in the series, then
	// instead of creating a recurrence exception, just change
	// the start time of the recurrence.
	if (dtstart == mStartMillis) {
	// TODO
	}

	// Create a recurrence exception by creating a new event
	// with the status "cancelled".
	ContentValues values = new ContentValues();

	// The title might not be necessary, but it makes it easier
	// to find this entry in the database when there is a problem.
	String title = mCursor.getString(indexTitle);
	values.put(Events.TITLE, title);

	String timezone = mCursor.getString(indexTimezone);
	int calendarId = mCursor.getInt(indexCalendarId);
	values.put(Events.EVENT_TIMEZONE, timezone);
	values.put(Events.ALL_DAY, allDay ? 1 : 0);
	values.put(Events.CALENDAR_ID, calendarId);
	values.put(Events.DTSTART, mStartMillis);
	values.put(Events.DTEND, mEndMillis);
	values.put(Events.ORIGINAL_EVENT, mSyncId);
	values.put(Events.ORIGINAL_INSTANCE_TIME, mStartMillis);
	values.put(Events.STATUS, Events.STATUS_CANCELED);

	mContentResolver.insert(Events.CONTENT_URI, values);
	break;
	}
	case DELETE_ALL: {
	Uri uri = ContentUris.withAppendedId(Calendar.Events.CONTENT_URI, id);
	mContentResolver.delete(uri, null /* where /, null / selectionArgs */);
	break;
	}
	case DELETE_ALL_FOLLOWING: {
	// If we are deleting the first event in the series and all
	// following events, then delete them all.
	if (dtstart == mStartMillis) {
	Uri uri = ContentUris.withAppendedId(Calendar.Events.CONTENT_URI, id);
	mContentResolver.delete(uri, null /* where /, null / selectionArgs */);
	break;
	}

	// Modify the repeating event to end just before this event time
	EventRecurrence eventRecurrence = new EventRecurrence();
	eventRecurrence.parse(rRule);
	Time date = new Time();
	if (allDay) {
	date.timezone = Time.TIMEZONE_UTC;
	}
	date.set(mStartMillis);
	date.second--;
	date.normalize(false);

	// Google calendar seems to require the UNTIL string to be
	// in UTC.
	date.switchTimezone(Time.TIMEZONE_UTC);
	eventRecurrence.until = date.format2445();

	ContentValues values = new ContentValues();
	values.put(Events.DTSTART, dtstart);
	values.put(Events.RRULE, eventRecurrence.toString());
	Uri uri = ContentUris.withAppendedId(Calendar.Events.CONTENT_URI, id);
	mContentResolver.update(uri, values, null, null);
	break;
	}
	}
	if (mExitWhenDone) {
	mParent.finish();
	}
	}
	}