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

package/ios/EXNotifications/EXServerRegistrationModule.m

@@ -0,0 +1,194 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXServerRegistrationModule.h>
+
+// noop (used by code transform to ensure the versioning isn't applied)
+#define EX_UNVERSIONED(symbol) symbol
+
+static NSString * const kEXDeviceInstallationUUIDKey = EX_UNVERSIONED(@"EXDeviceInstallationUUIDKey");
+static NSString * const kEXDeviceInstallationUUIDLegacyKey = EX_UNVERSIONED(@"EXDeviceInstallUUIDKey");
+
+static NSString * const kEXRegistrationInfoKey = EX_UNVERSIONED(@"EXNotificationRegistrationInfoKey");
+
+@implementation EXServerRegistrationModule
+
+EX_EXPORT_MODULE(NotificationsServerRegistrationModule)
+
+EX_EXPORT_METHOD_AS(getInstallationIdAsync,
+                    getInstallationIdAsyncWithResolver:(EXPromiseResolveBlock)resolve
+                                              rejecter:(EXPromiseRejectBlock)reject)
+{
+  resolve([self getInstallationId]);
+}
+
+- (NSString *)getInstallationId
+{
+  NSString *installationId = [self fetchInstallationId];
+  if (installationId) {
+    return installationId;
+  }
+  
+  installationId = [[NSUUID UUID] UUIDString];
+  [self setInstallationId:installationId error:NULL];
+  return installationId;
+}
+
+- (nullable NSString *)fetchInstallationId
+{
+  NSString *installationId;
+  CFTypeRef keychainResult = NULL;
+  
+  if (SecItemCopyMatching((__bridge CFDictionaryRef)[self installationIdGetQuery], &keychainResult) == noErr) {
+    NSData *result = (__bridge_transfer NSData *)keychainResult;
+    NSString *value = [[NSString alloc] initWithData:result
+                                            encoding:NSUTF8StringEncoding];
+    // `initWithUUIDString` returns nil if string is not a valid UUID
+    if ([[NSUUID alloc] initWithUUIDString:value]) {
+      installationId = value;
+    }
+  }
+  
+  if (installationId) {
+    return installationId;
+  }
+  
+  NSString *legacyUUID = [[NSUserDefaults standardUserDefaults] stringForKey:kEXDeviceInstallationUUIDLegacyKey];
+  if (legacyUUID) {
+    installationId = legacyUUID;
+
+    NSError *error = nil;
+    if ([self setInstallationId:installationId error:&error]) {
+      // We only remove the value from old storage once it's set and saved in the new storage.
+      [[NSUserDefaults standardUserDefaults] removeObjectForKey:kEXDeviceInstallationUUIDLegacyKey];
+    } else {
+      NSLog(@"Could not migrate device installation UUID from legacy storage: %@", error.description);
+    }
+  }
+  
+  return installationId;
+}
+
+- (BOOL)setInstallationId:(NSString *)installationId error:(NSError **)error
+{
+  // Delete existing UUID so we don't need to handle "duplicate item" error
+  SecItemDelete((__bridge CFDictionaryRef)[self installationIdSearchQuery]);
+  
+  OSStatus status = SecItemAdd((__bridge CFDictionaryRef)[self installationIdSetQuery:installationId], NULL);
+  if (status != errSecSuccess && error) {
+    *error = [NSError errorWithDomain:NSOSStatusErrorDomain code:status userInfo:nil];
+  }
+  return status == errSecSuccess;
+}
+
+# pragma mark - Keychain dictionaries
+
+- (NSDictionary *)keychainSearchQueryFor:(NSString *)key merging:(NSDictionary *)dictionaryToMerge
+{
+  NSData *encodedKey = [key dataUsingEncoding:NSUTF8StringEncoding];
+  NSMutableDictionary *query = [NSMutableDictionary dictionaryWithDictionary:@{
+    (__bridge id)kSecClass:(__bridge id)kSecClassGenericPassword,
+    (__bridge id)kSecAttrService:[NSBundle mainBundle].bundleIdentifier,
+    (__bridge id)kSecAttrGeneric:encodedKey,
+    (__bridge id)kSecAttrAccount:encodedKey
+  }];
+  [query addEntriesFromDictionary:dictionaryToMerge];
+  return query;
+}
+
+# pragma mark Installation ID
+
+- (NSDictionary *)installationIdSearchQueryMerging:(NSDictionary *)dictionaryToMerge
+{
+  return [self keychainSearchQueryFor:kEXDeviceInstallationUUIDKey merging:dictionaryToMerge];
+}
+
+- (NSDictionary *)installationIdSearchQuery
+{
+  return [self installationIdSearchQueryMerging:@{}];
+}
+
+- (NSDictionary *)installationIdGetQuery
+{
+  return [self installationIdSearchQueryMerging:@{
+    (__bridge id)kSecMatchLimit:(__bridge id)kSecMatchLimitOne,
+    (__bridge id)kSecReturnData:(__bridge id)kCFBooleanTrue
+  }];
+}
+
+- (NSDictionary *)installationIdSetQuery:(NSString *)deviceInstallationUUID
+{
+  return [self installationIdSearchQueryMerging:@{
+    (__bridge id)kSecValueData:[deviceInstallationUUID dataUsingEncoding:NSUTF8StringEncoding],
+    (__bridge id)kSecAttrAccessible:(__bridge id)kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+  }];
+}
+
+# pragma mark Registration information
+
+- (NSDictionary *)registrationSearchQueryMerging:(NSDictionary *)dictionaryToMerge
+{
+  return [self keychainSearchQueryFor:kEXRegistrationInfoKey merging:dictionaryToMerge];
+}
+
+- (NSDictionary *)registrationSearchQuery
+{
+  return [self registrationSearchQueryMerging:@{}];
+}
+
+- (NSDictionary *)registrationGetQuery
+{
+  return [self registrationSearchQueryMerging:@{
+    (__bridge id)kSecMatchLimit:(__bridge id)kSecMatchLimitOne,
+    (__bridge id)kSecReturnData:(__bridge id)kCFBooleanTrue
+  }];
+}
+
+- (NSDictionary *)registrationSetQuery:(NSString *)registration
+{
+  return [self registrationSearchQueryMerging:@{
+    (__bridge id)kSecValueData:[registration dataUsingEncoding:NSUTF8StringEncoding],
+    (__bridge id)kSecAttrAccessible:(__bridge id)kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+  }];
+}
+
+EX_EXPORT_METHOD_AS(getRegistrationInfoAsync,
+                    getRegistrationInfoAsyncWithResolver:(EXPromiseResolveBlock)resolve
+                                                rejecter:(EXPromiseRejectBlock)reject)
+{
+  CFTypeRef keychainResult = NULL;
+  OSStatus status = SecItemCopyMatching((__bridge CFDictionaryRef)[self registrationGetQuery], &keychainResult);
+  if (status == noErr) {
+    NSData *result = (__bridge_transfer NSData *)keychainResult;
+    NSString *value = [[NSString alloc] initWithData:result
+                                            encoding:NSUTF8StringEncoding];
+    resolve(value);
+  } else if (status == errSecItemNotFound) {
+    resolve(nil);
+  } else {
+    NSError *error = [NSError errorWithDomain:NSOSStatusErrorDomain code:status userInfo:nil];
+    reject(@"ERR_NOTIFICATIONS_KEYCHAIN_ACCESS", @"Could not fetch registration information from keychain.", error);
+  }
+}
+
+EX_EXPORT_METHOD_AS(setRegistrationInfoAsync,
+                    setRegistrationInfoAsync:(NSString *)registrationInfo
+                                    resolver:(EXPromiseResolveBlock)resolve
+                                    rejecter:(EXPromiseRejectBlock)reject)
+{
+  // Delete existing registration so we don't need to handle "duplicate item" error
+  SecItemDelete((__bridge CFDictionaryRef)[self registrationSearchQuery]);
+  
+  if (registrationInfo) {
+    OSStatus status = SecItemAdd((__bridge CFDictionaryRef)[self registrationSetQuery:registrationInfo], NULL);
+    if (status == errSecSuccess) {
+      resolve(nil);
+    } else {
+      NSError *error = [NSError errorWithDomain:NSOSStatusErrorDomain code:status userInfo:nil];
+      reject(@"ERR_NOTIFICATIONS_KEYCHAIN_ACCESS", @"Could not save registration information into keychain.", error);
+    }
+  } else {
+    resolve(nil);
+  }
+}
+
+@end

