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

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

@@ -0,0 +1,263 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXNotificationSchedulerModule.h>
+#import <EXNotifications/EXNotificationSerializer.h>
+#import <EXNotifications/EXNotificationBuilder.h>
+#import <EXNotifications/NSDictionary+EXNotificationsVerifyingClass.h>
+
+#import <UserNotifications/UserNotifications.h>
+
+static NSString * const notificationTriggerTypeKey = @"type";
+static NSString * const notificationTriggerRepeatsKey = @"repeats";
+
+static NSString * const intervalNotificationTriggerType = @"timeInterval";
+static NSString * const intervalNotificationTriggerIntervalKey = @"seconds";
+
+static NSString * const dailyNotificationTriggerType = @"daily";
+static NSString * const dailyNotificationTriggerHourKey = @"hour";
+static NSString * const dailyNotificationTriggerMinuteKey = @"minute";
+
+static NSString * const weeklyNotificationTriggerType = @"weekly";
+static NSString * const weeklyNotificationTriggerWeekdayKey = @"weekday";
+static NSString * const weeklyNotificationTriggerHourKey = @"hour";
+static NSString * const weeklyNotificationTriggerMinuteKey = @"minute";
+
+static NSString * const yearlyNotificationTriggerType = @"yearly";
+static NSString * const yearlyNotificationTriggerDayKey = @"day";
+static NSString * const yearlyNotificationTriggerMonthKey = @"month";
+static NSString * const yearlyNotificationTriggerHourKey = @"hour";
+static NSString * const yearlyNotificationTriggerMinuteKey = @"minute";
+
+static NSString * const dateNotificationTriggerType = @"date";
+static NSString * const dateNotificationTriggerTimestampKey = @"timestamp";
+
+static NSString * const calendarNotificationTriggerType = @"calendar";
+static NSString * const calendarNotificationTriggerComponentsKey = @"value";
+static NSString * const calendarNotificationTriggerTimezoneKey = @"timezone";
+
+
+
+@interface EXNotificationSchedulerModule ()
+
+@property (nonatomic, weak) id<EXNotificationBuilder> builder;
+
+@end
+
+@implementation EXNotificationSchedulerModule
+
+EX_EXPORT_MODULE(ExpoNotificationScheduler);
+
+- (void)setModuleRegistry:(EXModuleRegistry *)moduleRegistry
+{
+  _builder = [moduleRegistry getModuleImplementingProtocol:@protocol(EXNotificationBuilder)];
+}
+
+# pragma mark - Exported methods
+
+EX_EXPORT_METHOD_AS(getAllScheduledNotificationsAsync,
+                    getAllScheduledNotifications:(EXPromiseResolveBlock)resolve reject:(EXPromiseRejectBlock)reject
+                    )
+{
+  [[UNUserNotificationCenter currentNotificationCenter] getPendingNotificationRequestsWithCompletionHandler:^(NSArray<UNNotificationRequest *> * _Nonnull requests) {
+    resolve([self serializeNotificationRequests:requests]);
+  }];
+}
+
+EX_EXPORT_METHOD_AS(scheduleNotificationAsync,
+                     scheduleNotification:(NSString *)identifier notificationSpec:(NSDictionary *)notificationSpec triggerSpec:(NSDictionary *)triggerSpec resolve:(EXPromiseResolveBlock)resolve rejecting:(EXPromiseRejectBlock)reject)
+{
+  @try {
+    UNNotificationRequest *request = [self buildNotificationRequestWithIdentifier:identifier content:notificationSpec trigger:triggerSpec];
+    [[UNUserNotificationCenter currentNotificationCenter] addNotificationRequest:request withCompletionHandler:^(NSError * _Nullable error) {
+      if (error) {
+        NSString *message = [NSString stringWithFormat:@"Failed to schedule notification. %@", error];
+        reject(@"ERR_NOTIFICATIONS_FAILED_TO_SCHEDULE", message, error);
+      } else {
+        resolve(identifier);
+      }
+    }];
+  } @catch (NSException *exception) {
+    NSString *message = [NSString stringWithFormat:@"Failed to schedule notification. %@", exception];
+    reject(@"ERR_NOTIFICATIONS_FAILED_TO_SCHEDULE", message, nil);
+  }
+}
+
+EX_EXPORT_METHOD_AS(cancelScheduledNotificationAsync,
+                     cancelNotification:(NSString *)identifier resolve:(EXPromiseResolveBlock)resolve rejecting:(EXPromiseRejectBlock)reject)
+{
+  [[UNUserNotificationCenter currentNotificationCenter] removePendingNotificationRequestsWithIdentifiers:@[identifier]];
+  resolve(nil);
+}
+
+EX_EXPORT_METHOD_AS(cancelAllScheduledNotificationsAsync,
+                     cancelAllNotificationsWithResolver:(EXPromiseResolveBlock)resolve rejecting:(EXPromiseRejectBlock)reject)
+{
+  [[UNUserNotificationCenter currentNotificationCenter] removeAllPendingNotificationRequests];
+  resolve(nil);
+}
+
+EX_EXPORT_METHOD_AS(getNextTriggerDateAsync,
+                    getNextTriggerDate:(NSDictionary *)triggerSpec resolve:(EXPromiseResolveBlock)resolve rejecting:(EXPromiseRejectBlock)reject)
+{
+  @try {
+    UNNotificationTrigger *trigger = [self triggerFromParams:triggerSpec];
+    if ([trigger isKindOfClass:[UNCalendarNotificationTrigger class]]) {
+      UNCalendarNotificationTrigger *calendarTrigger = (UNCalendarNotificationTrigger *)trigger;
+      NSDate *nextTriggerDate = [calendarTrigger nextTriggerDate];
+      // We want to return milliseconds from this method.
+      resolve(nextTriggerDate ? @([nextTriggerDate timeIntervalSince1970] * 1000) : [NSNull null]);
+    } else if ([trigger isKindOfClass:[UNTimeIntervalNotificationTrigger class]]) {
+      UNTimeIntervalNotificationTrigger *timeIntervalTrigger = (UNTimeIntervalNotificationTrigger *)trigger;
+      NSDate *nextTriggerDate = [timeIntervalTrigger nextTriggerDate];
+      // We want to return milliseconds from this method.
+      resolve(nextTriggerDate ? @([nextTriggerDate timeIntervalSince1970] * 1000) : [NSNull null]);
+    } else {
+      NSString *message = [NSString stringWithFormat:@"It is not possible to get next trigger date for triggers other than calendar-based. Provided trigger resulted in %@ trigger.", NSStringFromClass([trigger class])];
+      reject(@"ERR_NOTIFICATIONS_INVALID_CALENDAR_TRIGGER", message, nil);
+    }
+  } @catch (NSException *exception) {
+    NSString *message = [NSString stringWithFormat:@"Failed to get next trigger date. %@", exception];
+    reject(@"ERR_NOTIFICATIONS_FAILED_TO_GET_NEXT_TRIGGER_DATE", message, nil);
+  }
+}
+
+- (UNNotificationRequest *)buildNotificationRequestWithIdentifier:(NSString *)identifier
+                                                          content:(NSDictionary *)contentInput
+                                                          trigger:(NSDictionary *)triggerInput
+{
+  UNNotificationContent *content = [_builder notificationContentFromRequest:contentInput];
+  UNNotificationRequest *request = [UNNotificationRequest requestWithIdentifier:identifier content:content trigger:[self triggerFromParams:triggerInput]];
+  return request;
+}
+
+- (NSArray * _Nonnull)serializeNotificationRequests:(NSArray<UNNotificationRequest *> * _Nonnull) requests
+{
+  NSMutableArray *serializedRequests = [NSMutableArray new];
+  for (UNNotificationRequest *request in requests) {
+    [serializedRequests addObject:[EXNotificationSerializer serializedNotificationRequest:request]];
+  }
+  return serializedRequests;
+}
+
+- (UNNotificationTrigger *)triggerFromParams:(NSDictionary *)params
+{
+  if (!params) {
+    // nil trigger is a valid trigger
+    return nil;
+  }
+  if (![params isKindOfClass:[NSDictionary class]]) {
+    NSString *reason = [NSString stringWithFormat:@"Unknown notification trigger declaration passed in, expected a dictionary, received %@.", NSStringFromClass(params.class)];
+    @throw [NSException exceptionWithName:NSInvalidArgumentException reason:reason userInfo:nil];
+  }
+  NSString *triggerType = params[notificationTriggerTypeKey];
+  if ([intervalNotificationTriggerType isEqualToString:triggerType]) {
+    NSNumber *interval = [params objectForKey:intervalNotificationTriggerIntervalKey verifyingClass:[NSNumber class]];
+    NSNumber *repeats = [params objectForKey:notificationTriggerRepeatsKey verifyingClass:[NSNumber class]];
+
+    return [UNTimeIntervalNotificationTrigger triggerWithTimeInterval:[interval unsignedIntegerValue]
+                                                              repeats:[repeats boolValue]];
+  } else if ([dateNotificationTriggerType isEqualToString:triggerType]) {
+    NSNumber *timestampMs = [params objectForKey:dateNotificationTriggerTimestampKey verifyingClass:[NSNumber class]];
+    NSUInteger timestamp = [timestampMs unsignedIntegerValue] / 1000;
+    NSDate *date = [NSDate dateWithTimeIntervalSince1970:timestamp];
+
+    return [UNTimeIntervalNotificationTrigger triggerWithTimeInterval:[date timeIntervalSinceNow]
+                                                              repeats:NO];
+
+  } else if ([dailyNotificationTriggerType isEqualToString:triggerType]) {
+    NSNumber *hour = [params objectForKey:dailyNotificationTriggerHourKey verifyingClass:[NSNumber class]];
+    NSNumber *minute = [params objectForKey:dailyNotificationTriggerMinuteKey verifyingClass:[NSNumber class]];
+    NSDateComponents *dateComponents = [NSDateComponents new];
+    dateComponents.hour = [hour integerValue];
+    dateComponents.minute = [minute integerValue];
+
+    return [UNCalendarNotificationTrigger triggerWithDateMatchingComponents:dateComponents
+                                                                    repeats:YES];
+  } else if ([weeklyNotificationTriggerType isEqualToString:triggerType]) {
+    NSNumber *weekday = [params objectForKey:weeklyNotificationTriggerWeekdayKey verifyingClass:[NSNumber class]];
+    NSNumber *hour = [params objectForKey:weeklyNotificationTriggerHourKey verifyingClass:[NSNumber class]];
+    NSNumber *minute = [params objectForKey:weeklyNotificationTriggerMinuteKey verifyingClass:[NSNumber class]];
+    NSDateComponents *dateComponents = [NSDateComponents new];
+    dateComponents.weekday = [weekday integerValue];
+    dateComponents.hour = [hour integerValue];
+    dateComponents.minute = [minute integerValue];
+
+    return [UNCalendarNotificationTrigger triggerWithDateMatchingComponents:dateComponents
+                                                                    repeats:YES];
+  } else if ([yearlyNotificationTriggerType isEqualToString:triggerType]) {
+    NSNumber *day = [params objectForKey:yearlyNotificationTriggerDayKey verifyingClass:[NSNumber class]];
+    NSNumber *month = [params objectForKey:yearlyNotificationTriggerMonthKey verifyingClass:[NSNumber class]];
+    NSNumber *hour = [params objectForKey:yearlyNotificationTriggerHourKey verifyingClass:[NSNumber class]];
+    NSNumber *minute = [params objectForKey:yearlyNotificationTriggerMinuteKey verifyingClass:[NSNumber class]];
+    NSDateComponents *dateComponents = [NSDateComponents new];
+    dateComponents.day = [day integerValue];
+    dateComponents.month = [month integerValue] + 1; // iOS uses 1-12 based numbers for months
+    dateComponents.hour = [hour integerValue];
+    dateComponents.minute = [minute integerValue];
+
+    return [UNCalendarNotificationTrigger triggerWithDateMatchingComponents:dateComponents
+                                                                    repeats:YES];
+  } else if ([calendarNotificationTriggerType isEqualToString:triggerType]) {
+    NSDateComponents *dateComponents = [self dateComponentsFromParams:params[calendarNotificationTriggerComponentsKey]];
+    NSNumber *repeats = [params objectForKey:notificationTriggerRepeatsKey verifyingClass:[NSNumber class]];
+
+    return [UNCalendarNotificationTrigger triggerWithDateMatchingComponents:dateComponents
+                                                                    repeats:[repeats boolValue]];
+  } else {
+    NSString *reason = [NSString stringWithFormat:@"Unknown notification trigger type: %@.", triggerType];
+    @throw [NSException exceptionWithName:NSInvalidArgumentException reason:reason userInfo:nil];
+  }
+}
+
+- (NSDateComponents *)dateComponentsFromParams:(NSDictionary<NSString *, id> *)params
+{
+  NSDateComponents *dateComponents = [NSDateComponents new];
+
+  // TODO: Verify that DoW matches JS getDay()
+  dateComponents.calendar = [NSCalendar calendarWithIdentifier:NSCalendarIdentifierISO8601];
+
+  if ([params objectForKey:calendarNotificationTriggerTimezoneKey verifyingClass:[NSString class]]) {
+    dateComponents.timeZone = [[NSTimeZone alloc] initWithName:params[calendarNotificationTriggerTimezoneKey]];
+  }
+
+  for (NSString *key in [self automatchedDateComponentsKeys]) {
+    if (params[key]) {
+      NSNumber *value = [params objectForKey:key verifyingClass:[NSNumber class]];
+      [dateComponents setValue:[value unsignedIntegerValue] forComponent:[self calendarUnitFor:key]];
+    }
+  }
+
+  return dateComponents;
+}
+
+- (NSDictionary<NSString *, NSNumber *> *)dateComponentsMatchMap
+{
+  static NSDictionary *map;
+  if (!map) {
+    map = @{
+      @"year": @(NSCalendarUnitYear),
+      @"month": @(NSCalendarUnitMonth),
+      @"day": @(NSCalendarUnitDay),
+      @"hour": @(NSCalendarUnitHour),
+      @"minute": @(NSCalendarUnitMinute),
+      @"second": @(NSCalendarUnitSecond),
+      @"weekday": @(NSCalendarUnitWeekday),
+      @"weekOfMonth": @(NSCalendarUnitWeekOfMonth),
+      @"weekOfYear": @(NSCalendarUnitWeekOfYear),
+      @"weekdayOrdinal": @(NSCalendarUnitWeekdayOrdinal)
+    };
+  }
+  return map;
+}
+
+- (NSArray<NSString *> *)automatchedDateComponentsKeys
+{
+  return [[self dateComponentsMatchMap] allKeys];
+}
+
+- (NSCalendarUnit)calendarUnitFor:(NSString *)key
+{
+  return [[self dateComponentsMatchMap][key] unsignedIntegerValue];
+}
+
+@end

