@amazon-devices/expo-notifications 2.0.9000000000-rn-83

package/ios/EXNotifications/Notifications/Handler/EXNotificationsHandlerModule.m

@@ -0,0 +1,109 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXNotificationsHandlerModule.h>
+#import <EXNotifications/EXNotificationSerializer.h>
+#import <EXNotifications/EXNotificationCenterDelegate.h>
+
+#import <ExpoModulesCore/EXEventEmitterService.h>
+
+@interface EXNotificationsHandlerModule ()
+
+@property (nonatomic, weak) id<EXNotificationCenterDelegate> notificationCenterDelegate;
+
+@property (nonatomic, assign) BOOL isListening;
+@property (nonatomic, assign) BOOL isBeingObserved;
+
+@property (nonatomic, weak) id<EXEventEmitterService> eventEmitter;
+
+@property (nonatomic, strong) NSMutableDictionary<NSString *, EXSingleNotificationHandlerTask *> *tasksMap;
+
+@end
+
+@implementation EXNotificationsHandlerModule
+
+EX_EXPORT_MODULE(ExpoNotificationsHandlerModule);
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _tasksMap = [NSMutableDictionary dictionary];
+  }
+  return self;
+}
+
+# pragma mark - Exported methods
+
+EX_EXPORT_METHOD_AS(handleNotificationAsync,
+                    handleNotificationAsync:(NSString *)identifier withBehavior:(NSDictionary *)behavior resolver:(EXPromiseResolveBlock)resolve rejecter:(EXPromiseRejectBlock)reject)
+{
+  EXSingleNotificationHandlerTask *task = _tasksMap[identifier];
+  if (!task) {
+    NSString *message = [NSString stringWithFormat:@"Failed to handle notification %@, it has already been handled.", identifier];
+    return reject(@"ERR_NOTIFICATION_HANDLED", message, nil);
+  }
+  NSError *error = [task handleResponse:behavior];
+  if (error) {
+    return reject(error.userInfo[@"code"], error.userInfo[@"message"], error);
+  } else {
+    resolve(nil);
+  }
+}
+
+# pragma mark - EXModuleRegistryConsumer
+
+- (void)setModuleRegistry:(EXModuleRegistry *)moduleRegistry
+{
+  _eventEmitter = [moduleRegistry getModuleImplementingProtocol:@protocol(EXEventEmitterService)];
+  _notificationCenterDelegate = [moduleRegistry getSingletonModuleForName:@"NotificationCenterDelegate"];
+}
+
+# pragma mark - EXEventEmitter
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return [EXSingleNotificationHandlerTask eventNames];
+}
+
+- (void)startObserving
+{
+  [self setIsBeingObserved:YES];
+}
+
+- (void)stopObserving
+{
+  [self setIsBeingObserved:NO];
+}
+
+- (void)setIsBeingObserved:(BOOL)isBeingObserved
+{
+  _isBeingObserved = isBeingObserved;
+  BOOL shouldListen = _isBeingObserved;
+  if (shouldListen && !_isListening) {
+    [_notificationCenterDelegate addDelegate:self];
+    _isListening = YES;
+  } else if (!shouldListen && _isListening) {
+    [_notificationCenterDelegate removeDelegate:self];
+    _isListening = NO;
+  }
+}
+
+# pragma mark - EXNotificationsDelegate
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler
+{
+  EXSingleNotificationHandlerTask *task = [[EXSingleNotificationHandlerTask alloc] initWithEventEmitter:_eventEmitter
+                                                                                           notification:notification
+                                                                                      completionHandler:completionHandler
+                                                                                               delegate:self];
+  [_tasksMap setObject:task forKey:task.identifier];
+  [task start];
+}
+
+# pragma mark - EXSingleNotificationHandlerTaskDelegate
+
+- (void)taskDidFinish:(EXSingleNotificationHandlerTask *)task
+{
+  [_tasksMap removeObjectForKey:task.identifier];
+}
+
+@end

package/ios/EXNotifications/Notifications/Handler/EXSingleNotificationHandlerTask.h

@@ -0,0 +1,33 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <ExpoModulesCore/EXEventEmitterService.h>
+#import <UserNotifications/UserNotifications.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class EXSingleNotificationHandlerTask;
+
+@protocol EXSingleNotificationHandlerTaskDelegate
+
+- (void)taskDidFinish:(EXSingleNotificationHandlerTask *)task;
+
+@end
+
+@interface EXSingleNotificationHandlerTask : NSObject
+
++ (NSArray<NSString *> *)eventNames;
+
+- (instancetype)initWithEventEmitter:(id<EXEventEmitterService>)eventEmitter
+                        notification:(UNNotification *)notification
+                   completionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler
+                            delegate:(id<EXSingleNotificationHandlerTaskDelegate>)delegate;
+
+- (NSString *)identifier;
+
+- (void)start;
+- (nullable NSError *)handleResponse:(NSDictionary *)response;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/EXNotifications/Notifications/Handler/EXSingleNotificationHandlerTask.m