package/ios/EXNotifications/Notifications/Background/EXBackgroundNotificationTasksModule.h

@@ -0,0 +1,16 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXExportedModule.h>
+#import <ExpoModulesCore/EXModuleRegistryConsumer.h>
+#import <EXNotifications/EXNotificationsDelegate.h>
+
+typedef NS_ENUM(NSUInteger, EXBackgroundNotificationResult) {
+  EXBackgroundNotificationResultNoData = 1,
+  EXBackgroundNotificationResultNewData = 2,
+  EXBackgroundNotificationResultFailed = 3,
+};
+
+@interface EXBackgroundNotificationTasksModule : EXExportedModule <EXModuleRegistryConsumer>
+
+
+@end

package/ios/EXNotifications/Notifications/Background/EXBackgroundNotificationTasksModule.m

@@ -0,0 +1,62 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXBackgroundNotificationTasksModule.h>
+#import <EXNotifications/EXBackgroundRemoteNotificationConsumer.h>
+#import <ExpoModulesCore/EXTaskManagerInterface.h>
+
+@interface EXBackgroundNotificationTasksModule ()
+
+@property (nonatomic, weak) id<EXTaskManagerInterface> taskManager;
+
+@end
+
+@implementation EXBackgroundNotificationTasksModule
+
+EX_EXPORT_MODULE(ExpoBackgroundNotificationTasksModule);
+
+# pragma mark - EXModuleRegistryConsumer
+
+- (void)setModuleRegistry:(EXModuleRegistry *)moduleRegistry
+{
+  _taskManager = [moduleRegistry getModuleImplementingProtocol:@protocol(EXTaskManagerInterface)];
+}
+# pragma mark - Exported methods
+
+EX_EXPORT_METHOD_AS(registerTaskAsync,
+                    registerTaskWithName:(nonnull NSString *)taskName
+                    resolve:(EXPromiseResolveBlock)resolve
+                    reject:(EXPromiseRejectBlock)reject)
+{
+  if (![_taskManager hasBackgroundModeEnabled:@"remote-notification"]) {
+    return reject(
+                  @"E_BACKGROUND_REMOTE_NOTIFICATIONS_DISABLED",
+                  @"Background remote notifications have not been configured. To enable it, add `remote-notification` to `UIBackgroundModes` in the application's Info.plist file.",
+                  nil
+                  );
+  }
+
+  @try {
+    [_taskManager registerTaskWithName:taskName
+                              consumer:EXBackgroundRemoteNotificationConsumer.class
+                               options:@{}];
+  }
+  @catch (NSException *e) {
+    return reject(e.name, e.reason, nil);
+  }
+  resolve(nil);
+}
+
+EX_EXPORT_METHOD_AS(unregisterTaskAsync,
+                    unregisterTaskWithName:(nonnull NSString *)taskName
+                    resolve:(EXPromiseResolveBlock)resolve
+                    reject:(EXPromiseRejectBlock)reject)
+{
+  @try {
+    [_taskManager unregisterTaskWithName:taskName consumerClass:[EXBackgroundRemoteNotificationConsumer class]];
+  } @catch (NSException *e) {
+    return reject(e.name, e.reason, nil);
+  }
+  resolve(nil);
+}
+
+@end

