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

package/ios/EXNotifications/Notifications/EXNotificationCenterDelegate.m

@@ -0,0 +1,209 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXNotificationCenterDelegate.h>
+#import <ExpoModulesCore/EXDefines.h>
+#import <EXNotifications/EXNotificationsDelegate.h>
+
+@interface EXNotificationCenterDelegate ()
+
+@property (nonatomic, strong) NSPointerArray *delegates;
+@property (nonatomic, strong) NSMutableArray<UNNotificationResponse *> *pendingNotificationResponses;
+
+@end
+
+@implementation EXNotificationCenterDelegate
+
+EX_REGISTER_SINGLETON_MODULE(NotificationCenterDelegate);
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    _delegates = [NSPointerArray weakObjectsPointerArray];
+    _pendingNotificationResponses = [NSMutableArray array];
+  }
+  return self;
+}
+
+# pragma mark - UIApplicationDelegate
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary<UIApplicationLaunchOptionsKey,id> *)launchOptions
+{
+  if ([UNUserNotificationCenter currentNotificationCenter].delegate) {
+    EXLogWarn(@"[expo-notifications] EXNotificationCenterDelegate encountered already present delegate of UNUserNotificationCenter: %@. "
+              "EXNotificationCenterDelegate will not overwrite the value not to break other features of your app. "
+              "In return, expo-notifications may not work properly. "
+              "To fix this problem either remove setting of the second delegate "
+              "or set the delegate to an instance of EXNotificationCenterDelegate manually afterwards.",
+              [UNUserNotificationCenter currentNotificationCenter].delegate);
+    return YES;
+  }
+
+  [[UNUserNotificationCenter currentNotificationCenter] setDelegate:self];
+  return YES;
+}
+
+- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler
+{
+  __block int delegatesCalled = 0;
+  __block int delegatesCompleted = 0;
+  __block BOOL delegatingCompleted = NO;
+  __block BOOL delegatesFailed = 0;
+  __block UIBackgroundFetchResult resultSum = UIBackgroundFetchResultNoData;
+  __block void (^completionHandlerCaller)(void) = ^{
+    if (delegatingCompleted && delegatesCompleted == delegatesCalled) {
+      if (delegatesCompleted == delegatesFailed) {
+        // If all delegates failed to fetch result, let's let the OS know about that
+        completionHandler(UIBackgroundFetchResultFailed);
+      } else {
+        // If at least one succeeded, let's take it as read and respond with that result.
+        completionHandler(resultSum);
+      }
+    }
+  };
+
+  for (int i = 0; i < _delegates.count; i++) {
+    id pointer = [_delegates pointerAtIndex:i];
+    if ([pointer respondsToSelector:@selector(application:didReceiveRemoteNotification:fetchCompletionHandler:)]) {
+      [pointer application:application didReceiveRemoteNotification:userInfo fetchCompletionHandler:^(UIBackgroundFetchResult result) {
+        @synchronized (self) {
+          if (result == UIBackgroundFetchResultFailed) {
+            delegatesFailed += 1;
+          } else if (result == UIBackgroundFetchResultNewData) {
+            resultSum = UIBackgroundFetchResultNewData;
+          }
+          delegatesCompleted += 1;
+          completionHandlerCaller();
+        }
+      }];
+      @synchronized (self) {
+        delegatesCalled += 1;
+      }
+    }
+  }
+  @synchronized (self) {
+    delegatingCompleted = YES;
+    completionHandlerCaller();
+  }
+}
+
+# pragma mark - UNUserNotificationCenterDelegate
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler
+{
+  __block int delegatesCalled = 0;
+  __block int delegatesCompleted = 0;
+  __block BOOL delegatingCompleted = NO;
+  __block UNNotificationPresentationOptions optionsSum = UNNotificationPresentationOptionNone;
+  __block void (^completionHandlerCaller)(void) = ^{
+    if (delegatingCompleted && delegatesCompleted == delegatesCalled) {
+      completionHandler(optionsSum);
+    }
+  };
+
+  for (int i = 0; i < _delegates.count; i++) {
+    id pointer = [_delegates pointerAtIndex:i];
+    if ([pointer respondsToSelector:@selector(userNotificationCenter:willPresentNotification:withCompletionHandler:)]) {
+      [pointer userNotificationCenter:center willPresentNotification:notification withCompletionHandler:^(UNNotificationPresentationOptions options) {
+        @synchronized (self) {
+          delegatesCompleted += 1;
+          optionsSum = optionsSum | options;
+          completionHandlerCaller();
+        }
+      }];
+      @synchronized (self) {
+        delegatesCalled += 1;
+      }
+    }
+  }
+  @synchronized (self) {
+    delegatingCompleted = YES;
+    completionHandlerCaller();
+  }
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler
+{
+  // Save response to pending responses array if none of the handlers will handle it.
+  BOOL responseWillBeHandledByAppropriateDelegate = NO;
+  for (int i = 0; i < _delegates.count; i++) {
+    id pointer = [_delegates pointerAtIndex:i];
+    if ([pointer respondsToSelector:@selector(userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:)]) {
+      responseWillBeHandledByAppropriateDelegate = YES;
+      break;
+    }
+  }
+  if (!responseWillBeHandledByAppropriateDelegate) {
+    [_pendingNotificationResponses addObject:response];
+  }
+
+  __block int delegatesCalled = 0;
+  __block int delegatesCompleted = 0;
+  __block BOOL delegatingCompleted = NO;
+  void (^completionHandlerCaller)(void) = ^{
+    if (delegatingCompleted && delegatesCompleted == delegatesCalled) {
+      completionHandler();
+    }
+  };
+
+  for (int i = 0; i < _delegates.count; i++) {
+    id pointer = [_delegates pointerAtIndex:i];
+    if ([pointer respondsToSelector:@selector(userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:)]) {
+      [pointer userNotificationCenter:center didReceiveNotificationResponse:response withCompletionHandler:^{
+        @synchronized (self) {
+          delegatesCompleted += 1;
+          completionHandlerCaller();
+        }
+      }];
+      @synchronized (self) {
+        delegatesCalled += 1;
+      }
+    }
+  }
+  @synchronized (self) {
+    delegatingCompleted = YES;
+    completionHandlerCaller();
+  }
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center openSettingsForNotification:(UNNotification *)notification
+{
+  if (@available(iOS 12.0, *)) {
+    for (int i = 0; i < _delegates.count; i++) {
+      id pointer = [_delegates pointerAtIndex:i];
+      if ([pointer respondsToSelector:@selector(userNotificationCenter:openSettingsForNotification:)]) {
+        [pointer userNotificationCenter:center openSettingsForNotification:notification];
+      }
+    }
+  }
+}
+
+# pragma mark - EXNotificationCenterDelegate
+
+- (void)addDelegate:(id<EXNotificationsDelegate>)delegate
+{
+  [_delegates addPointer:(__bridge void * _Nullable)(delegate)];
+  if ([delegate respondsToSelector:@selector(userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:)]) {
+    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+    for (UNNotificationResponse *response in _pendingNotificationResponses) {
+      [delegate userNotificationCenter:center didReceiveNotificationResponse:response withCompletionHandler:^{
+        // completion handler doesn't need to do anything
+      }];
+    }
+  }
+}
+
+- (void)removeDelegate:(id<EXNotificationsDelegate>)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/Notifications/EXNotificationSerializer.h

@@ -0,0 +1,16 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <UserNotifications/UserNotifications.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface EXNotificationSerializer : NSObject
+
++ (NSDictionary *)serializedNotification:(UNNotification *)notification;
++ (NSDictionary *)serializedNotificationRequest:(UNNotificationRequest *)notificationRequest;
++ (NSDictionary *)serializedNotificationResponse:(UNNotificationResponse *)notificationResponse;
++ (NSDictionary *)serializedNotificationContent:(UNNotificationRequest *)request;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/EXNotifications/Notifications/EXNotificationSerializer.m

@@ -0,0 +1,232 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXNotificationSerializer.h>
+#import <CoreLocation/CoreLocation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+static NSString * const EXNotificationResponseDefaultActionIdentifier = @"expo.modules.notifications.actions.DEFAULT";
+
+@implementation EXNotificationSerializer
+
++ (NSDictionary *)serializedNotificationResponse:(UNNotificationResponse *)response
+{
+  NSMutableDictionary *serializedResponse = [NSMutableDictionary dictionary];
+  NSString *actionIdentifier = response.actionIdentifier;
+  if ([UNNotificationDefaultActionIdentifier isEqualToString:actionIdentifier]) {
+    actionIdentifier = EXNotificationResponseDefaultActionIdentifier;
+  }
+  serializedResponse[@"actionIdentifier"] = actionIdentifier;
+  serializedResponse[@"notification"] = [self serializedNotification:response.notification];
+  if ([response isKindOfClass:[UNTextInputNotificationResponse class]]) {
+    UNTextInputNotificationResponse *textInputResponse = (UNTextInputNotificationResponse *)response;
+    serializedResponse[@"userText"] = textInputResponse.userText ?: [NSNull null];
+  }
+  return serializedResponse;
+}
+
++ (NSDictionary *)serializedNotification:(UNNotification *)notification
+{
+  NSMutableDictionary *serializedNotification = [NSMutableDictionary dictionary];
+  serializedNotification[@"request"] = [self serializedNotificationRequest:notification.request];
+  serializedNotification[@"date"] = @(notification.date.timeIntervalSince1970);
+  return serializedNotification;
+}
+
++ (NSDictionary *)serializedNotificationRequest:(UNNotificationRequest *)request
+{
+  NSMutableDictionary *serializedRequest = [NSMutableDictionary dictionary];
+  serializedRequest[@"identifier"] = request.identifier;
+  serializedRequest[@"content"] = [self serializedNotificationContent:request];
+  serializedRequest[@"trigger"] = [self serializedNotificationTrigger:request];
+  return serializedRequest;
+}
+
++ (NSDictionary *)serializedNotificationContent:(UNNotificationRequest *)request
+{
+  UNNotificationContent *content = request.content;
+  NSMutableDictionary *serializedContent = [NSMutableDictionary dictionary];
+  serializedContent[@"title"] = content.title ?: [NSNull null];
+  serializedContent[@"subtitle"] = content.subtitle ?: [NSNull null];
+  serializedContent[@"body"] = content.body ?: [NSNull null];
+  serializedContent[@"badge"] = content.badge ?: [NSNull null];
+  serializedContent[@"sound"] = [self serializedNotificationSound:content.sound] ?: [NSNull null];
+  serializedContent[@"launchImageName"] = content.launchImageName ?: [NSNull null];
+  serializedContent[@"data"] = [self serializedNotificationData:request] ?: [NSNull null];
+  serializedContent[@"attachments"] = [self serializedNotificationAttachments:content.attachments];
+
+  if (@available(iOS 12.0, *)) {
+    serializedContent[@"summaryArgument"] = content.summaryArgument ?: [NSNull null];
+    serializedContent[@"summaryArgumentCount"] = @(content.summaryArgumentCount);
+  }
+  serializedContent[@"categoryIdentifier"] = content.categoryIdentifier ? content.categoryIdentifier : [NSNull null];
+  serializedContent[@"threadIdentifier"] = content.threadIdentifier ?: [NSNull null];
+  if (@available(iOS 13.0, *)) {
+    serializedContent[@"targetContentIdentifier"] = content.targetContentIdentifier ?: [NSNull null];
+  }
+
+  return serializedContent;
+}
+
++ (NSDictionary *)serializedNotificationData:(UNNotificationRequest *)request
+{
+  BOOL isRemote = [request.trigger isKindOfClass:[UNPushNotificationTrigger class]];
+  return isRemote ? request.content.userInfo[@"body"] : request.content.userInfo;
+}
+
++ (NSString *)serializedNotificationSound:(UNNotificationSound *)sound
+{
+  // nil compared to defaultCriticalSound returns true
+  if (!sound) {
+    return nil;
+  }
+
+  if (@available(iOS 12.0, *)) {
+    if ([[UNNotificationSound defaultCriticalSound] isEqual:sound]) {
+      return @"defaultCritical";
+    }
+  }
+
+  if ([[UNNotificationSound defaultSound] isEqual:sound]) {
+    return @"default";
+  }
+
+  return @"custom";
+}
+
++ (NSArray *)serializedNotificationAttachments:(NSArray<UNNotificationAttachment *> *)attachments
+{
+  NSMutableArray *serializedAttachments = [NSMutableArray array];
+  for (UNNotificationAttachment *attachment in attachments) {
+    [serializedAttachments addObject:[self serializedNotificationAttachment:attachment]];
+  }
+  return serializedAttachments;
+}
+
++ (NSDictionary *)serializedNotificationAttachment:(UNNotificationAttachment *)attachment
+{
+  NSMutableDictionary *serializedAttachment = [NSMutableDictionary dictionary];
+  serializedAttachment[@"identifier"] = attachment.identifier ?: [NSNull null];
+  serializedAttachment[@"url"] = attachment.URL.absoluteString ?: [NSNull null];
+  serializedAttachment[@"type"] = attachment.type ?: [NSNull null];
+  return serializedAttachment;
+}
+
++ (NSDictionary *)serializedNotificationTrigger:(UNNotificationRequest *)request
+{
+  UNNotificationTrigger *trigger = request.trigger;
+  NSMutableDictionary *serializedTrigger = [NSMutableDictionary dictionary];
+  serializedTrigger[@"class"] = NSStringFromClass(trigger.class);
+  if ([trigger isKindOfClass:[UNPushNotificationTrigger class]]) {
+    serializedTrigger[@"type"] = @"push";
+    serializedTrigger[@"payload"] = request.content.userInfo;
+  } else if ([trigger isKindOfClass:[UNCalendarNotificationTrigger class]]) {
+    serializedTrigger[@"type"] = @"calendar";
+    serializedTrigger[@"repeats"] = @(trigger.repeats);
+    UNCalendarNotificationTrigger *calendarTrigger = (UNCalendarNotificationTrigger *)trigger;
+    serializedTrigger[@"dateComponents"] = [self serializedDateComponents:calendarTrigger.dateComponents];
+#if !(TARGET_OS_MACCATALYST)
+  } else if ([trigger isKindOfClass:[UNLocationNotificationTrigger class]]) {
+    serializedTrigger[@"type"] = @"location";
+    serializedTrigger[@"repeats"] = @(trigger.repeats);
+    UNLocationNotificationTrigger *locationTrigger = (UNLocationNotificationTrigger *)trigger;
+    serializedTrigger[@"region"] = [self serializedRegion:locationTrigger.region];
+#endif
+  } else if ([trigger isKindOfClass:[UNTimeIntervalNotificationTrigger class]]) {
+    serializedTrigger[@"type"] = @"timeInterval";
+    UNTimeIntervalNotificationTrigger *timeIntervalTrigger = (UNTimeIntervalNotificationTrigger *)trigger;
+    serializedTrigger[@"seconds"] = @(timeIntervalTrigger.timeInterval);
+    serializedTrigger[@"repeats"] = @(trigger.repeats);
+  } else {
+    serializedTrigger[@"type"] = @"unknown";
+  }
+  return serializedTrigger;
+}
+
++ (NSDictionary *)serializedDateComponents:(NSDateComponents *)dateComponents
+{
+  NSMutableDictionary *serializedComponents = [NSMutableDictionary dictionary];
+  NSArray<NSNumber *> *autoConvertedUnits = [[self calendarUnitsConversionMap] allKeys];
+  for (NSNumber *calendarUnitNumber in autoConvertedUnits) {
+    NSCalendarUnit calendarUnit = [calendarUnitNumber unsignedIntegerValue];
+    NSInteger unitValue = [dateComponents valueForComponent:calendarUnit];
+    if (unitValue != NSDateComponentUndefined) {
+      serializedComponents[[self keyForCalendarUnit:calendarUnit]] = @([dateComponents valueForComponent:calendarUnit]);
+    }
+  }
+  serializedComponents[@"calendar"] = dateComponents.calendar.calendarIdentifier ?: [NSNull null];
+  serializedComponents[@"timeZone"] = dateComponents.timeZone.description ?: [NSNull null];
+  serializedComponents[@"isLeapMonth"] = @(dateComponents.isLeapMonth);
+  return serializedComponents;
+}
+
++ (NSDictionary *)calendarUnitsConversionMap
+{
+  static NSDictionary *keysMap = nil;
+  if (!keysMap) {
+    keysMap = @{
+      @(NSCalendarUnitEra): @"era",
+      @(NSCalendarUnitYear): @"year",
+      @(NSCalendarUnitMonth): @"month",
+      @(NSCalendarUnitDay): @"day",
+      @(NSCalendarUnitHour): @"hour",
+      @(NSCalendarUnitMinute): @"minute",
+      @(NSCalendarUnitSecond): @"second",
+      @(NSCalendarUnitWeekday): @"weekday",
+      @(NSCalendarUnitWeekdayOrdinal): @"weekdayOrdinal",
+      @(NSCalendarUnitQuarter): @"quarter",
+      @(NSCalendarUnitWeekOfMonth): @"weekOfMonth",
+      @(NSCalendarUnitWeekOfYear): @"weekOfYear",
+      @(NSCalendarUnitYearForWeekOfYear): @"yearForWeekOfYear",
+      @(NSCalendarUnitNanosecond): @"nanosecond"
+      // NSCalendarUnitCalendar and NSCalendarUnitTimeZone
+      // should be handled separately
+    };
+  }
+  return keysMap;
+}
+
++ (NSString *)keyForCalendarUnit:(NSCalendarUnit)calendarUnit
+{
+  return [self calendarUnitsConversionMap][@(calendarUnit)];
+}
+
++ (NSDictionary *)serializedRegion:(CLRegion *)region
+{
+  NSMutableDictionary *serializedRegion = [NSMutableDictionary dictionary];
+  serializedRegion[@"identifier"] = region.identifier;
+  serializedRegion[@"notifyOnEntry"] = @(region.notifyOnEntry);
+  serializedRegion[@"notifyOnExit"] = @(region.notifyOnExit);
+  if ([region isKindOfClass:[CLCircularRegion class]]) {
+    serializedRegion[@"type"] = @"circular";
+    CLCircularRegion *circularRegion = (CLCircularRegion *)region;
+    NSDictionary *serializedCenter = @{
+      @"latitude": @(circularRegion.center.latitude),
+      @"longitude": @(circularRegion.center.longitude)
+    };
+    serializedRegion[@"center"] = serializedCenter;
+    serializedRegion[@"radius"] = @(circularRegion.radius);
+  } else if ([region isKindOfClass:[CLBeaconRegion class]]) {
+    serializedRegion[@"type"] = @"beacon";
+    CLBeaconRegion *beaconRegion = (CLBeaconRegion *)region;
+    serializedRegion[@"notifyEntryStateOnDisplay"] = @(beaconRegion.notifyEntryStateOnDisplay);
+    serializedRegion[@"major"] = beaconRegion.major ?: [NSNull null];
+    serializedRegion[@"minor"] = beaconRegion.minor ?: [NSNull null];
+    if (@available(iOS 13.0, *)) {
+      serializedRegion[@"uuid"] = beaconRegion.UUID;
+      NSDictionary *serializedConstraint = @{
+        @"uuid": beaconRegion.beaconIdentityConstraint.UUID,
+        @"major": beaconRegion.beaconIdentityConstraint.major ?: [NSNull null],
+        @"minor": beaconRegion.beaconIdentityConstraint.minor ?: [NSNull null],
+      };
+      serializedRegion[@"beaconIdentityConstraint"] = serializedConstraint;
+    }
+  } else {
+    serializedRegion[@"type"] = @"unknown";
+  }
+  return serializedRegion;
+}
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/EXNotifications/Notifications/EXNotificationsDelegate.h

@@ -0,0 +1,27 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <UserNotifications/UserNotifications.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol EXNotificationsDelegate <NSObject>
+
+@optional
+
+# pragma mark - UIApplicationDelegate
+
+- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler;
+
+# pragma mark - UNUserNotificationCenterDelegate
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler;
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler;
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center openSettingsForNotification:(UNNotification *)notification;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/EXNotifications/Notifications/Emitter/EXNotificationsEmitter.h

@@ -0,0 +1,17 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXExportedModule.h>
+#import <ExpoModulesCore/EXEventEmitter.h>
+#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
+#import <ExpoModulesCore/EXEventEmitterService.h>
+
+#import <EXNotifications/EXNotificationsDelegate.h>
+
+static NSString * const onDidReceiveNotification = @"onDidReceiveNotification";
+static NSString * const onDidReceiveNotificationResponse = @"onDidReceiveNotificationResponse";
+
+@interface EXNotificationsEmitter : EXExportedModule <EXEventEmitter, EXModuleRegistryConsumer, EXNotificationsDelegate>
+
+@property (nonatomic, weak, readonly) id<EXEventEmitterService> eventEmitter;
+
+@end

package/ios/EXNotifications/Notifications/Emitter/EXNotificationsEmitter.m

@@ -0,0 +1,114 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXNotificationsEmitter.h>
+#import <EXNotifications/EXNotificationSerializer.h>
+#import <EXNotifications/EXNotificationCenterDelegate.h>
+
+#import <ExpoModulesCore/EXEventEmitterService.h>
+
+@interface EXNotificationsEmitter ()
+
+@property (nonatomic, weak) id<EXNotificationCenterDelegate> notificationCenterDelegate;
+
+@property (nonatomic, assign) BOOL isBeingObserved;
+@property (nonatomic, assign) BOOL isListening;
+
+@property (nonatomic, weak) id<EXEventEmitterService> eventEmitter;
+
+@property (nonatomic, strong) UNNotificationResponse *lastNotificationResponse;
+
+@end
+
+@implementation EXNotificationsEmitter
+
+EX_EXPORT_MODULE(ExpoNotificationsEmitter);
+
+EX_EXPORT_METHOD_AS(getLastNotificationResponseAsync,
+                    getLastNotificationResponseAsyncWithResolver:(EXPromiseResolveBlock)resolve reject:(EXPromiseRejectBlock)reject)
+{
+  resolve(_lastNotificationResponse ? [self serializedNotificationResponse:_lastNotificationResponse] : [NSNull null]);
+}
+
+# pragma mark - EXModuleRegistryConsumer
+
+- (void)setModuleRegistry:(EXModuleRegistry *)moduleRegistry
+{
+  _eventEmitter = [moduleRegistry getModuleImplementingProtocol:@protocol(EXEventEmitterService)];
+  _notificationCenterDelegate = [moduleRegistry getSingletonModuleForName:@"NotificationCenterDelegate"];
+}
+
+# pragma mark - EXEventEmitter
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[onDidReceiveNotification, onDidReceiveNotificationResponse];
+}
+
+- (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)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler
+{
+  // Background task execution would happen here.
+  completionHandler(UIBackgroundFetchResultNoData);
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response withCompletionHandler:(void (^)(void))completionHandler
+{
+  _lastNotificationResponse = response;
+  [self sendEventWithName:onDidReceiveNotificationResponse body:[self serializedNotificationResponse:response]];
+  completionHandler();
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center willPresentNotification:(UNNotification *)notification withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler
+{
+  [self sendEventWithName:onDidReceiveNotification body:[self serializedNotification:notification]];
+  completionHandler(UNNotificationPresentationOptionNone);
+}
+
+- (void)sendEventWithName:(NSString *)eventName body:(id)body
+{
+  // Silence React Native warning: "Sending ... with no listeners registered."
+  // See: https://github.com/expo/expo/pull/10883#pullrequestreview-529183413
+  // While in practice we don't need to verify this, as as of the end of 2020
+  // we wouldn't send any event to JS if we weren't being observed because
+  // we wouldn't be subscribed to the notification center delegate it's nice
+  // to be sure this problem won't ever arise.
+  if (_isBeingObserved) {
+    [_eventEmitter sendEventWithName:eventName body:body];
+  }
+}
+
+- (NSDictionary *)serializedNotification:(UNNotification *)notification
+{
+  return [EXNotificationSerializer serializedNotification:notification];
+}
+
+- (NSDictionary *)serializedNotificationResponse:(UNNotificationResponse *)notificationResponse
+{
+  return [EXNotificationSerializer serializedNotificationResponse:notificationResponse];
+}
+
+@end

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

@@ -0,0 +1,12 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXExportedModule.h>
+#import <ExpoModulesCore/EXEventEmitter.h>
+#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
+
+#import <EXNotifications/EXNotificationsDelegate.h>
+#import <EXNotifications/EXSingleNotificationHandlerTask.h>
+
+@interface EXNotificationsHandlerModule : EXExportedModule <EXEventEmitter, EXModuleRegistryConsumer, EXNotificationsDelegate, EXSingleNotificationHandlerTaskDelegate>
+
+@end