@@ -0,0 +1,124 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXSingleNotificationHandlerTask.h>
+#import <EXNotifications/EXNotificationSerializer.h>
+
+static NSString * const onHandleNotification = @"onHandleNotification";
+static NSString * const onHandleNotificationTimeout = @"onHandleNotificationTimeout";
+
+static NSString * const shouldShowAlertKey = @"shouldShowAlert";
+static NSString * const shouldPlaySoundKey = @"shouldPlaySound";
+static NSString * const shouldSetBadgeKey = @"shouldSetBadge";
+
+static NSTimeInterval const secondsToTimeout = 3;
+
+static NSString * const EXNotificationHandlerErrorDomain = @"expo.notifications.handler";
+
+@interface EXSingleNotificationHandlerTask ()
+
+@property (nonatomic, weak) id<EXEventEmitterService> eventEmitter;
+@property (nonatomic, strong) UNNotification *notification;
+@property (nonatomic, copy) void (^completionHandler)(UNNotificationPresentationOptions);
+
+@property (nonatomic, weak) id<EXSingleNotificationHandlerTaskDelegate> delegate;
+
+@property (nonatomic, strong) NSTimer *timer;
+
+@end
+
+@implementation EXSingleNotificationHandlerTask
+
++ (NSArray<NSString *> *)eventNames
+{
+  return @[onHandleNotification, onHandleNotificationTimeout];
+}
+
+- (instancetype)initWithEventEmitter:(id<EXEventEmitterService>)eventEmitter
+                        notification:(UNNotification *)notification
+                   completionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler
+                            delegate:(nonnull id<EXSingleNotificationHandlerTaskDelegate>)delegate
+{
+  if (self = [super init]) {
+    _eventEmitter = eventEmitter;
+    _notification = notification;
+    _completionHandler = completionHandler;
+    _delegate = delegate;
+  }
+  return self;
+}
+
+- (NSString *)identifier
+{
+  return _notification.request.identifier;
+}
+
+- (void)start
+{
+  [_eventEmitter sendEventWithName:onHandleNotification body:@{
+    @"id": _notification.request.identifier,
+    @"notification": [EXNotificationSerializer serializedNotification:_notification]
+  }];
+  _timer = [NSTimer scheduledTimerWithTimeInterval:secondsToTimeout target:self selector:@selector(handleTimeout) userInfo:nil repeats:NO];
+}
+
+- (nullable NSError *)handleResponse:(NSDictionary *)response
+{
+  @synchronized (self) {
+    NSError *maybeError = [self callCompletionHandlerWithOptions:[self presentationOptionsFromResponse:response]];
+    [self finish];
+    return maybeError;
+  }
+}
+
+- (void)handleTimeout
+{
+  @synchronized (self) {
+    [_eventEmitter sendEventWithName:onHandleNotificationTimeout body:@{
+      @"id": _notification.request.identifier,
+      @"notification": [EXNotificationSerializer serializedNotification:_notification]
+    }];
+    [self callCompletionHandlerWithOptions:UNNotificationPresentationOptionNone];
+    [self finish];
+  }
+}
+
+- (nullable NSError *)callCompletionHandlerWithOptions:(UNNotificationPresentationOptions)options
+{
+  if (_completionHandler) {
+    _completionHandler(options);
+    _completionHandler = nil;
+    return nil;
+  } else {
+    return [NSError errorWithDomain:EXNotificationHandlerErrorDomain code:-1 userInfo:@{
+      @"code": @"ERR_NOTIFICATION_RESPONSE_TIMEOUT",
+      @"message": @"Notification has already been handled. Most probably the request has timed out."
+    }];
+  }
+}
+
+- (void)finish
+{
+  [_timer invalidate];
+  _timer = nil;
+  [_delegate taskDidFinish:self];
+}
+
+- (UNNotificationPresentationOptions)presentationOptionsFromResponse:(NSDictionary *)response
+{
+  UNNotificationPresentationOptions options = UNNotificationPresentationOptionNone;
+
+  // TODO(iOS 14): use UNNotificationPresentationOptionList and UNNotificationPresentationOptionBanner
+  if ([response[shouldShowAlertKey] boolValue]) {
+    options |= UNNotificationPresentationOptionAlert;
+  }
+  if ([response[shouldPlaySoundKey] boolValue]) {
+    options |= UNNotificationPresentationOptionSound;
+  }
+  if ([response[shouldSetBadgeKey] boolValue]) {
+    options |= UNNotificationPresentationOptionBadge;
+  }
+
+  return options;
+}
+
+@end