package/ios/EXNotifications/Permissions/EXLegacyRemoteNotificationPermissionRequester.h

@@ -0,0 +1,13 @@
+// Copyright 2016-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXPermissionsInterface.h>
+#import <EXNotifications/EXRemoteNotificationPermissionSingletonModule.h>
+
+// TODO: Remove once we deprecate and remove "notifications" permission type
+@interface EXLegacyRemoteNotificationPermissionRequester : NSObject <EXPermissionsRequester, EXRemoteNotificationPermissionDelegate>
+
+- (instancetype)initWithUserNotificationPermissionRequester:(id<EXPermissionsRequester>)userNotificationPermissionRequester
+                                        permissionPublisher:(id<EXRemoteNotificationPermissionProgressPublisher>)permissionProgressPublisher
+                                            withMethodQueue:(dispatch_queue_t)methodQueue;
+
+@end

package/ios/EXNotifications/Permissions/EXLegacyRemoteNotificationPermissionRequester.m

@@ -0,0 +1,135 @@
+// Copyright 2016-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXLegacyRemoteNotificationPermissionRequester.h>
+#import <ExpoModulesCore/EXUtilities.h>
+
+@interface EXLegacyRemoteNotificationPermissionRequester ()
+
+@property (nonatomic, strong) EXPromiseResolveBlock resolve;
+@property (nonatomic, strong) EXPromiseRejectBlock reject;
+@property (nonatomic, assign) BOOL remoteNotificationsRegistrationIsPending;
+@property (nonatomic, weak) id<EXPermissionsRequester> userNotificationPermissionRequester;
+@property (nonatomic, weak) dispatch_queue_t methodQueue;
+@property (nonatomic, weak) id<EXRemoteNotificationPermissionProgressPublisher> permissionProgressPublisher;
+
+@end
+
+@implementation EXLegacyRemoteNotificationPermissionRequester
+
++ (NSString *)permissionType
+{
+  return @"notifications";
+}
+
+- (instancetype)initWithUserNotificationPermissionRequester:(id<EXPermissionsRequester>)userNotificationPermissionRequester
+                                        permissionPublisher:(id<EXRemoteNotificationPermissionProgressPublisher>)permissionProgressPublisher
+                                            withMethodQueue:(dispatch_queue_t)methodQueue
+{
+  if (self = [super init]) {
+    _remoteNotificationsRegistrationIsPending = NO;
+    _permissionProgressPublisher = permissionProgressPublisher;
+    _userNotificationPermissionRequester = userNotificationPermissionRequester;
+    _methodQueue = methodQueue;
+  }
+  return self;
+}
+
+- (NSDictionary *)getPermissions
+{
+  __block EXPermissionStatus status;
+  [EXUtilities performSynchronouslyOnMainThread:^{
+    status = (UMSharedApplication().isRegisteredForRemoteNotifications) ?
+    EXPermissionStatusGranted :
+    EXPermissionStatusUndetermined;
+  }];
+  NSMutableDictionary *permissions = [[_userNotificationPermissionRequester getPermissions] mutableCopy];
+  
+  [permissions setValuesForKeysWithDictionary:@{
+                                                @"status": @(status),
+
+                                                }];
+  return permissions;
+}
+
+- (void)requestPermissionsWithResolver:(EXPromiseResolveBlock)resolve rejecter:(EXPromiseRejectBlock)reject
+{
+  if (_resolve != nil || _reject != nil) {
+    reject(@"E_AWAIT_PROMISE", @"Another request for the same permission is already being handled.", nil);
+    return;
+  }
+
+  _resolve = resolve;
+  _reject = reject;
+
+  BOOL __block isRegisteredForRemoteNotifications = NO;
+  [EXUtilities performSynchronouslyOnMainThread:^{
+    isRegisteredForRemoteNotifications = UMSharedApplication().isRegisteredForRemoteNotifications;
+  }];
+
+  if (isRegisteredForRemoteNotifications) {
+    // resolve immediately if already registered
+    [self _maybeConsumeResolverWithCurrentPermissions];
+  } else {
+    [_permissionProgressPublisher addDelegate:self];
+     EX_WEAKIFY(self)
+    [_userNotificationPermissionRequester requestPermissionsWithResolver:^(NSDictionary *permission){
+      EX_STRONGIFY(self)
+      EXPermissionStatus localNotificationsStatus = [[permission objectForKey:@"status"] intValue];
+      // We may assume that `EXLocalNotificationRequester`'s permission request will always finish
+      // when the user responds to the dialog or has already responded in the past.
+      // However, `UIApplication.registerForRemoteNotification` results in calling
+      // `application:didRegisterForRemoteNotificationsWithDeviceToken:` or
+      // `application:didFailToRegisterForRemoteNotificationsWithError:` on the application delegate
+      // ONLY when the notifications are enabled in settings (by allowing sound, alerts or app badge).
+      // So, when the local notifications are disabled, the application delegate's callbacks will not be called instantly.
+      if (localNotificationsStatus == EXPermissionStatusDenied) {
+        [self _clearObserver];
+        [self _maybeConsumeResolverWithCurrentPermissions];
+      } else {
+        self.remoteNotificationsRegistrationIsPending = YES;
+        dispatch_async(dispatch_get_main_queue(), ^{
+          [UMSharedApplication() registerForRemoteNotifications];
+        });
+      }
+    } rejecter:^(NSString *code, NSString *message, NSError *error){
+      [self _clearObserver];
+      if (self.reject) {
+        self.reject(code, message, error);
+      }
+    }];
+  }
+}
+
+- (void)dealloc
+{
+  [self _clearObserver];
+}
+
+- (void)handleDidFinishRegisteringForRemoteNotifications
+{
+  [self _clearObserver];
+  EX_WEAKIFY(self)
+  dispatch_async(_methodQueue, ^{
+    EX_STRONGIFY(self)
+    [self _maybeConsumeResolverWithCurrentPermissions];
+  });
+}
+
+- (void)_clearObserver
+{
+  [_permissionProgressPublisher removeDelegate:self];
+  _remoteNotificationsRegistrationIsPending = NO;
+}
+
+- (void)_maybeConsumeResolverWithCurrentPermissions
+{
+  if (!_remoteNotificationsRegistrationIsPending) {
+    if (_resolve) {
+      _resolve([self getPermissions]);
+      _resolve = nil;
+      _reject = nil;
+    }
+  }
+}
+
+@end