package/ios/EXNotifications/Notifications/Background/EXBackgroundRemoteNotificationConsumer.h

@@ -0,0 +1,14 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import <ExpoModulesCore/EXTaskConsumerInterface.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface EXBackgroundRemoteNotificationConsumer : NSObject <EXTaskConsumerInterface>
+
+@property (nonatomic, strong) id<EXTaskInterface> task;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/EXNotifications/Notifications/Background/EXBackgroundRemoteNotificationConsumer.m

@@ -0,0 +1,51 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXBackgroundNotificationTasksModule.h>
+#import <EXNotifications/EXBackgroundRemoteNotificationConsumer.h>
+#import <ExpoModulesCore/EXTaskInterface.h>
+
+@implementation EXBackgroundRemoteNotificationConsumer
+
++ (BOOL)supportsLaunchReason:(EXTaskLaunchReason)launchReason
+{
+  return launchReason == EXTaskLaunchReasonRemoteNotification;
+}
+
+- (NSString *)taskType
+{
+  return @"remote-notification";
+}
+
+// Associating task to the consumer.
+- (void)didRegisterTask:(id<EXTaskInterface>)task
+{
+  _task = task;
+}
+
+// Method that is being called when the JS app just finished launching,
+// after the native app was launched with the launch reason supported by the consumer.
+// For background notifications, `application:didReceiveRemoteNotification:fetchCompletionHandler:` is the entry point of this method,
+// so the task can be executed immediately here
+- (void)didBecomeReadyToExecuteWithData:(NSDictionary *)data
+{
+  [_task executeWithData:data withError:nil];
+}
+
+// Translate result received from JS to another (native) type that is then used for example as an argument in completion callbacks.
+- (NSUInteger)normalizeTaskResult:(id)result
+{
+  if (!result || result == [NSNull null]) {
+    return UIBackgroundFetchResultNoData;
+  }
+  switch ([result unsignedIntegerValue]) {
+    case EXBackgroundNotificationResultNewData:
+      return UIBackgroundFetchResultNewData;
+    case EXBackgroundNotificationResultFailed:
+      return UIBackgroundFetchResultFailed;
+    case EXBackgroundNotificationResultNoData:
+    default:
+      return UIBackgroundFetchResultNoData;
+  }
+}
+
+@end