package/ios/EXNotifications/Notifications/NSDictionary+EXNotificationsVerifyingClass.h

@@ -0,0 +1,7 @@
+#import <Foundation/Foundation.h>
+
+@interface NSDictionary (EXNotificationsVerifyingClass)
+
+- (id)objectForKey:(id)aKey verifyingClass:(__unsafe_unretained Class)klass;
+
+@end

package/ios/EXNotifications/Notifications/NSDictionary+EXNotificationsVerifyingClass.m

@@ -0,0 +1,19 @@
+#import <EXNotifications/NSDictionary+EXNotificationsVerifyingClass.h>
+
+static NSString * const invalidValueExceptionName = @"Value of invalid class encountered";
+static NSString * const invalidValueClassReasonFormat = @"Value under key `%@` is of class %@, while %@ was expected.";
+
+@implementation NSDictionary (EXNotificationsVerifyingClass)
+
+- (id)objectForKey:(id)aKey verifyingClass:(__unsafe_unretained Class)klass
+{
+  id obj = [self objectForKey:aKey];
+  if (!obj || [obj isKindOfClass:klass]) {
+    return obj;
+  }
+
+  NSString *reason = [NSString stringWithFormat:invalidValueClassReasonFormat, aKey, NSStringFromClass([obj class]), NSStringFromClass(klass)];
+  @throw [NSException exceptionWithName:invalidValueExceptionName reason:reason userInfo:nil];
+}
+
+@end

package/ios/EXNotifications/Notifications/Presenting/EXNotificationPresentationModule.h

@@ -0,0 +1,13 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXExportedModule.h>
+#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
+#import <EXNotifications/EXNotificationsDelegate.h>
+
+@interface EXNotificationPresentationModule : EXExportedModule <EXModuleRegistryConsumer, EXNotificationsDelegate>
+
+- (NSArray * _Nonnull)serializeNotifications:(NSArray<UNNotification *> * _Nonnull)notifications;
+
+- (void)dismissNotificationWithIdentifier:(NSString *)identifier resolve:(EXPromiseResolveBlock)resolve reject:(EXPromiseRejectBlock)reject;
+
+@end

package/ios/EXNotifications/Notifications/Presenting/EXNotificationPresentationModule.m