package/ios/EXNotifications/Permissions/EXNotificationPermissionsModule.h

@@ -0,0 +1,8 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXExportedModule.h>
+#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
+
+@interface EXNotificationPermissionsModule : EXExportedModule <EXModuleRegistryConsumer>
+
+@end

package/ios/EXNotifications/Permissions/EXNotificationPermissionsModule.m

@@ -0,0 +1,67 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXNotificationPermissionsModule.h>
+
+#import <ExpoModulesCore/EXPermissionsInterface.h>
+#import <ExpoModulesCore/EXPermissionsMethodsDelegate.h>
+
+#import <EXNotifications/EXLegacyRemoteNotificationPermissionRequester.h>
+#import <EXNotifications/EXUserFacingNotificationsPermissionsRequester.h>
+
+@interface EXNotificationPermissionsModule ()
+
+@property (nonatomic, weak) id<EXPermissionsInterface> permissionsManager;
+@property (nonatomic, strong) EXUserFacingNotificationsPermissionsRequester *requester;
+@property (nonatomic, strong) EXLegacyRemoteNotificationPermissionRequester *legacyRemoteNotificationsRequester;
+
+@end
+
+@implementation EXNotificationPermissionsModule
+
+EX_EXPORT_MODULE(ExpoNotificationPermissionsModule);
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _requester = [[EXUserFacingNotificationsPermissionsRequester alloc] initWithMethodQueue:self.methodQueue];
+  }
+  return self;
+}
+
+# pragma mark - Exported methods
+
+EX_EXPORT_METHOD_AS(getPermissionsAsync,
+                    getPermissionsAsync:(EXPromiseResolveBlock)resolve
+                    rejecter:(EXPromiseRejectBlock)reject)
+{
+  [EXPermissionsMethodsDelegate getPermissionWithPermissionsManager:_permissionsManager
+                                                      withRequester:[EXUserFacingNotificationsPermissionsRequester class]
+                                                            resolve:resolve
+                                                             reject:reject];
+}
+
+EX_EXPORT_METHOD_AS(requestPermissionsAsync,
+                    requestPermissionsAsync:(NSDictionary *)requestedPermissions
+                    requester:(EXPromiseResolveBlock)resolve
+                    rejecter:(EXPromiseRejectBlock)reject)
+{
+  [EXUserFacingNotificationsPermissionsRequester setRequestedPermissions:requestedPermissions];
+  [EXPermissionsMethodsDelegate askForPermissionWithPermissionsManager:_permissionsManager
+                                                         withRequester:[EXUserFacingNotificationsPermissionsRequester class]
+                                                               resolve:resolve
+                                                                reject:reject];
+}
+
+# pragma mark - EXModuleRegistryConsumer
+
+- (void)setModuleRegistry:(EXModuleRegistry *)moduleRegistry {
+  _permissionsManager = [moduleRegistry getModuleImplementingProtocol:@protocol(EXPermissionsInterface)];
+  if (!_legacyRemoteNotificationsRequester) {
+    // TODO: Remove once we deprecate and remove "notifications" permission type
+    _legacyRemoteNotificationsRequester = [[EXLegacyRemoteNotificationPermissionRequester alloc] initWithUserNotificationPermissionRequester:_requester permissionPublisher:[moduleRegistry getSingletonModuleForName:@"RemoteNotificationPermissionPublisher"] withMethodQueue:self.methodQueue];
+  }
+  [EXPermissionsMethodsDelegate registerRequesters:@[_requester, _legacyRemoteNotificationsRequester]
+                            withPermissionsManager:_permissionsManager];
+}
+
+@end