package/ios/EXNotifications/Notifications/Categories/EXNotificationCategoriesModule.h

@@ -0,0 +1,25 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <ExpoModulesCore/EXExportedModule.h>
+#import <EXNotifications/EXNotificationsDelegate.h>
+
+@interface EXNotificationCategoriesModule : EXExportedModule <EXNotificationsDelegate>
+
+- (void)getNotificationCategoriesAsyncWithResolver:(EXPromiseResolveBlock)resolve reject:(EXPromiseRejectBlock)reject;
+- (void)setNotificationCategoryWithCategoryId:(NSString *)categoryId
+                                      actions:(NSArray *)actions
+                                      options:(NSDictionary *)options
+                                      resolve:(EXPromiseResolveBlock)resolve 
+                                       reject:(EXPromiseRejectBlock)reject;
+- (void)deleteNotificationCategoryWithCategoryId:(NSString *)categoryId
+                                         resolve:(EXPromiseResolveBlock)resolve 
+                                          reject:(EXPromiseRejectBlock)reject;
+- (NSMutableDictionary *)serializeCategory:(UNNotificationCategory *)category;
+- (UNNotificationCategory *)createCategoryWithId:(NSString*)categoryId
+                                         actions:(NSArray *)actions
+                                         options:(NSDictionary *)options;
+- (NSMutableDictionary *)serializeCategoryOptions:(UNNotificationCategory *)category;
+- (NSMutableArray *)serializeActions:(NSArray<UNNotificationAction *>*)actions;
+- (NSMutableDictionary *)serializeActionOptions:(NSUInteger)options;
+
+@end

package/ios/EXNotifications/Notifications/Categories/EXNotificationCategoriesModule.m

