diff options
Diffstat (limited to 'plugins/de.appplant.cordova.plugin.local-notification/src/ios')
8 files changed, 1796 insertions, 0 deletions
diff --git a/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotification.h b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotification.h new file mode 100644 index 00000000..f86bf498 --- /dev/null +++ b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotification.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2013-2015 by appPlant UG. All rights reserved. + * + * @APPPLANT_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apache License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://opensource.org/licenses/Apache-2.0/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPPLANT_LICENSE_HEADER_END@ + */ + +#import <Foundation/Foundation.h> +#import <Cordova/CDVPlugin.h> + +@interface APPLocalNotification : CDVPlugin + +// Execute all queued events +- (void) deviceready:(CDVInvokedUrlCommand*)command; + +// Inform if the app has the permission to show notifications +- (void) hasPermission:(CDVInvokedUrlCommand*)command; +// Register permission to show notifications +- (void) registerPermission:(CDVInvokedUrlCommand*)command; + +// Schedule set of notifications +- (void) schedule:(CDVInvokedUrlCommand*)command; +// Update set of notifications +- (void) update:(CDVInvokedUrlCommand*)command; +// Cancel set of notifications +- (void) cancel:(CDVInvokedUrlCommand*)command; +// Cancel all notifications +- (void) cancelAll:(CDVInvokedUrlCommand*)command; +// Clear set of notifications +- (void) clear:(CDVInvokedUrlCommand*)command; +// Clear all notifications +- (void) clearAll:(CDVInvokedUrlCommand*)command; + +// If a notification with an ID is present +- (void) isPresent:(CDVInvokedUrlCommand*)command; +// If a notification with an ID is scheduled +- (void) isScheduled:(CDVInvokedUrlCommand*)command; +// If a notification with an ID is triggered +- (void) isTriggered:(CDVInvokedUrlCommand*)command; + +// List all ids from all local notifications +- (void) getAllIds:(CDVInvokedUrlCommand*)command; +// List all ids from all pending notifications +- (void) getScheduledIds:(CDVInvokedUrlCommand*)command; +// List all ids from all triggered notifications +- (void) getTriggeredIds:(CDVInvokedUrlCommand*)command; + +// Propertys for given local notification +- (void) getSingle:(CDVInvokedUrlCommand*)command; +// Propertya for given scheduled notification +- (void) getSingleScheduled:(CDVInvokedUrlCommand*)command; +// Propertys for given triggered notification +- (void) getSingleTriggered:(CDVInvokedUrlCommand*)command; + +// Property list for given local notifications +- (void) getAll:(CDVInvokedUrlCommand*)command; +// Property list for given scheduled notifications +- (void) getScheduled:(CDVInvokedUrlCommand*)command; +// Property list for given triggered notifications +- (void) getTriggered:(CDVInvokedUrlCommand*)command; + +@end diff --git a/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotification.m b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotification.m new file mode 100644 index 00000000..43cf9f8c --- /dev/null +++ b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotification.m @@ -0,0 +1,738 @@ +/* + * Copyright (c) 2013-2015 by appPlant UG. All rights reserved. + * + * @APPPLANT_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apache License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://opensource.org/licenses/Apache-2.0/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPPLANT_LICENSE_HEADER_END@ + */ + +#import "APPLocalNotification.h" +#import "APPLocalNotificationOptions.h" +#import "UIApplication+APPLocalNotification.h" +#import "UILocalNotification+APPLocalNotification.h" +#import "AppDelegate+APPRegisterUserNotificationSettings.h" + +@interface APPLocalNotification () + +// Retrieves the application state +@property (readonly, getter=applicationState) NSString* applicationState; +// All events will be queued until deviceready has been fired +@property (readwrite, assign) BOOL deviceready; +// Event queue +@property (readonly, nonatomic, retain) NSMutableArray* eventQueue; +// Needed when calling `registerPermission` +@property (nonatomic, retain) CDVInvokedUrlCommand* command; + +@end + +@implementation APPLocalNotification + +@synthesize deviceready, eventQueue; + +#pragma mark - +#pragma mark Interface + +/** + * Execute all queued events. + */ +- (void) deviceready:(CDVInvokedUrlCommand*)command +{ + deviceready = YES; + + for (NSString* js in eventQueue) { + [self.commandDelegate evalJs:js]; + } + + [eventQueue removeAllObjects]; +} + +/** + * Schedule a set of notifications. + * + * @param properties + * A dict of properties for each notification + */ +- (void) schedule:(CDVInvokedUrlCommand*)command +{ + NSArray* notifications = command.arguments; + + [self.commandDelegate runInBackground:^{ + for (NSDictionary* options in notifications) { + UILocalNotification* notification; + + notification = [[UILocalNotification alloc] + initWithOptions:options]; + + [self scheduleLocalNotification:[notification copy]]; + [self fireEvent:@"schedule" notification:notification]; + + if (notifications.count > 1) { + [NSThread sleepForTimeInterval:0.01]; + } + } + + [self execCallback:command]; + }]; +} + +/** + * Update a set of notifications. + * + * @param properties + * A dict of properties for each notification + */ +- (void) update:(CDVInvokedUrlCommand*)command +{ + NSArray* notifications = command.arguments; + + [self.commandDelegate runInBackground:^{ + for (NSDictionary* options in notifications) { + NSNumber* id = [options objectForKey:@"id"]; + UILocalNotification* notification; + + notification = [self.app localNotificationWithId:id]; + + if (!notification) + continue; + + [self updateLocalNotification:[notification copy] + withOptions:options]; + + [self fireEvent:@"update" notification:notification]; + + if (notifications.count > 1) { + [NSThread sleepForTimeInterval:0.01]; + } + } + + [self execCallback:command]; + }]; +} + +/** + * Cancel a set of notifications. + * + * @param ids + * The IDs of the notifications + */ +- (void) cancel:(CDVInvokedUrlCommand*)command +{ + [self.commandDelegate runInBackground:^{ + for (NSNumber* id in command.arguments) { + UILocalNotification* notification; + + notification = [self.app localNotificationWithId:id]; + + if (!notification) + continue; + + [self.app cancelLocalNotification:notification]; + [self fireEvent:@"cancel" notification:notification]; + } + + [self execCallback:command]; + }]; +} + +/** + * Cancel all local notifications. + */ +- (void) cancelAll:(CDVInvokedUrlCommand*)command +{ + [self.commandDelegate runInBackground:^{ + [self cancelAllLocalNotifications]; + [self fireEvent:@"cancelall"]; + [self execCallback:command]; + }]; +} + +/** + * Clear a set of notifications. + * + * @param ids + * The IDs of the notifications + */ +- (void) clear:(CDVInvokedUrlCommand*)command +{ + [self.commandDelegate runInBackground:^{ + for (NSNumber* id in command.arguments) { + UILocalNotification* notification; + + notification = [self.app localNotificationWithId:id]; + + if (!notification) + continue; + + [self.app clearLocalNotification:notification]; + [self fireEvent:@"clear" notification:notification]; + } + + [self execCallback:command]; + }]; +} + +/** + * Clear all local notifications. + */ +- (void) clearAll:(CDVInvokedUrlCommand*)command +{ + [self.commandDelegate runInBackground:^{ + [self clearAllLocalNotifications]; + [self fireEvent:@"clearall"]; + [self execCallback:command]; + }]; +} + +/** + * If a notification by ID is present. + * + * @param id + * The ID of the notification + */ +- (void) isPresent:(CDVInvokedUrlCommand *)command +{ + [self isPresent:command type:NotifcationTypeAll]; +} + +/** + * If a notification by ID is scheduled. + * + * @param id + * The ID of the notification + */ +- (void) isScheduled:(CDVInvokedUrlCommand*)command +{ + [self isPresent:command type:NotifcationTypeScheduled]; +} + +/** + * Check if a notification with an ID is triggered. + * + * @param id + * The ID of the notification + */ +- (void) isTriggered:(CDVInvokedUrlCommand*)command +{ + [self isPresent:command type:NotifcationTypeTriggered]; +} + +/** + * Check if a notification with an ID exists. + * + * @param type + * The notification life cycle type + */ +- (void) isPresent:(CDVInvokedUrlCommand*)command + type:(APPLocalNotificationType)type; +{ + [self.commandDelegate runInBackground:^{ + NSNumber* id = [command argumentAtIndex:0]; + BOOL exist; + + CDVPluginResult* result; + + if (type == NotifcationTypeAll) { + exist = [self.app localNotificationExist:id]; + } else { + exist = [self.app localNotificationExist:id type:type]; + } + + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK + messageAsBool:exist]; + + [self.commandDelegate sendPluginResult:result + callbackId:command.callbackId]; + }]; +} + +/** + * List all ids from all local notifications. + */ +- (void) getAllIds:(CDVInvokedUrlCommand*)command +{ + [self getIds:command byType:NotifcationTypeAll]; +} + +/** + * List all ids from all pending notifications. + */ +- (void) getScheduledIds:(CDVInvokedUrlCommand*)command +{ + [self getIds:command byType:NotifcationTypeScheduled]; +} + +/** + * List all ids from all triggered notifications. + */ +- (void) getTriggeredIds:(CDVInvokedUrlCommand*)command +{ + [self getIds:command byType:NotifcationTypeTriggered]; +} + +/** + * List of ids for given local notifications. + * + * @param type + * Notification life cycle type + * @param ids + * The IDs of the notifications + */ +- (void) getIds:(CDVInvokedUrlCommand*)command + byType:(APPLocalNotificationType)type; +{ + [self.commandDelegate runInBackground:^{ + CDVPluginResult* result; + NSArray* ids; + + if (type == NotifcationTypeAll) { + ids = [self.app localNotificationIds]; + } else { + ids = [self.app localNotificationIdsByType:type]; + } + + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK + messageAsArray:ids]; + + [self.commandDelegate sendPluginResult:result + callbackId:command.callbackId]; + }]; +} + +/** + * Propertys for given local notification. + */ +- (void) getSingle:(CDVInvokedUrlCommand*)command +{ + [self getOption:command byType:NotifcationTypeAll]; +} + +/** + * Propertya for given scheduled notification. + */ +- (void) getSingleScheduled:(CDVInvokedUrlCommand*)command +{ + [self getOption:command byType:NotifcationTypeScheduled]; +} + +// Propertys for given triggered notification +- (void) getSingleTriggered:(CDVInvokedUrlCommand*)command +{ + [self getOption:command byType:NotifcationTypeTriggered]; +} + +/** + * Property list for given local notifications. + * + * @param ids + * The IDs of the notifications + */ +- (void) getAll:(CDVInvokedUrlCommand*)command +{ + [self getOptions:command byType:NotifcationTypeAll]; +} + +/** + * Property list for given scheduled notifications. + * + * @param ids + * The IDs of the notifications + */ +- (void) getScheduled:(CDVInvokedUrlCommand*)command +{ + [self getOptions:command byType:NotifcationTypeScheduled]; +} + +/** + * Property list for given triggered notifications. + * + * @param ids + * The IDs of the notifications + */ +- (void) getTriggered:(CDVInvokedUrlCommand *)command +{ + [self getOptions:command byType:NotifcationTypeTriggered]; +} + +/** + * Propertys for given triggered notification. + * + * @param type + * Notification life cycle type + * @param ids + * The ID of the notification + */ +- (void) getOption:(CDVInvokedUrlCommand*)command + byType:(APPLocalNotificationType)type; +{ + [self.commandDelegate runInBackground:^{ + NSArray* ids = command.arguments; + NSArray* notifications; + CDVPluginResult* result; + + if (type == NotifcationTypeAll) { + notifications = [self.app localNotificationOptionsById:ids]; + } + else { + notifications = [self.app localNotificationOptionsByType:type + andId:ids]; + } + + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK + messageAsDictionary:notifications[0]]; + + [self.commandDelegate sendPluginResult:result + callbackId:command.callbackId]; + }]; +} + +/** + * Property list for given triggered notifications. + * + * @param type + * Notification life cycle type + * @param ids + * The IDs of the notifications + */ +- (void) getOptions:(CDVInvokedUrlCommand*)command + byType:(APPLocalNotificationType)type; +{ + [self.commandDelegate runInBackground:^{ + NSArray* ids = command.arguments; + NSArray* notifications; + CDVPluginResult* result; + + if (type == NotifcationTypeAll && ids.count == 0) { + notifications = [self.app localNotificationOptions]; + } + else if (type == NotifcationTypeAll) { + notifications = [self.app localNotificationOptionsById:ids]; + } + else if (ids.count == 0) { + notifications = [self.app localNotificationOptionsByType:type]; + } + else { + notifications = [self.app localNotificationOptionsByType:type + andId:ids]; + } + + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK + messageAsArray:notifications]; + + [self.commandDelegate sendPluginResult:result + callbackId:command.callbackId]; + }]; +} + +/** + * Inform if the app has the permission to show + * badges and local notifications. + */ +- (void) hasPermission:(CDVInvokedUrlCommand*)command +{ + [self.commandDelegate runInBackground:^{ + CDVPluginResult* result; + BOOL hasPermission; + + hasPermission = [self.app hasPermissionToScheduleLocalNotifications]; + + result = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK + messageAsBool:hasPermission]; + + [self.commandDelegate sendPluginResult:result + callbackId:command.callbackId]; + }]; +} + +/** + * Ask for permission to show badges. + */ +- (void) registerPermission:(CDVInvokedUrlCommand*)command +{ + if ([[UIApplication sharedApplication] + respondsToSelector:@selector(registerUserNotificationSettings:)]) + { + _command = command; + + [self.commandDelegate runInBackground:^{ + [self.app registerPermissionToScheduleLocalNotifications]; + }]; + } else { + [self hasPermission:command]; + } +} + +#pragma mark - +#pragma mark Core Logic + +/** + * Schedule the local notification. + */ +- (void) scheduleLocalNotification:(UILocalNotification*)notification +{ + [self cancelForerunnerLocalNotification:notification]; + [self.app scheduleLocalNotification:notification]; +} + +/** + * Update the local notification. + */ +- (void) updateLocalNotification:(UILocalNotification*)notification + withOptions:(NSDictionary*)newOptions +{ + NSMutableDictionary* options = [notification.userInfo mutableCopy]; + + [options addEntriesFromDictionary:newOptions]; + [options setObject:[NSDate date] forKey:@"updatedAt"]; + + notification = [[UILocalNotification alloc] + initWithOptions:options]; + + [self scheduleLocalNotification:notification]; +} + +/** + * Cancel all local notifications. + */ +- (void) cancelAllLocalNotifications +{ + [self.app cancelAllLocalNotifications]; + [self.app setApplicationIconBadgeNumber:0]; +} + +/** + * Clear all local notifications. + */ +- (void) clearAllLocalNotifications +{ + [self.app clearAllLocalNotifications]; + [self.app setApplicationIconBadgeNumber:0]; +} + +/** + * Cancel a maybe given forerunner with the same ID. + */ +- (void) cancelForerunnerLocalNotification:(UILocalNotification*)notification +{ + NSNumber* id = notification.options.id; + UILocalNotification* forerunner; + + forerunner = [self.app localNotificationWithId:id]; + + if (!forerunner) + return; + + [self.app cancelLocalNotification:forerunner]; +} + +/** + * Cancels all non-repeating local notification older then + * a specific amount of seconds + */ +- (void) cancelAllNotificationsWhichAreOlderThen:(float)seconds +{ + NSArray* notifications; + + notifications = [self.app localNotifications]; + + for (UILocalNotification* notification in notifications) + { + if (![notification isRepeating] + && notification.timeIntervalSinceFireDate > seconds) + { + [self.app cancelLocalNotification:notification]; + [self fireEvent:@"cancel" notification:notification]; + } + } +} + +#pragma mark - +#pragma mark Delegates + +/** + * Calls the cancel or trigger event after a local notification was received. + * Cancels the local notification if autoCancel was set to true. + */ +- (void) didReceiveLocalNotification:(NSNotification*)localNotification +{ + UILocalNotification* notification = [localNotification object]; + + if ([notification wasUpdated]) + return; + + NSTimeInterval timeInterval = [notification timeIntervalSinceLastTrigger]; + + NSString* event = (timeInterval <= 1 && deviceready) ? @"trigger" : @"click"; + + [self fireEvent:event notification:notification]; + + if (![event isEqualToString:@"click"]) + return; + + if ([notification isRepeating]) { + [self fireEvent:@"clear" notification:notification]; + } else { + [self.app cancelLocalNotification:notification]; + [self fireEvent:@"cancel" notification:notification]; + } +} + +/** + * Called when app has started + * (by clicking on a local notification). + */ +- (void) didFinishLaunchingWithOptions:(NSNotification*)notification +{ + NSDictionary* launchOptions = [notification userInfo]; + + UILocalNotification* localNotification; + + localNotification = [launchOptions objectForKey: + UIApplicationLaunchOptionsLocalNotificationKey]; + + if (localNotification) { + [self didReceiveLocalNotification: + [NSNotification notificationWithName:CDVLocalNotification + object:localNotification]]; + } +} + +/** + * Called on otification settings registration is completed. + */ +- (void) didRegisterUserNotificationSettings:(UIUserNotificationSettings*)settings +{ + if (_command) + { + [self hasPermission:_command]; + _command = NULL; + } +} + +#pragma mark - +#pragma mark Life Cycle + +/** + * Registers obervers after plugin was initialized. + */ +- (void) pluginInitialize +{ + NSNotificationCenter* center = [NSNotificationCenter + defaultCenter]; + + eventQueue = [[NSMutableArray alloc] init]; + + [center addObserver:self + selector:@selector(didReceiveLocalNotification:) + name:CDVLocalNotification + object:nil]; + + [center addObserver:self + selector:@selector(didFinishLaunchingWithOptions:) + name:UIApplicationDidFinishLaunchingNotification + object:nil]; + + [center addObserver:self + selector:@selector(didRegisterUserNotificationSettings:) + name:UIApplicationRegisterUserNotificationSettings + object:nil]; +} + +/** + * Clears all single repeating notifications which are older then 5 days + * before the app terminates. + */ +- (void) onAppTerminate +{ + [self cancelAllNotificationsWhichAreOlderThen:432000]; +} + +#pragma mark - +#pragma mark Helper + +/** + * Retrieves the application state + * + * @return + * Either "background" or "foreground" + */ +- (NSString*) applicationState +{ + UIApplicationState state = [self.app applicationState]; + + bool isActive = state == UIApplicationStateActive; + + return isActive ? @"foreground" : @"background"; +} + +/** + * Simply invokes the callback without any parameter. + */ +- (void) execCallback:(CDVInvokedUrlCommand*)command +{ + CDVPluginResult *result = [CDVPluginResult + resultWithStatus:CDVCommandStatus_OK]; + + [self.commandDelegate sendPluginResult:result + callbackId:command.callbackId]; +} + +/** + * Short hand for shared application instance. + */ +- (UIApplication*) app +{ + return [UIApplication sharedApplication]; +} + +/** + * Fire general event. + */ +- (void) fireEvent:(NSString*)event +{ + [self fireEvent:event notification:NULL]; +} + +/** + * Fire event for local notification. + */ +- (void) fireEvent:(NSString*)event notification:(UILocalNotification*)notification +{ + NSString* js; + NSString* params = [NSString stringWithFormat: + @"\"%@\"", self.applicationState]; + + if (notification) { + NSString* args = [notification encodeToJSON]; + + params = [NSString stringWithFormat: + @"%@,'%@'", + args, self.applicationState]; + } + + js = [NSString stringWithFormat: + @"cordova.plugins.notification.local.core.fireEvent('%@', %@)", + event, params]; + + if (deviceready) { + [self.commandDelegate evalJs:js]; + } else { + [self.eventQueue addObject:js]; + } +} + +@end diff --git a/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotificationOptions.h b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotificationOptions.h new file mode 100644 index 00000000..73c3ef75 --- /dev/null +++ b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotificationOptions.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2013-2015 by appPlant UG. All rights reserved. + * + * @APPPLANT_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apache License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://opensource.org/licenses/Apache-2.0/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPPLANT_LICENSE_HEADER_END@ + */ + +@interface APPLocalNotificationOptions : NSObject + +- (id) initWithDict:(NSDictionary*)dict; + +@property (readonly, getter=id) NSNumber* id; +@property (readonly, getter=badgeNumber) NSInteger badgeNumber; +@property (readonly, getter=alertBody) NSString* alertBody; +@property (readonly, getter=soundName) NSString* soundName; +@property (readonly, getter=fireDate) NSDate* fireDate; +@property (readonly, getter=repeatInterval) NSCalendarUnit repeatInterval; +@property (readonly, getter=userInfo) NSDictionary* userInfo; + +// If it's a repeating notification +- (BOOL) isRepeating; + +@end diff --git a/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotificationOptions.m b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotificationOptions.m new file mode 100644 index 00000000..ac90f993 --- /dev/null +++ b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/APPLocalNotificationOptions.m @@ -0,0 +1,246 @@ +/* + * Copyright (c) 2013-2015 by appPlant UG. All rights reserved. + * + * @APPPLANT_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apache License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://opensource.org/licenses/Apache-2.0/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPPLANT_LICENSE_HEADER_END@ + */ + +#import "APPLocalNotificationOptions.h" + +// Default sound ressource path +NSString* const DEFAULT_SOUND = @"res://platform_default"; + +@interface APPLocalNotificationOptions () + +// The dictionary which contains all notification properties +@property(nonatomic, retain) NSDictionary* dict; + +@end + +@implementation APPLocalNotificationOptions + +@synthesize dict; + +#pragma mark - +#pragma mark Initialization + +/** + * Initialize the object with the given options when calling on JS side: + * notification.local.add(options) + */ +- (id) initWithDict:(NSDictionary*)dictionary +{ + self = [self init]; + + self.dict = dictionary; + + return self; +} + +#pragma mark - +#pragma mark Attributes + +/** + * The notification's ID. + */ +- (NSNumber*) id +{ + NSInteger id = [[dict objectForKey:@"id"] integerValue]; + + return [NSNumber numberWithInteger:id]; +} + +/** + * The notification's title. + */ +- (NSString*) title +{ + return [dict objectForKey:@"title"]; +} + +/** + * The notification's message. + */ +- (NSString*) text +{ + return [dict objectForKey:@"text"]; +} + +/** + * The notification's badge number. + */ +- (NSInteger) badgeNumber +{ + return [[dict objectForKey:@"badge"] intValue]; +} + +#pragma mark - +#pragma mark Complex Attributes + +/** + * The notification's alert body. + */ +- (NSString*) alertBody +{ + NSString* title = [self title]; + NSString* msg = [self text]; + + NSString* alertBody = msg; + + if (![self stringIsNullOrEmpty:title]) + { + alertBody = [NSString stringWithFormat:@"%@\n%@", + title, msg]; + } + + return alertBody; +} + +/** + * The notification's sound path. + */ +- (NSString*) soundName +{ + NSString* path = [dict objectForKey:@"sound"]; + + if ([self stringIsNullOrEmpty:path]) + return NULL; + + if ([path isEqualToString:DEFAULT_SOUND]) + return UILocalNotificationDefaultSoundName; + + if ([path hasPrefix:@"file:/"]) + return [self soundNameForAsset:path]; + + if ([path hasPrefix:@"res:"]) + return [self soundNameForResource:path]; + + return NULL; +} + +/** + * The notification's fire date. + */ +- (NSDate*) fireDate +{ + double timestamp = [[dict objectForKey:@"at"] + doubleValue]; + + return [NSDate dateWithTimeIntervalSince1970:timestamp]; +} + +/** + * The notification's repeat interval. + */ +- (NSCalendarUnit) repeatInterval +{ + NSString* interval = [dict objectForKey:@"every"]; + + if ([self stringIsNullOrEmpty:interval]) { + return NSCalendarUnitEra; + } + else if ([interval isEqualToString:@"second"]) { + return NSCalendarUnitSecond; + } + else if ([interval isEqualToString:@"minute"]) { + return NSCalendarUnitMinute; + } + else if ([interval isEqualToString:@"hour"]) { + return NSCalendarUnitHour; + } + else if ([interval isEqualToString:@"day"]) { + return NSCalendarUnitDay; + } + else if ([interval isEqualToString:@"week"]) { + return NSCalendarUnitWeekOfYear; + } + else if ([interval isEqualToString:@"month"]) { + return NSCalendarUnitMonth; + } + else if ([interval isEqualToString:@"year"]) { + return NSCalendarUnitYear; + } + + return NSCalendarUnitEra; +} + +#pragma mark - +#pragma mark Methods + +/** + * The notification's user info dict. + */ +- (NSDictionary*) userInfo +{ + if ([dict objectForKey:@"updatedAt"]) { + NSMutableDictionary* data = [dict mutableCopy]; + + [data removeObjectForKey:@"updatedAt"]; + + return data; + } + + return dict; +} + +/** + * If it's a repeating notification. + */ +- (BOOL) isRepeating +{ + NSCalendarUnit interval = self.repeatInterval; + + return !(interval == NSCalendarUnitEra || interval == 0); +} + +#pragma mark - +#pragma mark Helpers + +/** + * Convert relative path to valid sound name attribute. + */ +- (NSString*) soundNameForAsset:(NSString*)path +{ + return [path stringByReplacingOccurrencesOfString:@"file:/" + withString:@"www"]; +} + +/** + * Convert resource path to valid sound name attribute. + */ +- (NSString*) soundNameForResource:(NSString*)path +{ + return [path pathComponents].lastObject; +} + +/** + * If the string is empty. + */ +- (BOOL) stringIsNullOrEmpty:(NSString*)str +{ + if (str == (NSString*)[NSNull null]) + return YES; + + if ([str isEqualToString:@""]) + return YES; + + return NO; +} + +@end diff --git a/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UIApplication+APPLocalNotification.h b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UIApplication+APPLocalNotification.h new file mode 100644 index 00000000..a18568e5 --- /dev/null +++ b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UIApplication+APPLocalNotification.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2013-2015 by appPlant UG. All rights reserved. + * + * @APPPLANT_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apache License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://opensource.org/licenses/Apache-2.0/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPPLANT_LICENSE_HEADER_END@ + */ + +#import "UILocalNotification+APPLocalNotification.h" + +@interface UIApplication (APPLocalNotification) + +@property (readonly, getter=localNotifications) NSArray* localNotifications; +@property (readonly, getter=localNotificationIds) NSArray* localNotificationIds; + +// If the app has the permission to schedule local notifications +- (BOOL) hasPermissionToScheduleLocalNotifications; +// Ask for permission to schedule local notifications +- (void) registerPermissionToScheduleLocalNotifications; + +// List of all local notification IDs from given type +- (NSArray*) localNotificationIdsByType:(APPLocalNotificationType)type; + +// If local notification with ID exists +- (BOOL) localNotificationExist:(NSNumber*)id; +// If local notification with ID and type exists +- (BOOL) localNotificationExist:(NSNumber*)id type:(APPLocalNotificationType)type; + +// Local notification by ID +- (UILocalNotification*) localNotificationWithId:(NSNumber*)id; +// Local notification by ID and type +- (UILocalNotification*) localNotificationWithId:(NSNumber*)id andType:(APPLocalNotificationType)type; + +// Property list from all local notifications +- (NSArray*) localNotificationOptions; +// Property list from given local notifications +- (NSArray*) localNotificationOptionsById:(NSArray*)ids; +// Property list from all local notifications with type constraint +- (NSArray*) localNotificationOptionsByType:(APPLocalNotificationType)type; +// Property list from given local notifications with type constraint +- (NSArray*) localNotificationOptionsByType:(APPLocalNotificationType)type andId:(NSArray*)ids; + +// Clear single local notfications +- (void) clearLocalNotification:(UILocalNotification*)notification; +// Clear all local notfications +- (void) clearAllLocalNotifications; + +@end diff --git a/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UIApplication+APPLocalNotification.m b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UIApplication+APPLocalNotification.m new file mode 100644 index 00000000..60b6daac --- /dev/null +++ b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UIApplication+APPLocalNotification.m @@ -0,0 +1,331 @@ +/* + * Copyright (c) 2013-2015 by appPlant UG. All rights reserved. + * + * @APPPLANT_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apache License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://opensource.org/licenses/Apache-2.0/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPPLANT_LICENSE_HEADER_END@ + */ + +#import "UIApplication+APPLocalNotification.h" +#import "UILocalNotification+APPLocalNotification.h" + +@implementation UIApplication (APPLocalNotification) + +#pragma mark - +#pragma mark Permissions + +/** + * If the app has the permission to schedule local notifications. + */ +- (BOOL) hasPermissionToScheduleLocalNotifications +{ + if ([[UIApplication sharedApplication] + respondsToSelector:@selector(registerUserNotificationSettings:)]) + { + UIUserNotificationType types; + UIUserNotificationSettings *settings; + + settings = [[UIApplication sharedApplication] + currentUserNotificationSettings]; + + types = UIUserNotificationTypeAlert|UIUserNotificationTypeBadge|UIUserNotificationTypeSound; + + return (settings.types & types); + } else { + return YES; + } +} + +/** + * Ask for permission to schedule local notifications. + */ +- (void) registerPermissionToScheduleLocalNotifications +{ + if ([[UIApplication sharedApplication] + respondsToSelector:@selector(registerUserNotificationSettings:)]) + { + UIUserNotificationType types; + UIUserNotificationSettings *settings; + + settings = [[UIApplication sharedApplication] + currentUserNotificationSettings]; + + types = settings.types|UIUserNotificationTypeAlert|UIUserNotificationTypeBadge|UIUserNotificationTypeSound; + + settings = [UIUserNotificationSettings settingsForTypes:types + categories:nil]; + + [[UIApplication sharedApplication] + registerUserNotificationSettings:settings]; + } +} + +#pragma mark - +#pragma mark LocalNotifications + +/** + * List of all local notifications which have been added + * but not yet removed from the notification center. + */ +- (NSArray*) localNotifications +{ + NSArray* scheduledNotifications = self.scheduledLocalNotifications; + NSMutableArray* notifications = [[NSMutableArray alloc] init]; + + for (UILocalNotification* notification in scheduledNotifications) + { + if (notification) { + [notifications addObject:notification]; + } + } + + return notifications; +} + +/** + * List of all triggered local notifications which have been scheduled + * and not yet removed the notification center. + */ +- (NSArray*) triggeredLocalNotifications +{ + NSArray* notifications = self.localNotifications; + NSMutableArray* triggeredNotifications = [[NSMutableArray alloc] init]; + + for (UILocalNotification* notification in notifications) + { + if ([notification isTriggered]) { + [triggeredNotifications addObject:notification]; + } + } + + return triggeredNotifications; +} + +/** + * List of all local notifications IDs. + */ +- (NSArray*) localNotificationIds +{ + NSArray* notifications = self.localNotifications; + NSMutableArray* ids = [[NSMutableArray alloc] init]; + + for (UILocalNotification* notification in notifications) + { + [ids addObject:notification.options.id]; + } + + return ids; +} + +/** + * List of all local notifications IDs from given type. + * + * @param type + * Notification life cycle type + */ +- (NSArray*) localNotificationIdsByType:(APPLocalNotificationType)type +{ + NSArray* notifications = self.localNotifications; + NSMutableArray* ids = [[NSMutableArray alloc] init]; + + for (UILocalNotification* notification in notifications) + { + if (notification.type == type) { + [ids addObject:notification.options.id]; + } + } + + return ids; +} + +/* + * If local notification with ID exists. + * + * @param id + * Notification ID + */ +- (BOOL) localNotificationExist:(NSNumber*)id +{ + return [self localNotificationWithId:id] != NULL; +} + +/* If local notification with ID and type exists + * + * @param id + * Notification ID + * @param type + * Notification life cycle type + */ +- (BOOL) localNotificationExist:(NSNumber*)id type:(APPLocalNotificationType)type +{ + return [self localNotificationWithId:id andType:type] != NULL; +} + +/** + * Get local notification with ID. + * + * @param id + * Notification ID + */ +- (UILocalNotification*) localNotificationWithId:(NSNumber*)id +{ + NSArray* notifications = self.localNotifications; + + for (UILocalNotification* notification in notifications) + { + if ([notification.options.id isEqualToNumber:id]) { + return notification; + } + } + + return NULL; +} + +/* + * Get local notification with ID and type. + * + * @param id + * Notification ID + * @param type + * Notification life cycle type + */ +- (UILocalNotification*) localNotificationWithId:(NSNumber*)id andType:(APPLocalNotificationType)type +{ + UILocalNotification* notification = [self localNotificationWithId:id]; + + if (notification && notification.type == type) + return notification; + + return NULL; +} + +/** + * List of properties from all notifications. + */ +- (NSArray*) localNotificationOptions +{ + NSArray* notifications = self.localNotifications; + NSMutableArray* options = [[NSMutableArray alloc] init]; + + for (UILocalNotification* notification in notifications) + { + [options addObject:notification.options.userInfo]; + } + + return options; +} + +/** + * List of properties from all local notifications from given type. + * + * @param type + * Notification life cycle type + */ +- (NSArray*) localNotificationOptionsByType:(APPLocalNotificationType)type +{ + NSArray* notifications = self.localNotifications; + NSMutableArray* options = [[NSMutableArray alloc] init]; + + for (UILocalNotification* notification in notifications) + { + if (notification.type == type) { + [options addObject:notification.options.userInfo]; + } + } + + return options; +} + +/** + * List of properties from given local notifications. + * + * @param ids + * Notification IDs + */ +- (NSArray*) localNotificationOptionsById:(NSArray*)ids +{ + UILocalNotification* notification; + NSMutableArray* options = [[NSMutableArray alloc] init]; + + for (NSNumber* id in ids) + { + notification = [self localNotificationWithId:id]; + + if (notification) { + [options addObject:notification.options.userInfo]; + } + } + + return options; +} + +/** + * List of properties from given local notifications. + * + * @param type + * Notification life cycle type + * @param ids + * Notification IDs + */ +- (NSArray*) localNotificationOptionsByType:(APPLocalNotificationType)type andId:(NSArray*)ids +{ + UILocalNotification* notification; + NSMutableArray* options = [[NSMutableArray alloc] init]; + + for (NSNumber* id in ids) + { + notification = [self localNotificationWithId:id]; + + if (notification && notification.type == type) { + [options addObject:notification.options.userInfo]; + } + } + + return options; +} + +/* + * Clear all local notfications. + */ +- (void) clearAllLocalNotifications +{ + NSArray* notifications = self.triggeredLocalNotifications; + + for (UILocalNotification* notification in notifications) { + [self clearLocalNotification:notification]; + } +} + +/* + * Clear single local notfication. + * + * @param notification + * The local notification object + */ +- (void) clearLocalNotification:(UILocalNotification*)notification +{ + [self cancelLocalNotification:notification]; + + if ([notification isRepeating]) { + notification.fireDate = notification.options.fireDate; + + [self scheduleLocalNotification:notification]; + }; +} + +@end diff --git a/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UILocalNotification+APPLocalNotification.h b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UILocalNotification+APPLocalNotification.h new file mode 100644 index 00000000..ac0fdc20 --- /dev/null +++ b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UILocalNotification+APPLocalNotification.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2013-2015 by appPlant UG. All rights reserved. + * + * @APPPLANT_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apache License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://opensource.org/licenses/Apache-2.0/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPPLANT_LICENSE_HEADER_END@ + */ + +#import "APPLocalNotificationOptions.h" + +typedef NS_ENUM(NSUInteger, APPLocalNotificationType) { + NotifcationTypeAll = 0, + NotifcationTypeScheduled = 1, + NotifcationTypeTriggered = 2 +}; + +@interface UILocalNotification (APPLocalNotification) + +// Initialize a new local notification +- (id) initWithOptions:(NSDictionary*)dict; +// The options provided by the plug-in +- (APPLocalNotificationOptions*) options; +// Timeinterval since last trigger date +- (double) timeIntervalSinceLastTrigger; +// Timeinterval since fire date +- (double) timeIntervalSinceFireDate; +// If the fire date was in the past +- (BOOL) wasInThePast; +// If the notification was already scheduled +- (BOOL) isScheduled; +// If the notification was already triggered +- (BOOL) isTriggered; +// If the notification was updated +- (BOOL) wasUpdated; +// If it's a repeating notification +- (BOOL) isRepeating; +// Notifciation type +- (APPLocalNotificationType) type; +// Encode the user info dict to JSON +- (NSString*) encodeToJSON; + +@end diff --git a/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UILocalNotification+APPLocalNotification.m b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UILocalNotification+APPLocalNotification.m new file mode 100644 index 00000000..d225cf52 --- /dev/null +++ b/plugins/de.appplant.cordova.plugin.local-notification/src/ios/UILocalNotification+APPLocalNotification.m @@ -0,0 +1,244 @@ +/* + * Copyright (c) 2013-2015 by appPlant UG. All rights reserved. + * + * @APPPLANT_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apache License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. Please obtain a copy of the License at + * http://opensource.org/licenses/Apache-2.0/ and read it before using this + * file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPPLANT_LICENSE_HEADER_END@ + */ + +#import "UILocalNotification+APPLocalNotification.h" +#import "APPLocalNotificationOptions.h" +#import <objc/runtime.h> + +static char optionsKey; + +NSInteger const APPLocalNotificationTypeScheduled = 1; +NSInteger const APPLocalNotificationTypeTriggered = 2; + +@implementation UILocalNotification (APPLocalNotification) + +#pragma mark - +#pragma mark Init + +/** + * Initialize a local notification with the given options when calling on JS side: + * notification.local.add(options) + */ +- (id) initWithOptions:(NSDictionary*)dict +{ + self = [self init]; + + [self setUserInfo:dict]; + [self __init]; + + return self; +} + +/** + * Applies the given options when calling on JS side: + * notification.local.add(options) + + */ +- (void) __init +{ + APPLocalNotificationOptions* options = self.options; + + self.fireDate = options.fireDate; + self.timeZone = [NSTimeZone defaultTimeZone]; + self.applicationIconBadgeNumber = options.badgeNumber; + self.repeatInterval = options.repeatInterval; + self.alertBody = options.alertBody; + self.soundName = options.soundName; + + if ([self wasInThePast]) { + self.fireDate = [NSDate date]; + } +} + +#pragma mark - +#pragma mark Methods + +/** + * The options provided by the plug-in. + */ +- (APPLocalNotificationOptions*) options +{ + APPLocalNotificationOptions* options = [self getOptions]; + + if (!options) { + options = [[APPLocalNotificationOptions alloc] + initWithDict:[self userInfo]]; + + [self setOptions:options]; + } + + return options; +} + +/** + * Get associated option object + */ +- (APPLocalNotificationOptions*) getOptions +{ + return objc_getAssociatedObject(self, &optionsKey); +} + +/** + * Set associated option object + */ +- (void) setOptions:(APPLocalNotificationOptions*)options +{ + objc_setAssociatedObject(self, &optionsKey, + options, OBJC_ASSOCIATION_RETAIN_NONATOMIC); +} + +/** + * The repeating interval in seconds. + */ +- (int) repeatIntervalInSeconds +{ + switch (self.repeatInterval) { + case NSCalendarUnitMinute: + return 60; + + case NSCalendarUnitHour: + return 60000; + + case NSCalendarUnitDay: + case NSCalendarUnitWeekOfYear: + case NSCalendarUnitMonth: + case NSCalendarUnitYear: + return 86400; + + default: + return 1; + } +} + +/** + * Timeinterval since fire date. + */ +- (double) timeIntervalSinceFireDate +{ + NSDate* now = [NSDate date]; + NSDate* fireDate = self.fireDate; + + int timespan = [now timeIntervalSinceDate:fireDate]; + + return timespan; +} + +/** + * Timeinterval since last trigger date. + */ +- (double) timeIntervalSinceLastTrigger +{ + int timespan = [self timeIntervalSinceFireDate]; + + if ([self isRepeating]) { + timespan = timespan % [self repeatIntervalInSeconds]; + } + + return timespan; +} + +/** + * Encode the user info dict to JSON. + */ +- (NSString*) encodeToJSON +{ + NSString* json; + NSData* data; + NSMutableDictionary* obj = [self.userInfo mutableCopy]; + + [obj removeObjectForKey:@"updatedAt"]; + + data = [NSJSONSerialization dataWithJSONObject:obj + options:NSJSONWritingPrettyPrinted + error:Nil]; + + json = [[NSString alloc] initWithData:data + encoding:NSUTF8StringEncoding]; + + return [json stringByReplacingOccurrencesOfString:@"\n" + withString:@""]; +} + +#pragma mark - +#pragma mark State + +/** + * If the fire date was in the past. + */ +- (BOOL) wasInThePast +{ + return [self timeIntervalSinceLastTrigger] > 0; +} + +// If the notification was already scheduled +- (BOOL) isScheduled +{ + return [self isRepeating] || ![self wasInThePast]; +} + +/** + * If the notification was already triggered. + */ +- (BOOL) isTriggered +{ + NSDate* now = [NSDate date]; + NSDate* fireDate = self.fireDate; + + bool isLaterThanFireDate = !([now compare:fireDate] == NSOrderedAscending); + + return isLaterThanFireDate; +} + +/** + * If the notification was updated. + */ +- (BOOL) wasUpdated +{ + NSDate* now = [NSDate date]; + NSDate* updatedAt = [self.userInfo objectForKey:@"updatedAt"]; + + if (updatedAt == NULL) + return NO; + + int timespan = [now timeIntervalSinceDate:updatedAt]; + + return timespan < 1; +} + +/** + * If it's a repeating notification. + */ +- (BOOL) isRepeating +{ + return [self.options isRepeating]; +} + +/** + * Process state type of the local notification. + */ +- (APPLocalNotificationType) type +{ + return [self isTriggered] ? NotifcationTypeTriggered : NotifcationTypeScheduled; +} + +@end |