package/ios/EXNotifications/Permissions/EXRemoteNotificationPermissionSingletonModule.h

@@ -0,0 +1,29 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <ExpoModulesCore/EXSingletonModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol EXRemoteNotificationPermissionDelegate
+
+- (void)handleDidFinishRegisteringForRemoteNotifications;
+
+@end
+
+@protocol EXRemoteNotificationPermissionProgressPublisher
+
+- (void)addDelegate:(id<EXRemoteNotificationPermissionDelegate>)delegate;
+- (void)removeDelegate:(id<EXRemoteNotificationPermissionDelegate>)delegate;
+
+@end
+
+@interface EXRemoteNotificationPermissionSingletonModule : EXSingletonModule <UIApplicationDelegate, EXRemoteNotificationPermissionProgressPublisher>
+
+- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)token;
+- (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/EXNotifications/Permissions/EXRemoteNotificationPermissionSingletonModule.m

@@ -0,0 +1,68 @@
+
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXRemoteNotificationPermissionSingletonModule.h>
+#import <ExpoModulesCore/EXDefines.h>
+
+@interface EXRemoteNotificationPermissionSingletonModule ()
+
+@property (nonatomic, strong) NSPointerArray *delegates;
+
+@end
+
+@implementation EXRemoteNotificationPermissionSingletonModule
+
+EX_REGISTER_SINGLETON_MODULE(RemoteNotificationPermissionPublisher);
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _delegates = [NSPointerArray weakObjectsPointerArray];
+  }
+  return self;
+}
+
+# pragma mark - UIApplicationDelegate
+
+- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)token
+{
+  // Copying the array in case delegates remove themselves while handling the "did finish" event
+  NSPointerArray *immutableDelegates = [_delegates copy];
+  for (int i = 0; i < immutableDelegates.count; i++) {
+    id pointer = [immutableDelegates pointerAtIndex:i];
+    [pointer handleDidFinishRegisteringForRemoteNotifications];
+  }
+}
+
+- (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error
+{
+  // Copying the array in case delegates remove themselves while handling the "did finish" event
+  NSPointerArray *immutableDelegates = [_delegates copy];
+  for (int i = 0; i < immutableDelegates.count; i++) {
+    id pointer = [_delegates pointerAtIndex:i];
+    [pointer handleDidFinishRegisteringForRemoteNotifications];
+  }
+}
+
+# pragma mark - EXNotificationCenterDelegate
+
+- (void)addDelegate:(id<EXRemoteNotificationPermissionDelegate>)delegate
+{
+  [_delegates addPointer:(__bridge void * _Nullable)(delegate)];
+}
+
+- (void)removeDelegate:(id<EXRemoteNotificationPermissionDelegate>)delegate
+{
+  for (int i = 0; i < _delegates.count; i++) {
+    id pointer = [_delegates pointerAtIndex:i];
+    if (pointer == (__bridge void * _Nullable)(delegate) || !pointer) {
+      [_delegates removePointerAtIndex:i];
+      i--;
+    }
+  }
+  // compact doesn't work, that's why we need the `|| !pointer` above
+  // http://www.openradar.me/15396578
+  [_delegates compact];
+}
+
+@end

package/ios/EXNotifications/Permissions/EXUserFacingNotificationsPermissionsRequester.h

@@ -0,0 +1,15 @@
+// Copyright 2019-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXPermissionsInterface.h>
+
+@interface EXUserFacingNotificationsPermissionsRequester : NSObject <EXPermissionsRequester>
+
+- (instancetype)initWithMethodQueue:(dispatch_queue_t)methodQueue;
+
+- (void)requestPermissions:(NSDictionary *)permissions
+              withResolver:(EXPromiseResolveBlock)resolve
+                  rejecter:(EXPromiseRejectBlock)reject;
+
++ (void)setRequestedPermissions:(NSDictionary *)permissions;
+
+@end