@@ -0,0 +1,124 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXNotificationPresentationModule.h>
+
+#import <EXNotifications/EXNotificationBuilder.h>
+#import <EXNotifications/EXNotificationSerializer.h>
+#import <EXNotifications/EXNotificationCenterDelegate.h>
+
+@interface EXNotificationPresentationModule ()
+
+@property (nonatomic, weak) id<EXNotificationBuilder> notificationBuilder;
+
+// Remove once presentNotificationAsync is removed
+@property (nonatomic, strong) NSCountedSet<NSString *> *presentedNotifications;
+@property (nonatomic, weak) id<EXNotificationCenterDelegate> notificationCenterDelegate;
+
+@end
+
+@implementation EXNotificationPresentationModule
+
+EX_EXPORT_MODULE(ExpoNotificationPresenter);
+
+// Remove once presentNotificationAsync is removed
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _presentedNotifications = [NSCountedSet set];
+  }
+  return self;
+}
+
+# pragma mark - Exported methods
+
+// Remove once presentNotificationAsync is removed
+EX_EXPORT_METHOD_AS(presentNotificationAsync,
+                    presentNotificationWithIdentifier:(NSString *)identifier
+                    notification:(NSDictionary *)notificationSpec
+                    resolve:(EXPromiseResolveBlock)resolve
+                    reject:(EXPromiseRejectBlock)reject)
+{
+  UNNotificationContent *content = [_notificationBuilder notificationContentFromRequest:notificationSpec];
+  UNNotificationTrigger *trigger = nil;
+  UNNotificationRequest *request = [UNNotificationRequest requestWithIdentifier:identifier content:content trigger:trigger];
+  [_presentedNotifications addObject:identifier];
+  __weak EXNotificationPresentationModule *weakSelf = self;
+  [[UNUserNotificationCenter currentNotificationCenter] addNotificationRequest:request withCompletionHandler:^(NSError * _Nullable error) {
+    if (error) {
+      // If there was no error, willPresentNotification: callback will remove the identifier from the set
+      [weakSelf.presentedNotifications removeObject:identifier];
+      NSString *message = [NSString stringWithFormat:@"Notification could not have been presented: %@", error.description];
+      reject(@"ERR_NOTIF_PRESENT", message, error);
+    } else {
+      resolve(identifier);
+    }
+  }];
+}
+
+EX_EXPORT_METHOD_AS(getPresentedNotificationsAsync,
+                    getPresentedNotificationsAsyncWithResolve:(EXPromiseResolveBlock)resolve
+                    reject:(EXPromiseRejectBlock)reject)
+{
+  [[UNUserNotificationCenter currentNotificationCenter] getDeliveredNotificationsWithCompletionHandler:^(NSArray<UNNotification *> * _Nonnull notifications) {
+    resolve([self serializeNotifications:notifications]);
+  }];
+}
+
+
+EX_EXPORT_METHOD_AS(dismissNotificationAsync,
+                    dismissNotificationWithIdentifier:(NSString *)identifier
+                    resolve:(EXPromiseResolveBlock)resolve
+                    reject:(EXPromiseRejectBlock)reject)
+{
+  [[UNUserNotificationCenter currentNotificationCenter] removeDeliveredNotificationsWithIdentifiers:@[identifier]];
+  resolve(nil);
+}
+
+EX_EXPORT_METHOD_AS(dismissAllNotificationsAsync,
+                    dismissAllNotificationsWithResolver:(EXPromiseResolveBlock)resolve
+                    reject:(EXPromiseRejectBlock)reject)
+{
+  [[UNUserNotificationCenter currentNotificationCenter] removeAllDeliveredNotifications];
+  resolve(nil);
+}
+
+# pragma mark - EXModuleRegistryConsumer
+
+- (void)setModuleRegistry:(EXModuleRegistry *)moduleRegistry
+{
+  _notificationBuilder = [moduleRegistry getModuleImplementingProtocol:@protocol(EXNotificationBuilder)];
+
+  // Remove once presentNotificationAsync is removed
+  id<EXNotificationCenterDelegate> notificationCenterDelegate = (id<EXNotificationCenterDelegate>)[moduleRegistry getSingletonModuleForName:@"NotificationCenterDelegate"];
+  [notificationCenterDelegate addDelegate:self];
+}
+
+// Remove once presentNotificationAsync is removed
+# pragma mark - EXNotificationsDelegate
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler
+{
+  UNNotificationPresentationOptions presentationOptions = UNNotificationPresentationOptionNone;
+
+  NSString *identifier = notification.request.identifier;
+  if ([_presentedNotifications containsObject:identifier]) {
+    [_presentedNotifications removeObject:identifier];
+    // TODO(iOS 14): use UNNotificationPresentationOptionList and UNNotificationPresentationOptionBanner
+    presentationOptions = UNNotificationPresentationOptionSound | UNNotificationPresentationOptionAlert | UNNotificationPresentationOptionBadge;
+  }
+
+  completionHandler(presentationOptions);
+}
+
+# pragma mark - Helpers
+
+- (NSArray * _Nonnull)serializeNotifications:(NSArray<UNNotification *> * _Nonnull)notifications
+{
+  NSMutableArray *serializedNotifications = [NSMutableArray new];
+  for (UNNotification *notification in notifications) {
+    [serializedNotifications addObject:[EXNotificationSerializer serializedNotification:notification]];
+  }
+  return serializedNotifications;
+}
+
+@end

package/ios/EXNotifications/Notifications/Scheduling/EXNotificationSchedulerModule.h

@@ -0,0 +1,21 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXExportedModule.h>
+#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
+#import <UserNotifications/UserNotifications.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface EXNotificationSchedulerModule : EXExportedModule <EXModuleRegistryConsumer>
+
+- (NSArray * _Nonnull)serializeNotificationRequests:(NSArray<UNNotificationRequest *> * _Nonnull) requests;
+
+- (void)cancelNotification:(NSString *)identifier resolve:(EXPromiseResolveBlock)resolve rejecting:(EXPromiseRejectBlock)reject;
+
+- (void)cancelAllNotificationsWithResolver:(EXPromiseResolveBlock)resolve rejecting:(EXPromiseRejectBlock)reject;
+
+- (UNNotificationRequest *)buildNotificationRequestWithIdentifier:(NSString *)identifier content:(NSDictionary *)contentInput trigger:(NSDictionary *)triggerInput;
+
+@end
+
+NS_ASSUME_NONNULL_END