add deleteCalendar() function

android/src/main/kotlin/com/builttoroam/devicecalendar/CalendarDelegate.kt

@@ -83,6 +83,7 @@ class CalendarDelegate : PluginRegistry.RequestPermissionsResultListener {
     private val CREATE_OR_UPDATE_EVENT_REQUEST_CODE = RETRIEVE_CALENDAR_REQUEST_CODE + 1
     private val DELETE_EVENT_REQUEST_CODE = CREATE_OR_UPDATE_EVENT_REQUEST_CODE + 1
     private val REQUEST_PERMISSIONS_REQUEST_CODE = DELETE_EVENT_REQUEST_CODE + 1
+    private val DELETE_CALENDAR_REQUEST_CODE = REQUEST_PERMISSIONS_REQUEST_CODE + 1
     private val PART_TEMPLATE = ";%s="
     private val BYMONTHDAY_PART = "BYMONTHDAY"
     private val BYMONTH_PART = "BYMONTH"
@@ -141,6 +142,9 @@ class CalendarDelegate : PluginRegistry.RequestPermissionsResultListener {
                 REQUEST_PERMISSIONS_REQUEST_CODE -> {
                     finishWithSuccess(permissionGranted, cachedValues.pendingChannelResult)
                 }
+                DELETE_CALENDAR_REQUEST_CODE -> {
+                    deleteCalendar(cachedValues.calendarId,cachedValues.pendingChannelResult)
+                }
             }
 
             return true
@@ -236,6 +240,39 @@ class CalendarDelegate : PluginRegistry.RequestPermissionsResultListener {
         return null
     }
 
+    fun deleteCalendar(calendarId: String, pendingChannelResult: MethodChannel.Result, isInternalCall: Boolean = false): Calendar? {
+        if (isInternalCall || arePermissionsGranted()) {
+            val calendarIdNumber = calendarId.toLongOrNull()
+            if (calendarIdNumber == null) {
+                if (!isInternalCall) {
+                    finishWithError(INVALID_ARGUMENT, CALENDAR_ID_INVALID_ARGUMENT_NOT_A_NUMBER_MESSAGE, pendingChannelResult)
+                }
+                return null
+            }
+
+            val contentResolver: ContentResolver? = _context?.contentResolver
+
+            val calendar = retrieveCalendar(calendarId,pendingChannelResult,true);
+            if(calendar != null) {
+                val calenderUriWithId = ContentUris.withAppendedId(CalendarContract.Calendars.CONTENT_URI, calendarIdNumber)
+                val deleteSucceeded = contentResolver?.delete(calenderUriWithId, null, null) ?: 0
+                finishWithSuccess(deleteSucceeded > 0, pendingChannelResult)
+            }else {
+                if (!isInternalCall) {
+                    finishWithError(NOT_FOUND, "The calendar with the ID $calendarId could not be found", pendingChannelResult)
+                }
+            }
+        } else {
+            val parameters = CalendarMethodsParametersCacheModel(
+                    pendingChannelResult = pendingChannelResult,
+                    calendarDelegateMethodCode = DELETE_CALENDAR_REQUEST_CODE,
+                    calendarId = calendarId)
+            requestPermissions(parameters)
+        }
+
+        return null
+    }
+
     fun createCalendar(calendarName: String, calendarColor: String?, localAccountName: String, pendingChannelResult: MethodChannel.Result) {
         val contentResolver: ContentResolver? = _context?.contentResolver
 

android/src/main/kotlin/com/builttoroam/devicecalendar/DeviceCalendarPlugin.kt

@@ -23,6 +23,7 @@ class DeviceCalendarPlugin() : MethodCallHandler {
     private val DELETE_EVENT_INSTANCE_METHOD = "deleteEventInstance"
     private val CREATE_OR_UPDATE_EVENT_METHOD = "createOrUpdateEvent"
     private val CREATE_CALENDAR_METHOD = "createCalendar"
+    private val DELETE_CALENDAR_METHOD = "deleteCalendar"
 
     // Method arguments
     private val CALENDAR_ID_ARGUMENT = "calendarId"
@@ -130,6 +131,10 @@ class DeviceCalendarPlugin() : MethodCallHandler {
 
                 _calendarDelegate.createCalendar(calendarName!!, calendarColor, localAccountName!!, result)
             }
+            DELETE_CALENDAR_METHOD -> {
+                val calendarId = call.argument<String>(CALENDAR_ID_ARGUMENT)
+                _calendarDelegate.deleteCalendar(calendarId!!,result)
+            }
             else -> {
                 result.notImplemented()
             }

example/lib/presentation/pages/calendar_events.dart

@@ -40,7 +40,9 @@ class _CalendarEventsPageState extends State<CalendarEventsPage> {
   Widget build(BuildContext context) {
     return Scaffold(
         key: _scaffoldstate,
-        appBar: AppBar(title: Text('${_calendar.name} events')),
+        appBar: AppBar(title: Text('${_calendar.name} events'),actions: [
+          _getDeleteButton()
+        ],),
         body: ((_calendarEvents?.isNotEmpty ?? false) || _isLoading)
             ? Stack(
                 children: [
@@ -137,4 +139,50 @@ class _CalendarEventsPageState extends State<CalendarEventsPage> {
       _isLoading = false;
     });
   }
+
+  Widget _getDeleteButton() {
+    return IconButton(
+        icon: Icon(Icons.delete),
+        onPressed: () async {
+          _showDeleteDialog();
+        });
+  }
+
+  Future<void> _showDeleteDialog() async {
+    return showDialog<void>(
+      context: context,
+      builder: (BuildContext context) {
+        return AlertDialog(
+          title: Text('Warning'),
+          content: SingleChildScrollView(
+            child: ListBody(
+              children: <Widget>[
+                Text('This will delete this calendar'),
+                Text('Are you sure?'),
+              ],
+            ),
+          ),
+          actions: <Widget>[
+            TextButton(
+              child: Text('Delete!'),
+              onPressed: () async {
+                var returnValue = await _deviceCalendarPlugin.deleteCalendar(_calendar.id);
+                print("returnValue: ${returnValue.data}, ${returnValue.errors}");
+                Navigator.of(context).pop();
+                Navigator.of(context).pop();
+              },
+            ),
+            TextButton(
+              child: Text('Cancel'),
+              onPressed: () {
+                Navigator.of(context).pop();
+              },
+            ),
+          ],
+        );
+      },
+    );
+  }
 }
+
+

example/lib/presentation/pages/calendars.dart

@@ -38,6 +38,9 @@ class _CalendarsPageState extends State<CalendarsPage> {
     return Scaffold(
       appBar: AppBar(
         title: Text('Calendars'),
+        actions: [
+          _getRefreshButton()
+        ],
       ),
       body: Column(
         children: [
@@ -136,4 +139,12 @@ class _CalendarsPageState extends State<CalendarsPage> {
       print(e);
     }
   }
+
+  Widget _getRefreshButton() {
+    return IconButton(
+        icon: Icon(Icons.refresh),
+        onPressed: () async {
+          _retrieveCalendars();
+        });
+  }
 }

ios/Classes/SwiftDeviceCalendarPlugin.swift

@@ -87,6 +87,7 @@ public class SwiftDeviceCalendarPlugin: NSObject, FlutterPlugin {
     let retrieveSourcesMethod = "retrieveSources"
     let createOrUpdateEventMethod = "createOrUpdateEvent"
     let createCalendarMethod = "createCalendar"
+    let deleteCalendarMethod = "deleteCalendar"
     let deleteEventMethod = "deleteEvent"
     let deleteEventInstanceMethod = "deleteEventInstance"
     let calendarIdArgument = "calendarId"
@@ -146,6 +147,8 @@ public class SwiftDeviceCalendarPlugin: NSObject, FlutterPlugin {
             deleteEvent(call, result)
         case createCalendarMethod:
             createCalendar(call, result)
+        case deleteCalendarMethod:
+            deleteCalendar(call, result)
         default:
             result(FlutterMethodNotImplemented)
         }
@@ -209,6 +212,32 @@ public class SwiftDeviceCalendarPlugin: NSObject, FlutterPlugin {
         }, result: result)
     }
 
+    private func deleteCalendar(_ call: FlutterMethodCall, _ result: @escaping FlutterResult) {
+        checkPermissionsThenExecute(permissionsGrantedAction: {
+            let arguments = call.arguments as! Dictionary<String, AnyObject>
+            let calendarId = arguments[calendarIdArgument] as! String
+
+            let ekCalendar = self.eventStore.calendar(withIdentifier: calendarId)
+            if ekCalendar == nil {
+                self.finishWithCalendarNotFoundError(result: result, calendarId: calendarId)
+                return
+            }
+
+            if !(ekCalendar!.allowsContentModifications) {
+                self.finishWithCalendarReadOnlyError(result: result, calendarId: calendarId)
+                return
+            }
+
+            do {
+                try self.eventStore.removeCalendar(ekCalendar!, commit: true)
+                result(true)
+            } catch {
+                self.eventStore.reset()
+                result(FlutterError(code: self.genericError, message: error.localizedDescription, details: nil))
+            }
+        }, result: result)
+    }
+
     private func getAccountType(_ sourceType: EKSourceType) -> String {
         switch (sourceType) {
         case .local:

lib/src/common/channel_constants.dart

@@ -9,6 +9,7 @@ class ChannelConstants {
   static const String methodNameDeleteEventInstance = 'deleteEventInstance';
   static const String methodNameCreateOrUpdateEvent = 'createOrUpdateEvent';
   static const String methodNameCreateCalendar = 'createCalendar';
+  static const String methodNameDeleteCalendar = 'deleteCalendar';
 
   static const String parameterNameCalendarId = 'calendarId';
   static const String parameterNameStartDate = 'startDate';

lib/src/device_calendar.dart

@@ -272,6 +272,26 @@ class DeviceCalendarPlugin {
     );
   }
 
+  /// Deletes a calendar.
+  /// The `calendarId` parameter is the id of the calendar that plugin will try to delete the event from\///
+  /// Returns a [Result] indicating if the instance of the calendar has (true) or has not (false) been deleted
+  Future<Result<bool>> deleteCalendar(
+      String calendarId,
+      ) async {
+    return _invokeChannelMethod(
+      ChannelConstants.methodNameDeleteCalendar,
+      assertParameters: (result) {
+        _validateCalendarIdParameter(
+          result,
+          calendarId,
+        );
+      },
+      arguments: () => <String, Object>{
+        ChannelConstants.parameterNameCalendarId: calendarId,
+      },
+    );
+  }
+
   Future<Result<T>> _invokeChannelMethod<T>(
     String channelMethodName, {
     Function(Result<T>) assertParameters,