@@ -0,0 +1,217 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+#import <EXNotifications/EXNotificationCategoriesModule.h>
+#import <EXNotifications/EXNotificationCenterDelegate.h>
+
+@implementation EXNotificationCategoriesModule
+
+EX_EXPORT_MODULE(ExpoNotificationCategoriesModule);
+
+# pragma mark - Exported methods
+
+EX_EXPORT_METHOD_AS(getNotificationCategoriesAsync,
+                 getNotificationCategoriesAsyncWithResolver:(EXPromiseResolveBlock)resolve reject:(EXPromiseRejectBlock)reject)
+{
+  [[UNUserNotificationCenter currentNotificationCenter] getNotificationCategoriesWithCompletionHandler:^(NSSet<UNNotificationCategory *> *categories) {
+    NSMutableArray* existingCategories = [NSMutableArray new];
+    for (UNNotificationCategory *category in categories) {
+      [existingCategories addObject:[self serializeCategory:category]];
+    }
+    resolve(existingCategories);
+  }];
+}
+
+EX_EXPORT_METHOD_AS(setNotificationCategoryAsync,
+                 setNotificationCategoryWithCategoryId:(NSString *)categoryId
+                 actions:(NSArray *)actions
+                 options:(NSDictionary *)options
+                 resolve:(EXPromiseResolveBlock)resolve reject:(EXPromiseRejectBlock)reject)
+{
+  UNNotificationCategory *newCategory = [EXNotificationCategoriesModule createCategoryWithId:categoryId
+                                                                                     actions:actions
+                                                                                     options:options];
+  
+  [[UNUserNotificationCenter currentNotificationCenter] getNotificationCategoriesWithCompletionHandler:^(NSSet<UNNotificationCategory *> *categories) {
+    NSMutableSet<UNNotificationCategory *> *newCategories = [categories mutableCopy] ?: [[NSMutableSet alloc] init];
+    for (UNNotificationCategory *category in newCategories) {
+      if ([category.identifier isEqualToString:newCategory.identifier]) {
+        [newCategories removeObject:category];
+        break;
+      }
+    }
+    [newCategories addObject:newCategory];
+    [[UNUserNotificationCenter currentNotificationCenter] setNotificationCategories:newCategories];
+    resolve([self serializeCategory:newCategory]);
+  }];
+}
+
+EX_EXPORT_METHOD_AS(deleteNotificationCategoryAsync,
+                 deleteNotificationCategoryWithCategoryId:(NSString *)categoryId
+                 resolve:(EXPromiseResolveBlock)resolve reject:(EXPromiseRejectBlock)reject)
+{
+  [[UNUserNotificationCenter currentNotificationCenter] getNotificationCategoriesWithCompletionHandler:^(NSSet<UNNotificationCategory *> *categories) {
+    BOOL didDelete = NO;
+    NSMutableSet<UNNotificationCategory *> *newCategories = [categories mutableCopy];
+    for (UNNotificationCategory *category in newCategories) {
+      if ([category.identifier isEqualToString:categoryId]) {
+        [newCategories removeObject:category];
+        didDelete = YES;
+        break;
+      }
+    }
+    [[UNUserNotificationCenter currentNotificationCenter] setNotificationCategories:newCategories];
+    resolve(@(didDelete));
+  }];
+}
+
+# pragma mark- Internal
+
++ (UNNotificationCategory *)createCategoryWithId:(NSString*)categoryId
+                                         actions:(NSArray *)actions
+                                         options:(NSDictionary *)options
+{
+  NSArray<NSString *> *intentIdentifiers = options[@"intentIdentifiers"];
+  NSString *previewPlaceholder = options[@"previewPlaceholder"];
+  NSString *categorySummaryFormat = options[@"categorySummaryFormat"];
+
+  NSMutableArray<UNNotificationAction *> *actionsArray = [[NSMutableArray alloc] init];
+  for (NSDictionary<NSString *, id> *actionParams in actions) {
+    [actionsArray addObject:[self parseNotificationActionFromParams:actionParams]];
+  }
+  UNNotificationCategoryOptions categoryOptions = [self parseNotificationCategoryOptionsFromParams: options];
+  UNNotificationCategory *newCategory;
+  if (@available(iOS 12, *)) {
+    newCategory = [UNNotificationCategory categoryWithIdentifier:categoryId
+                                                         actions:actionsArray
+                                               intentIdentifiers:intentIdentifiers
+                                   hiddenPreviewsBodyPlaceholder:previewPlaceholder
+                                           categorySummaryFormat:categorySummaryFormat
+                                                         options:categoryOptions];
+  } else if (@available(iOS 11, *)) {
+    newCategory = [UNNotificationCategory categoryWithIdentifier:categoryId
+                                                         actions:actionsArray
+                                               intentIdentifiers:intentIdentifiers
+                                   hiddenPreviewsBodyPlaceholder:previewPlaceholder
+                                                         options:categoryOptions];
+  } else {
+    newCategory = [UNNotificationCategory categoryWithIdentifier:categoryId
+                                                         actions:actionsArray
+                                               intentIdentifiers:intentIdentifiers
+                                                         options:categoryOptions];
+  }
+  return newCategory;
+}
+
++ (UNNotificationAction *)parseNotificationActionFromParams:(NSDictionary *)params
+{
+  NSString *identifier = params[@"identifier"];
+  NSString *buttonTitle = params[@"buttonTitle"];
+  UNNotificationActionOptions options = UNNotificationActionOptionNone;
+
+  if (params[@"options"][@"opensAppToForeground"] == nil || [params[@"options"][@"opensAppToForeground"] boolValue]) {
+    options += UNNotificationActionOptionForeground;
+  }
+  if ([params[@"options"][@"isDestructive"] boolValue]) {
+    options += UNNotificationActionOptionDestructive;
+  }
+  if ([params[@"options"][@"isAuthenticationRequired"] boolValue]) {
+    options += UNNotificationActionOptionAuthenticationRequired;
+  }
+
+  if ([params[@"textInput"] isKindOfClass:[NSDictionary class]]) {
+    return [UNTextInputNotificationAction actionWithIdentifier:identifier
+                                                         title:buttonTitle
+                                                       options:options
+                                          textInputButtonTitle:params[@"textInput"][@"submitButtonTitle"]
+                                          textInputPlaceholder:params[@"textInput"][@"placeholder"]];
+  }
+
+  return [UNNotificationAction actionWithIdentifier:identifier title:buttonTitle options:options];
+}
+
++ (UNNotificationCategoryOptions )parseNotificationCategoryOptionsFromParams:(NSDictionary *)params
+{
+  UNNotificationCategoryOptions options = UNNotificationCategoryOptionNone;
+  if ([params[@"customDismissAction"] boolValue]) {
+    options += UNNotificationCategoryOptionCustomDismissAction;
+  }
+  if ([params[@"allowInCarPlay"] boolValue]) {
+    options += UNNotificationCategoryOptionAllowInCarPlay;
+  }
+  if (@available(iOS 11, *)) {
+    if ([params[@"showTitle"] boolValue]) {
+      options += UNNotificationCategoryOptionHiddenPreviewsShowTitle;
+    }
+    if ([params[@"showSubtitle"] boolValue]) {
+      options += UNNotificationCategoryOptionHiddenPreviewsShowSubtitle;
+    }
+  }
+  if (@available(iOS 13, *)) {
+    if ([params[@"allowAnnouncement"] boolValue]) {
+      options += UNNotificationCategoryOptionAllowAnnouncement;
+    }
+  }
+
+  return options;
+}
+
+- (NSMutableDictionary *)serializeCategory:(UNNotificationCategory *)category
+{
+  NSMutableDictionary* serializedCategory = [NSMutableDictionary dictionary];
+  serializedCategory[@"identifier"] = category.identifier;
+  serializedCategory[@"actions"] = [self serializeActions: category.actions];
+  serializedCategory[@"options"] = [self serializeCategoryOptions: category];
+  return serializedCategory;
+}
+
+- (NSMutableDictionary *)serializeCategoryOptions:(UNNotificationCategory *)category
+{
+  NSMutableDictionary* serializedOptions = [NSMutableDictionary dictionary];
+  serializedOptions[@"intentIdentifiers"] = category.intentIdentifiers;
+  serializedOptions[@"customDismissAction"] =  [NSNumber numberWithBool:((category.options & UNNotificationCategoryOptionCustomDismissAction) != 0)];
+  serializedOptions[@"allowInCarPlay"] = [NSNumber numberWithBool:((category.options & UNNotificationCategoryOptionAllowInCarPlay) != 0)];
+  if (@available(iOS 11, *)) {
+    serializedOptions[@"previewPlaceholder"] = category.hiddenPreviewsBodyPlaceholder;
+    serializedOptions[@"showTitle"] =  [NSNumber numberWithBool:((category.options & UNNotificationCategoryOptionHiddenPreviewsShowTitle) != 0)];
+    serializedOptions[@"showSubtitle"] = [NSNumber numberWithBool:((category.options & UNNotificationCategoryOptionHiddenPreviewsShowSubtitle) != 0)];
+  }
+  if (@available(iOS 12, *)) {
+    serializedOptions[@"categorySummaryFormat"] = category.categorySummaryFormat;
+  }
+  if (@available(iOS 13, *)) {
+    serializedOptions[@"allowAnnouncement"] = [NSNumber numberWithBool:((category.options & UNNotificationActionOptionAuthenticationRequired) != 0)];
+  }
+  return serializedOptions;
+}
+
+- (NSMutableArray *)serializeActions:(NSArray<UNNotificationAction *>*)actions
+{
+  NSMutableArray* serializedActions = [NSMutableArray new];
+  for (NSUInteger i = 0; i < [actions count]; i++)
+  {
+    NSMutableDictionary *actionDictionary = [NSMutableDictionary dictionary];
+    actionDictionary[@"buttonTitle"] = actions[i].title;
+    actionDictionary[@"identifier"] = actions[i].identifier;
+    actionDictionary[@"options"] = [self serializeActionOptions:actions[i].options];
+    if ([actions[i] isKindOfClass:[UNTextInputNotificationAction class]]) {
+      UNTextInputNotificationAction *textInputAction = (UNTextInputNotificationAction *)actions[i];
+      NSMutableDictionary *textInputOptions = [NSMutableDictionary dictionary];
+      textInputOptions[@"placeholder"] = textInputAction.textInputPlaceholder;
+      textInputOptions[@"submitButtonTitle"] = textInputAction.textInputButtonTitle;
+      actionDictionary[@"textInput"] = textInputOptions;
+    }
+    [serializedActions addObject:actionDictionary];
+  }
+  return serializedActions;
+}
+
+- (NSMutableDictionary *)serializeActionOptions:(NSUInteger)options
+{
+  NSMutableDictionary* serializedOptions = [NSMutableDictionary dictionary];
+  serializedOptions[@"opensAppToForeground"] =  [NSNumber numberWithBool:((options & UNNotificationActionOptionForeground) != 0)];
+  serializedOptions[@"isDestructive"] = [NSNumber numberWithBool:((options & UNNotificationActionOptionDestructive) != 0)];
+  serializedOptions[@"isAuthenticationRequired"] = [NSNumber numberWithBool:((options & UNNotificationActionOptionAuthenticationRequired) != 0)];
+  return serializedOptions;
+}
+
+@end

package/ios/EXNotifications/Notifications/EXNotificationCenterDelegate.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>
+#import <UserNotifications/UserNotifications.h>
+#import <EXNotifications/EXNotificationsDelegate.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol EXNotificationCenterDelegate
+
+- (void)addDelegate:(id<EXNotificationsDelegate>)delegate;
+- (void)removeDelegate:(id<EXNotificationsDelegate>)delegate;
+
+@end
+
+@interface EXNotificationCenterDelegate : EXSingletonModule <UIApplicationDelegate, UNUserNotificationCenterDelegate, EXNotificationCenterDelegate>
+
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(nullable NSDictionary<UIApplicationLaunchOptionsKey,id> *)launchOptions;
+- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler;
+
+- (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:(nullable UNNotification *)notification;
+
+@end
+
+NS_ASSUME_NONNULL_END