react-native-notify-kit 10.0.0 → 10.2.0

package/ios/NotifeeCore/NotifeeCore.m

@@ -17,6 +17,7 @@
 
 #import <UIKit/UIKit.h>
 #import <dispatch/dispatch.h>
+#include <math.h>
 
 #import "Intents/Intents.h"
 #import "NotifeeCore+UNUserNotificationCenter.h"
@@ -25,8 +26,950 @@
 #import "NotifeeCoreExtensionHelper.h"
 #import "NotifeeCoreUtil.h"
 
+static NSString *const kNotifeeRollingPublicId = @"notifee_rolling_public_id";
+static NSString *const kNotifeeRollingOccurrenceMs = @"notifee_rolling_occurrence_ms";
+static NSString *const kNotifeeRollingInternalId = @"notifee_rolling_internal_id";
+static NSString *const kNotifeeRollingInternalIdPrefix = @"__notifee_rolling__";
+static NSString *const kNotifeeCoreErrorDomain = @"app.notifee.core";
+
+typedef NS_ENUM(NSInteger, NotifeeCoreRollingErrorCode) {
+  NotifeeCoreRollingErrorCodeInvalidTrigger = 1,
+  NotifeeCoreRollingErrorCodeBudgetExceeded = 2,
+  NotifeeCoreRollingErrorCodeStorageFailed = 3,
+};
+
 @implementation NotifeeCore
 
++ (dispatch_queue_t)rollingTimestampQueue {
+  static dispatch_queue_t queue;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    queue = dispatch_queue_create("app.notifee.core.rollingTimestamp", DISPATCH_QUEUE_SERIAL);
+  });
+  return queue;
+}
+
++ (NSError *)rollingTimestampErrorWithCode:(NotifeeCoreRollingErrorCode)code
+                                   message:(NSString *)message {
+  return [NSError errorWithDomain:kNotifeeCoreErrorDomain
+                             code:code
+                         userInfo:@{NSLocalizedDescriptionKey : message}];
+}
+
++ (NSNumber *)currentTimestampMs {
+  return @((long long)llround([[NSDate date] timeIntervalSince1970] * 1000.0));
+}
+
++ (void)resolveBlock:(notifeeMethodVoidBlock)block withError:(NSError *)error {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    block(error);
+  });
+}
+
++ (NSArray<UNNotificationRequest *> *)pendingNotificationRequests:
+    (UNUserNotificationCenter *)center {
+  __block NSArray<UNNotificationRequest *> *pendingRequests = @[];
+  dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+
+  [center getPendingNotificationRequestsWithCompletionHandler:^(
+              NSArray<UNNotificationRequest *> *_Nonnull requests) {
+    pendingRequests = requests != nil ? requests : @[];
+    dispatch_semaphore_signal(semaphore);
+  }];
+
+  dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+  return pendingRequests;
+}
+
++ (NSArray<UNNotification *> *)deliveredNotifications:(UNUserNotificationCenter *)center {
+  __block NSArray<UNNotification *> *deliveredNotifications = @[];
+  dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+
+  [center getDeliveredNotificationsWithCompletionHandler:^(
+              NSArray<UNNotification *> *_Nonnull notifications) {
+    deliveredNotifications = notifications != nil ? notifications : @[];
+    dispatch_semaphore_signal(semaphore);
+  }];
+
+  dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
+  return deliveredNotifications;
+}
+
++ (NSString *)rollingPublicIdForNotification:(NSDictionary *)notification {
+  NSString *publicId = notification[@"id"];
+  if (![publicId isKindOfClass:NSString.class] || [publicId length] == 0) {
+    return nil;
+  }
+
+  return publicId;
+}
+
++ (BOOL)isPotentialRollingInternalNotificationId:(NSString *)notificationId {
+  return [notificationId isKindOfClass:NSString.class] &&
+         [notificationId hasPrefix:kNotifeeRollingInternalIdPrefix];
+}
+
++ (NSString *)rollingPublicIdForRequest:(UNNotificationRequest *)request {
+  NSString *identifier = request.identifier;
+  NSString *mappedPublicId =
+      [NotifeeCoreUtil rollingPublicIdFromInternalNotificationId:identifier];
+  if ([mappedPublicId isKindOfClass:NSString.class] && [mappedPublicId length] > 0) {
+    return mappedPublicId;
+  }
+
+  if ([self isPotentialRollingInternalNotificationId:identifier]) {
+    NSString *metadataPublicId = request.content.userInfo[kNotifeeRollingPublicId];
+    if ([metadataPublicId isKindOfClass:NSString.class] && [metadataPublicId length] > 0) {
+      return metadataPublicId;
+    }
+
+    NSDictionary *notification = request.content.userInfo[kNotifeeUserInfoNotification];
+    if ([notification isKindOfClass:NSDictionary.class]) {
+      NSString *payloadPublicId = notification[@"id"];
+      if ([payloadPublicId isKindOfClass:NSString.class] && [payloadPublicId length] > 0) {
+        return payloadPublicId;
+      }
+    }
+  }
+
+  return nil;
+}
+
++ (NSString *)publicIdentifierForRequest:(UNNotificationRequest *)request {
+  NSString *rollingPublicId = [self rollingPublicIdForRequest:request];
+  if (rollingPublicId != nil) {
+    return rollingPublicId;
+  }
+
+  NSString *identifier = request.identifier;
+  if ([self isPotentialRollingInternalNotificationId:identifier]) {
+    return nil;
+  }
+
+  return identifier;
+}
+
++ (void)addString:(NSString *)string toOrderedSet:(NSMutableOrderedSet<NSString *> *)orderedSet {
+  if ([string isKindOfClass:NSString.class] && [string length] > 0) {
+    [orderedSet addObject:string];
+  }
+}
+
++ (NSMutableOrderedSet<NSString *> *)rollingIdentifiersForPublicId:(NSString *)publicId
+                                                    pendingRequests:
+                                                        (NSArray<UNNotificationRequest *> *)
+                                                            pendingRequests
+                                                            record:(NSDictionary *)record {
+  NSMutableOrderedSet<NSString *> *identifiers = [NSMutableOrderedSet orderedSet];
+
+  NSArray *scheduledIds = record[@"scheduledIds"];
+  if ([scheduledIds isKindOfClass:NSArray.class]) {
+    for (id scheduledId in scheduledIds) {
+      [self addString:scheduledId toOrderedSet:identifiers];
+    }
+  }
+
+  for (UNNotificationRequest *request in pendingRequests) {
+    NSString *identifier = request.identifier;
+    if ([identifier isEqualToString:publicId]) {
+      [self addString:identifier toOrderedSet:identifiers];
+      continue;
+    }
+
+    NSString *mappedPublicId =
+        [NotifeeCoreUtil rollingPublicIdFromInternalNotificationId:identifier];
+    if ([mappedPublicId isEqualToString:publicId]) {
+      [self addString:identifier toOrderedSet:identifiers];
+    }
+  }
+
+  return identifiers;
+}
+
++ (NSMutableOrderedSet<NSString *> *)rollingDeliveredIdentifiersForPublicId:
+                                      (NSString *)publicId
+                                                   deliveredNotifications:
+                                                       (NSArray<UNNotification *> *)
+                                                           deliveredNotifications
+                                                                 record:(NSDictionary *)record {
+  NSMutableOrderedSet<NSString *> *identifiers = [NSMutableOrderedSet orderedSet];
+
+  NSArray *scheduledIds = record[@"scheduledIds"];
+  if ([scheduledIds isKindOfClass:NSArray.class]) {
+    for (id scheduledId in scheduledIds) {
+      [self addString:scheduledId toOrderedSet:identifiers];
+    }
+  }
+
+  for (UNNotification *notification in deliveredNotifications) {
+    UNNotificationRequest *request = notification.request;
+    NSString *identifier = request.identifier;
+    if ([identifier isEqualToString:publicId]) {
+      [self addString:identifier toOrderedSet:identifiers];
+      continue;
+    }
+
+    NSString *mappedPublicId = [self rollingPublicIdForRequest:request];
+    if ([mappedPublicId isEqualToString:publicId]) {
+      [self addString:identifier toOrderedSet:identifiers];
+    }
+  }
+
+  return identifiers;
+}
+
++ (NSUInteger)pendingRequestCountForIdentifiers:(NSOrderedSet<NSString *> *)identifiers
+                                pendingRequests:
+                                    (NSArray<UNNotificationRequest *> *)pendingRequests {
+  NSUInteger count = 0;
+  for (UNNotificationRequest *request in pendingRequests) {
+    if ([identifiers containsObject:request.identifier]) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
++ (UNCalendarNotificationTrigger *)rollingOneShotTriggerForOccurrenceMs:
+    (NSNumber *)occurrenceMs {
+  NSDate *date = [NSDate dateWithTimeIntervalSince1970:([occurrenceMs doubleValue] / 1000.0)];
+  NSDateComponents *components =
+      [[NSCalendar currentCalendar] components:NSCalendarUnitYear | NSCalendarUnitMonth |
+                                   NSCalendarUnitDay | NSCalendarUnitHour |
+                                   NSCalendarUnitMinute | NSCalendarUnitSecond
+                                      fromDate:date];
+
+  return [UNCalendarNotificationTrigger triggerWithDateMatchingComponents:components repeats:NO];
+}
+
++ (UNMutableNotificationContent *)rollingContentFromContent:(UNMutableNotificationContent *)content
+                                                   publicId:(NSString *)publicId
+                                               occurrenceMs:(NSNumber *)occurrenceMs
+                                                 internalId:(NSString *)internalId {
+  UNMutableNotificationContent *rollingContent = [content mutableCopy];
+  NSMutableDictionary *userInfo = [rollingContent.userInfo mutableCopy];
+  userInfo[kNotifeeRollingPublicId] = publicId;
+  userInfo[kNotifeeRollingOccurrenceMs] = occurrenceMs;
+  userInfo[kNotifeeRollingInternalId] = internalId;
+  rollingContent.userInfo = userInfo;
+
+  return rollingContent;
+}
+
++ (UNMutableNotificationContent *)triggerNotificationContentForNotification:
+                                  (NSDictionary *)notification
+                                                                    trigger:(NSDictionary *)trigger {
+  UNMutableNotificationContent *content = [self buildNotificationContent:notification
+                                                              withTrigger:trigger];
+
+  if (@available(iOS 15.0, *)) {
+    if (notification[@"ios"][@"communicationInfo"] != nil) {
+      INSendMessageIntent *intent = [NotifeeCoreUtil
+          generateSenderIntentForCommunicationNotification:notification[@"ios"]
+                                                                       [@"communicationInfo"]];
+
+      INInteraction *interaction = [[INInteraction alloc] initWithIntent:intent response:nil];
+      interaction.direction = INInteractionDirectionIncoming;
+      [interaction donateInteractionWithCompletion:^(NSError *donateError) {
+        if (donateError)
+          NSLog(@"NotifeeCore: Could not donate interaction for communication notification: %@",
+                donateError);
+      }];
+
+      NSError *contentUpdateError = nil;
+      UNNotificationContent *updatedContent =
+          [content contentByUpdatingWithProvider:intent error:&contentUpdateError];
+      if (contentUpdateError) {
+        NSLog(@"NotifeeCore: Could not update notification content with communication intent: %@",
+              contentUpdateError);
+      } else if (updatedContent != nil) {
+        content = [updatedContent mutableCopy];
+      }
+    }
+  }
+
+  return content;
+}
+
++ (UNNotificationRequest *)rollingNotificationRequestForPublicId:(NSString *)publicId
+                                                    occurrenceMs:(NSNumber *)occurrenceMs
+                                                         content:(UNMutableNotificationContent *)content
+                                                           error:(NSError **)error {
+  NSString *internalId = [NotifeeCoreUtil rollingInternalNotificationIdForPublicId:publicId
+                                                                      occurrenceMs:occurrenceMs];
+  if (internalId == nil) {
+    if (error != nil) {
+      *error = [self
+          rollingTimestampErrorWithCode:NotifeeCoreRollingErrorCodeInvalidTrigger
+                                message:@"NotifeeCore: Failed to create rolling timestamp "
+                                        @"notification identifier."];
+    }
+    return nil;
+  }
+
+  UNMutableNotificationContent *rollingContent = [self rollingContentFromContent:content
+                                                                        publicId:publicId
+                                                                    occurrenceMs:occurrenceMs
+                                                                      internalId:internalId];
+  return [UNNotificationRequest
+      requestWithIdentifier:internalId
+                    content:rollingContent
+                    trigger:[self rollingOneShotTriggerForOccurrenceMs:occurrenceMs]];
+}
+
++ (void)removeRollingPendingRequestsForIds:(NSArray<NSString *> *)identifiers
+                                    center:(UNUserNotificationCenter *)center {
+  if ([identifiers count] > 0) {
+    [center removePendingNotificationRequestsWithIdentifiers:identifiers];
+  }
+}
+
++ (NSMutableSet<NSString *> *)pendingIdentifierSetFromRequests:
+    (NSArray<UNNotificationRequest *> *)pendingRequests {
+  NSMutableSet<NSString *> *identifiers = [NSMutableSet set];
+  for (UNNotificationRequest *request in pendingRequests) {
+    NSString *identifier = request.identifier;
+    if ([identifier isKindOfClass:NSString.class] && [identifier length] > 0) {
+      [identifiers addObject:identifier];
+    }
+  }
+  return identifiers;
+}
+
++ (NSComparisonResult)compareRollingRebalanceState:(NSDictionary *)firstState
+                                        otherState:(NSDictionary *)secondState {
+  return [firstState[@"publicId"] compare:secondState[@"publicId"]];
+}
+
++ (NSError *)scheduleRollingNotificationRequests:(NSArray<UNNotificationRequest *> *)requests
+                                          center:(UNUserNotificationCenter *)center
+                           successfulIdentifiers:
+                               (NSMutableSet<NSString *> *)successfulIdentifiers {
+  if ([requests count] == 0) {
+    return nil;
+  }
+
+  dispatch_group_t group = dispatch_group_create();
+  NSObject *scheduleLock = [[NSObject alloc] init];
+  __block NSError *scheduleError = nil;
+
+  for (__unused UNNotificationRequest *request in requests) {
+    dispatch_group_enter(group);
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    for (UNNotificationRequest *request in requests) {
+      [center addNotificationRequest:request
+               withCompletionHandler:^(NSError *_Nullable error) {
+                 @synchronized(scheduleLock) {
+                   if (error != nil && scheduleError == nil) {
+                     scheduleError = error;
+                   } else if (error == nil && successfulIdentifiers != nil) {
+                     [successfulIdentifiers addObject:request.identifier];
+                   }
+                 }
+                 dispatch_group_leave(group);
+               }];
+    }
+  });
+
+  dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
+  return scheduleError;
+}
+
++ (BOOL)persistedRollingRecords:(NSDictionary *)persistedRecords
+           matchUpdatedRecords:(NSDictionary *)updatedRecords {
+  if ([persistedRecords count] != [updatedRecords count]) {
+    return NO;
+  }
+
+  for (id publicId in updatedRecords) {
+    if (persistedRecords[publicId] == nil) {
+      return NO;
+    }
+  }
+
+  return YES;
+}
+
++ (NSArray<NSMutableDictionary *> *)rollingRebalanceStatesFromRecords:(NSDictionary *)records
+                                                                nowMs:(NSNumber *)nowMs
+                                                     requiredPublicId:
+                                                         (NSString *)requiredPublicId
+                                                                error:(NSError **)error {
+  NSMutableArray<NSMutableDictionary *> *states = [NSMutableArray array];
+  BOOL foundRequiredPublicId = requiredPublicId == nil;
+
+  for (id key in records) {
+    if (![key isKindOfClass:NSString.class] || [key length] == 0) {
+      continue;
+    }
+
+    NSString *publicId = key;
+    BOOL isRequiredPublicId = [publicId isEqualToString:requiredPublicId];
+    if (isRequiredPublicId) {
+      foundRequiredPublicId = YES;
+    }
+
+    NSDictionary *record = records[publicId];
+    NSDictionary *notification = record[@"notification"];
+    NSDictionary *trigger = record[@"trigger"];
+    if (![notification isKindOfClass:NSDictionary.class] ||
+        ![trigger isKindOfClass:NSDictionary.class] ||
+        ![NotifeeCoreUtil isRollingTimestampTrigger:trigger]) {
+      if (isRequiredPublicId && error != nil) {
+        *error = [self
+            rollingTimestampErrorWithCode:NotifeeCoreRollingErrorCodeInvalidTrigger
+                                  message:@"NotifeeCore: Rolling timestamp trigger requires a "
+                                          @"valid notification and trigger record."];
+        return nil;
+      }
+      continue;
+    }
+
+    NSArray<NSNumber *> *firstOccurrence =
+        [NotifeeCoreUtil rollingTimestampOccurrencesFromTrigger:trigger nowMs:nowMs maxCount:1];
+    NSNumber *firstOccurrenceMs = [firstOccurrence firstObject];
+    NSString *firstInternalId =
+        [NotifeeCoreUtil rollingInternalNotificationIdForPublicId:publicId
+                                                     occurrenceMs:firstOccurrenceMs];
+    if (firstOccurrenceMs == nil || firstInternalId == nil) {
+      if (isRequiredPublicId && error != nil) {
+        *error = [self
+            rollingTimestampErrorWithCode:NotifeeCoreRollingErrorCodeInvalidTrigger
+                                  message:@"NotifeeCore: Rolling timestamp trigger did not "
+                                          @"produce any future occurrences."];
+        return nil;
+      }
+      continue;
+    }
+
+    NSNumber *createdAt = record[@"createdAtMs"];
+    if (![createdAt isKindOfClass:NSNumber.class]) {
+      createdAt = nowMs;
+    }
+
+    NSMutableDictionary *state = [NSMutableDictionary dictionary];
+    state[@"publicId"] = publicId;
+    state[@"notification"] = notification;
+    state[@"trigger"] = trigger;
+    state[@"createdAtMs"] = createdAt;
+    state[@"quota"] = @0;
+    [states addObject:state];
+  }
+
+  if (!foundRequiredPublicId) {
+    if (error != nil) {
+      *error = [self rollingTimestampErrorWithCode:NotifeeCoreRollingErrorCodeInvalidTrigger
+                                           message:@"NotifeeCore: Rolling timestamp trigger "
+                                                   @"record was not found for rebalance."];
+    }
+    return nil;
+  }
+
+  [states sortUsingComparator:^NSComparisonResult(NSDictionary *firstState,
+                                                  NSDictionary *secondState) {
+    return [self compareRollingRebalanceState:firstState otherState:secondState];
+  }];
+
+  return states;
+}
+
++ (BOOL)prepareRollingRebalanceDesiredSchedulesForStates:
+            (NSArray<NSMutableDictionary *> *)states
+                                                   nowMs:(NSNumber *)nowMs
+                                                   error:(NSError **)error {
+  for (NSMutableDictionary *state in states) {
+    NSInteger quota = [state[@"quota"] integerValue];
+    if (quota <= 0) {
+      continue;
+    }
+
+    NSString *publicId = state[@"publicId"];
+    NSDictionary *notification = state[@"notification"];
+    NSDictionary *trigger = state[@"trigger"];
+    NSArray<NSNumber *> *occurrences =
+        [NotifeeCoreUtil rollingTimestampOccurrencesFromTrigger:trigger
+                                                          nowMs:nowMs
+                                                       maxCount:quota];
+    if ([occurrences count] == 0) {
+      if (error != nil) {
+        *error = [self
+            rollingTimestampErrorWithCode:NotifeeCoreRollingErrorCodeInvalidTrigger
+                                  message:@"NotifeeCore: Rolling timestamp trigger did not "
+                                          @"produce any future occurrences."];
+      }
+      return NO;
+    }
+
+    UNMutableNotificationContent *content =
+        [self triggerNotificationContentForNotification:notification trigger:trigger];
+    NSMutableOrderedSet<NSString *> *desiredIds = [NSMutableOrderedSet orderedSet];
+    NSMutableDictionary<NSString *, UNNotificationRequest *> *desiredRequests =
+        [NSMutableDictionary dictionary];
+    NSNumber *lastScheduledOccurrence = nil;
+
+    for (NSNumber *occurrenceMs in occurrences) {
+      if ([desiredIds count] >= (NSUInteger)quota) {
+        break;
+      }
+
+      NSError *requestError = nil;
+      UNNotificationRequest *request =
+          [self rollingNotificationRequestForPublicId:publicId
+                                         occurrenceMs:occurrenceMs
+                                              content:content
+                                                error:&requestError];
+      if (request == nil) {
+        if (error != nil) {
+          *error = requestError;
+        }
+        return NO;
+      }
+
+      if ([desiredIds containsObject:request.identifier]) {
+        continue;
+      }
+
+      [desiredIds addObject:request.identifier];
+      desiredRequests[request.identifier] = request;
+      lastScheduledOccurrence = occurrenceMs;
+    }
+
+    if ([desiredIds count] == 0 || lastScheduledOccurrence == nil) {
+      if (error != nil) {
+        *error = [self
+            rollingTimestampErrorWithCode:NotifeeCoreRollingErrorCodeInvalidTrigger
+                                  message:@"NotifeeCore: Rolling timestamp trigger did not "
+                                          @"produce any future occurrences."];
+      }
+      return NO;
+    }
+
+    NSMutableDictionary *updatedRecord = [NSMutableDictionary dictionary];
+    updatedRecord[@"publicId"] = publicId;
+    updatedRecord[@"notification"] = notification;
+    updatedRecord[@"trigger"] = trigger;
+    updatedRecord[@"scheduledIds"] = [desiredIds array];
+    updatedRecord[@"lastScheduledOccurrenceMs"] = lastScheduledOccurrence;
+    updatedRecord[@"createdAtMs"] = state[@"createdAtMs"];
+
+    state[@"desiredIds"] = desiredIds;
+    state[@"desiredRequests"] = desiredRequests;
+    state[@"updatedRecord"] = updatedRecord;
+  }
+
+  return YES;
+}
+
++ (void)rollbackRollingRebalanceRemovedRequests:
+            (NSArray<UNNotificationRequest *> *)removedRequests
+                         successfulNewIdentifiers:(NSSet<NSString *> *)successfulNewIdentifiers
+                                           center:(UNUserNotificationCenter *)center {
+  if ([successfulNewIdentifiers count] > 0) {
+    [self removeRollingPendingRequestsForIds:[successfulNewIdentifiers allObjects] center:center];
+  }
+
+  if ([removedRequests count] > 0) {
+    [self scheduleRollingNotificationRequests:removedRequests
+                                       center:center
+                        successfulIdentifiers:nil];
+  }
+}
+
++ (BOOL)rebalanceRollingTimestampTriggerRecords:(NSDictionary *)records
+                                         center:(UNUserNotificationCenter *)center
+                                pendingRequests:
+                                    (NSArray<UNNotificationRequest *> *)pendingRequests
+                                          nowMs:(NSNumber *)nowMs
+                                refreshPublicId:(NSString *)refreshPublicId
+                               requiredPublicId:(NSString *)requiredPublicId
+                                          error:(NSError **)error {
+  NSError *stateError = nil;
+  NSArray<NSMutableDictionary *> *states =
+      [self rollingRebalanceStatesFromRecords:records
+                                        nowMs:nowMs
+                             requiredPublicId:requiredPublicId
+                                        error:&stateError];
+  if (states == nil) {
+    if (error != nil) {
+      *error = stateError;
+    }
+    return NO;
+  }
+
+  NSMutableSet<NSString *> *pendingIdentifierSet =
+      [self pendingIdentifierSetFromRequests:pendingRequests];
+  NSMutableDictionary<NSString *, UNNotificationRequest *> *pendingRequestByIdentifier =
+      [NSMutableDictionary dictionary];
+  NSMutableOrderedSet<NSString *> *rollingPendingIdentifiers = [NSMutableOrderedSet orderedSet];
+  NSMutableOrderedSet<NSString *> *replacementPendingIdentifiers = [NSMutableOrderedSet orderedSet];
+  NSInteger nonRollingPendingCount = 0;
+
+  for (UNNotificationRequest *request in pendingRequests) {
+    NSString *identifier = request.identifier;
+    if (![identifier isKindOfClass:NSString.class] || [identifier length] == 0) {
+      continue;
+    }
+
+    pendingRequestByIdentifier[identifier] = request;
+    if ([self isPotentialRollingInternalNotificationId:identifier]) {
+      [rollingPendingIdentifiers addObject:identifier];
+    } else if ([identifier isEqualToString:refreshPublicId]) {
+      [replacementPendingIdentifiers addObject:identifier];
+    } else {
+      nonRollingPendingCount += 1;
+    }
+  }
+
+  NSInteger rollingBudget = [NotifeeCoreUtil rollingPendingBudget] - nonRollingPendingCount;
+  if (rollingBudget < 0) {
+    rollingBudget = 0;
+  }
+
+  if ((NSInteger)[states count] > rollingBudget) {
+    if (error != nil) {
+      *error = [self
+          rollingTimestampErrorWithCode:NotifeeCoreRollingErrorCodeBudgetExceeded
+                                message:@"NotifeeCore: iOS rolling timestamp trigger budget "
+                                        @"cannot allocate one occurrence per active trigger."];
+    }
+    return NO;
+  }
+
+  NSInteger targetPerTrigger = [NotifeeCoreUtil rollingTargetPerTrigger];
+  NSInteger remainingBudget = rollingBudget;
+  for (NSMutableDictionary *state in states) {
+    state[@"quota"] = @1;
+    remainingBudget -= 1;
+  }
+
+  BOOL allocatedAdditionalSlot = YES;
+  while (remainingBudget > 0 && allocatedAdditionalSlot) {
+    allocatedAdditionalSlot = NO;
+    for (NSMutableDictionary *state in states) {
+      if (remainingBudget <= 0) {
+        break;
+      }
+
+      NSInteger quota = [state[@"quota"] integerValue];
+      if (quota >= targetPerTrigger) {
+        continue;
+      }
+
+      state[@"quota"] = @(quota + 1);
+      remainingBudget -= 1;
+      allocatedAdditionalSlot = YES;
+    }
+  }
+
+  NSError *planError = nil;
+  if (![self prepareRollingRebalanceDesiredSchedulesForStates:states
+                                                        nowMs:nowMs
+                                                        error:&planError]) {
+    if (error != nil) {
+      *error = planError;
+    }
+    return NO;
+  }
+
+  NSMutableOrderedSet<NSString *> *desiredIdentifiers = [NSMutableOrderedSet orderedSet];
+  NSMutableDictionary *updatedRecords = [NSMutableDictionary dictionary];
+  for (NSMutableDictionary *state in states) {
+    NSOrderedSet<NSString *> *stateDesiredIds = state[@"desiredIds"];
+    [desiredIdentifiers unionOrderedSet:stateDesiredIds];
+
+    NSString *publicId = state[@"publicId"];
+    NSDictionary *updatedRecord = state[@"updatedRecord"];
+    if (publicId != nil && updatedRecord != nil) {
+      updatedRecords[publicId] = updatedRecord;
+    }
+  }
+
+  if (requiredPublicId != nil && updatedRecords[requiredPublicId] == nil) {
+    if (error != nil) {
+      *error = [self
+          rollingTimestampErrorWithCode:NotifeeCoreRollingErrorCodeInvalidTrigger
+                                message:@"NotifeeCore: Rolling timestamp trigger did not produce "
+                                        @"any future occurrences."];
+    }
+    return NO;
+  }
+
+  NSMutableOrderedSet<NSString *> *identifiersToRemove = [NSMutableOrderedSet orderedSet];
+  for (NSString *identifier in rollingPendingIdentifiers) {
+    if (![desiredIdentifiers containsObject:identifier]) {
+      [identifiersToRemove addObject:identifier];
+    }
+  }
+  [identifiersToRemove unionOrderedSet:replacementPendingIdentifiers];
+
+  NSMutableArray<UNNotificationRequest *> *removedRequests = [NSMutableArray array];
+  for (NSString *identifier in identifiersToRemove) {
+    UNNotificationRequest *request = pendingRequestByIdentifier[identifier];
+    if (request != nil) {
+      [removedRequests addObject:request];
+    }
+  }
+
+  NSMutableArray<UNNotificationRequest *> *requestsToSchedule = [NSMutableArray array];
+  NSMutableSet<NSString *> *newRequestIdentifiers = [NSMutableSet set];
+  for (NSMutableDictionary *state in states) {
+    NSString *publicId = state[@"publicId"];
+    NSOrderedSet<NSString *> *stateDesiredIds = state[@"desiredIds"];
+    NSDictionary<NSString *, UNNotificationRequest *> *desiredRequests = state[@"desiredRequests"];
+    BOOL shouldRefresh = refreshPublicId != nil && [publicId isEqualToString:refreshPublicId];
+
+    for (NSString *identifier in stateDesiredIds) {
+      UNNotificationRequest *request = desiredRequests[identifier];
+      if (request == nil) {
+        continue;
+      }
+
+      BOOL isAlreadyPending = [pendingIdentifierSet containsObject:identifier];
+      if (!isAlreadyPending || shouldRefresh) {
+        [requestsToSchedule addObject:request];
+      }
+      if (!isAlreadyPending) {
+        [newRequestIdentifiers addObject:identifier];
+      }
+    }
+  }
+
+  [self removeRollingPendingRequestsForIds:[identifiersToRemove array] center:center];
+
+  NSMutableSet<NSString *> *successfulScheduledIdentifiers = [NSMutableSet set];
+  NSError *scheduleError =
+      [self scheduleRollingNotificationRequests:requestsToSchedule
+                                         center:center
+                          successfulIdentifiers:successfulScheduledIdentifiers];
+  if (scheduleError != nil) {
+    NSMutableSet<NSString *> *successfulNewIdentifiers = [NSMutableSet set];
+    for (NSString *identifier in successfulScheduledIdentifiers) {
+      if ([newRequestIdentifiers containsObject:identifier]) {
+        [successfulNewIdentifiers addObject:identifier];
+      }
+    }
+
+    [self rollbackRollingRebalanceRemovedRequests:removedRequests
+                         successfulNewIdentifiers:successfulNewIdentifiers
+                                           center:center];
+    if (error != nil) {
+      *error = scheduleError;
+    }
+    return NO;
+  }
+
+  [NotifeeCoreUtil setRollingTimestampTriggers:updatedRecords];
+  NSDictionary *persistedRecords = [NotifeeCoreUtil getRollingTimestampTriggers];
+  if (![self persistedRollingRecords:persistedRecords matchUpdatedRecords:updatedRecords]) {
+    NSMutableSet<NSString *> *successfulNewIdentifiers = [NSMutableSet set];
+    for (NSString *identifier in successfulScheduledIdentifiers) {
+      if ([newRequestIdentifiers containsObject:identifier]) {
+        [successfulNewIdentifiers addObject:identifier];
+      }
+    }
+    [self removeRollingPendingRequestsForIds:[successfulNewIdentifiers allObjects] center:center];
+
+    if (error != nil) {
+      *error = [self
+          rollingTimestampErrorWithCode:NotifeeCoreRollingErrorCodeStorageFailed
+                                message:@"NotifeeCore: Failed to persist rolling timestamp "
+                                        @"trigger records after rebalance."];
+    }
+    return NO;
+  }
+
+  return YES;
+}
+
++ (void)topUpRollingTimestampTriggersWithCompletion:(void (^)(NSError *error))completion {
+  dispatch_async([self rollingTimestampQueue], ^{
+    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+    NSNumber *nowMs = [self currentTimestampMs];
+    NSArray<UNNotificationRequest *> *pendingRequests = [self pendingNotificationRequests:center];
+    NSMutableDictionary *records = [NotifeeCoreUtil getRollingTimestampTriggers];
+    NSError *topUpError = nil;
+
+    [self rebalanceRollingTimestampTriggerRecords:records
+                                           center:center
+                                  pendingRequests:pendingRequests
+                                            nowMs:nowMs
+                                  refreshPublicId:nil
+                                 requiredPublicId:nil
+                                            error:&topUpError];
+
+    if (completion != nil) {
+      dispatch_async(dispatch_get_main_queue(), ^{
+        completion(topUpError);
+      });
+    }
+  });
+}
+
++ (void)createRollingTriggerNotification:(NSDictionary *)notification
+                             withTrigger:(NSDictionary *)trigger
+                  withNotificationDetail:(NSDictionary *)notificationDetail
+                                  center:(UNUserNotificationCenter *)center
+                                   block:(notifeeMethodVoidBlock)block {
+  dispatch_async([self rollingTimestampQueue], ^{
+    NSString *publicId = [self rollingPublicIdForNotification:notification];
+    if (publicId == nil) {
+      NSError *error = [self
+          rollingTimestampErrorWithCode:NotifeeCoreRollingErrorCodeInvalidTrigger
+                                message:@"NotifeeCore: Rolling timestamp trigger requires a "
+                                        @"notification id."];
+      [self resolveBlock:block withError:error];
+      return;
+    }
+
+    NSArray<UNNotificationRequest *> *pendingRequests = [self pendingNotificationRequests:center];
+    NSMutableDictionary *records = [NotifeeCoreUtil getRollingTimestampTriggers];
+    NSNumber *nowMs = [self currentTimestampMs];
+    NSDictionary *record = @{
+      @"publicId" : publicId,
+      @"notification" : notification,
+      @"trigger" : trigger,
+      @"scheduledIds" : @[],
+      @"createdAtMs" : nowMs
+    };
+    records[publicId] = record;
+
+    NSError *rebalanceError = nil;
+    if (![self rebalanceRollingTimestampTriggerRecords:records
+                                                center:center
+                                       pendingRequests:pendingRequests
+                                                 nowMs:nowMs
+                                       refreshPublicId:publicId
+                                      requiredPublicId:publicId
+                                                 error:&rebalanceError]) {
+      [self resolveBlock:block withError:rebalanceError];
+      return;
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [[NotifeeCoreDelegateHolder instance] didReceiveNotifeeCoreEvent:@{
+        @"type" : @(NotifeeCoreEventTypeTriggerNotificationCreated),
+        @"detail" : @{
+          @"notification" : notificationDetail,
+        }
+      }];
+      block(nil);
+    });
+  });
+}
+
++ (void)cancelRollingNotification:(NSString *)notificationId
+             withNotificationType:(NSInteger)notificationType
+                            block:(notifeeMethodVoidBlock)block {
+  UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+  BOOL cancelDisplayed = notificationType == NotifeeCoreNotificationTypeDisplayed ||
+                         notificationType == NotifeeCoreNotificationTypeAll;
+  BOOL cancelTrigger = notificationType == NotifeeCoreNotificationTypeTrigger ||
+                       notificationType == NotifeeCoreNotificationTypeAll;
+
+  if (!cancelDisplayed && !cancelTrigger) {
+    block(nil);
+    return;
+  }
+
+  dispatch_async([self rollingTimestampQueue], ^{
+    NSDictionary *records = [NotifeeCoreUtil getRollingTimestampTriggers];
+    NSDictionary *record = records[notificationId];
+
+    if (cancelDisplayed) {
+      NSArray<UNNotification *> *deliveredNotifications = [self deliveredNotifications:center];
+      NSMutableOrderedSet<NSString *> *deliveredIdentifiersToRemove =
+          [self rollingDeliveredIdentifiersForPublicId:notificationId
+                               deliveredNotifications:deliveredNotifications
+                                               record:record];
+      [self addString:notificationId toOrderedSet:deliveredIdentifiersToRemove];
+      if ([deliveredIdentifiersToRemove count] > 0) {
+        [center removeDeliveredNotificationsWithIdentifiers:[deliveredIdentifiersToRemove array]];
+      }
+    }
+
+    if (cancelTrigger) {
+      NSArray<UNNotificationRequest *> *pendingRequests = [self pendingNotificationRequests:center];
+      NSMutableOrderedSet<NSString *> *pendingIdentifiersToRemove =
+          [self rollingIdentifiersForPublicId:notificationId
+                              pendingRequests:pendingRequests
+                                       record:record];
+      [self addString:notificationId toOrderedSet:pendingIdentifiersToRemove];
+
+      [self removeRollingPendingRequestsForIds:[pendingIdentifiersToRemove array] center:center];
+      if (record != nil) {
+        [NotifeeCoreUtil removeRollingTimestampTriggerRecordForPublicId:notificationId];
+      }
+    }
+
+    [self resolveBlock:block withError:nil];
+  });
+}
+
++ (void)cancelRollingNotificationsWithIds:(NSArray<NSString *> *)ids
+                     withNotificationType:(NSInteger)notificationType
+                                    block:(notifeeMethodVoidBlock)block {
+  UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+  BOOL cancelDisplayed = notificationType == NotifeeCoreNotificationTypeDisplayed ||
+                         notificationType == NotifeeCoreNotificationTypeAll;
+  BOOL cancelTrigger = notificationType == NotifeeCoreNotificationTypeTrigger ||
+                       notificationType == NotifeeCoreNotificationTypeAll;
+
+  NSMutableOrderedSet<NSString *> *publicIds = [NSMutableOrderedSet orderedSet];
+  for (id notificationId in ids) {
+    [self addString:notificationId toOrderedSet:publicIds];
+  }
+
+  if (!cancelDisplayed && !cancelTrigger) {
+    block(nil);
+    return;
+  }
+
+  dispatch_async([self rollingTimestampQueue], ^{
+    NSDictionary *records = [NotifeeCoreUtil getRollingTimestampTriggers];
+    NSArray<UNNotification *> *deliveredNotifications =
+        cancelDisplayed ? [self deliveredNotifications:center] : @[];
+    NSArray<UNNotificationRequest *> *pendingRequests =
+        cancelTrigger ? [self pendingNotificationRequests:center] : @[];
+    NSMutableOrderedSet<NSString *> *deliveredIdentifiersToRemove =
+        [NSMutableOrderedSet orderedSet];
+    NSMutableOrderedSet<NSString *> *pendingIdentifiersToRemove =
+        [NSMutableOrderedSet orderedSet];
+
+    for (NSString *publicId in publicIds) {
+      NSDictionary *record = records[publicId];
+
+      if (cancelDisplayed) {
+        NSMutableOrderedSet<NSString *> *rollingDeliveredIdentifiers =
+            [self rollingDeliveredIdentifiersForPublicId:publicId
+                                 deliveredNotifications:deliveredNotifications
+                                                 record:record];
+        [deliveredIdentifiersToRemove unionOrderedSet:rollingDeliveredIdentifiers];
+        [self addString:publicId toOrderedSet:deliveredIdentifiersToRemove];
+      }
+
+      if (cancelTrigger) {
+        NSMutableOrderedSet<NSString *> *rollingPendingIdentifiers =
+            [self rollingIdentifiersForPublicId:publicId
+                                pendingRequests:pendingRequests
+                                         record:record];
+        [pendingIdentifiersToRemove unionOrderedSet:rollingPendingIdentifiers];
+        [self addString:publicId toOrderedSet:pendingIdentifiersToRemove];
+        if (record != nil) {
+          [NotifeeCoreUtil removeRollingTimestampTriggerRecordForPublicId:publicId];
+        }
+      }
+    }
+
+    if ([deliveredIdentifiersToRemove count] > 0) {
+      [center removeDeliveredNotificationsWithIdentifiers:[deliveredIdentifiersToRemove array]];
+    }
+    [self removeRollingPendingRequestsForIds:[pendingIdentifiersToRemove array] center:center];
+    [self resolveBlock:block withError:nil];
+  });
+}
+
 #pragma mark - Library Methods
 
 + (void)setCoreDelegate:(id<NotifeeCoreDelegate>)coreDelegate {
@@ -42,17 +985,9 @@
 + (void)cancelNotification:(NSString *)notificationId
       withNotificationType:(NSInteger)notificationType
                  withBlock:(notifeeMethodVoidBlock)block {
-  UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
-  // cancel displayed notification
-  if (notificationType == NotifeeCoreNotificationTypeDisplayed ||
-      notificationType == NotifeeCoreNotificationTypeAll)
-    [center removeDeliveredNotificationsWithIdentifiers:@[ notificationId ]];
-
-  // cancel trigger notification
-  if (notificationType == NotifeeCoreNotificationTypeTrigger ||
-      notificationType == NotifeeCoreNotificationTypeAll)
-    [center removePendingNotificationRequestsWithIdentifiers:@[ notificationId ]];
-  block(nil);
+  [self cancelRollingNotification:notificationId
+             withNotificationType:notificationType
+                            block:block];
 }
 
 /**
@@ -69,11 +1004,17 @@
       notificationType == NotifeeCoreNotificationTypeAll)
     [center removeAllDeliveredNotifications];
 
-  // cancel trigger notifications
-  if (notificationType == NotifeeCoreNotificationTypeTrigger ||
-      notificationType == NotifeeCoreNotificationTypeAll)
+  if (notificationType != NotifeeCoreNotificationTypeTrigger &&
+      notificationType != NotifeeCoreNotificationTypeAll) {
+    block(nil);
+    return;
+  }
+
+  dispatch_async([self rollingTimestampQueue], ^{
     [center removeAllPendingNotificationRequests];
-  block(nil);
+    [NotifeeCoreUtil clearRollingTimestampTriggerRecords];
+    [self resolveBlock:block withError:nil];
+  });
 }
 
 /**
@@ -86,18 +1027,7 @@
 + (void)cancelAllNotificationsWithIds:(NSInteger)notificationType
                               withIds:(NSArray<NSString *> *)ids
                             withBlock:(notifeeMethodVoidBlock)block {
-  UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
-
-  // cancel displayed notifications
-  if (notificationType == NotifeeCoreNotificationTypeDisplayed ||
-      notificationType == NotifeeCoreNotificationTypeAll)
-    [center removeDeliveredNotificationsWithIdentifiers:ids];
-
-  // cancel trigger notifications
-  if (notificationType == NotifeeCoreNotificationTypeTrigger ||
-      notificationType == NotifeeCoreNotificationTypeAll)
-    [center removePendingNotificationRequestsWithIdentifiers:ids];
-  block(nil);
+  [self cancelRollingNotificationsWithIds:ids withNotificationType:notificationType block:block];
 }
 
 + (void)getDisplayedNotifications:(notifeeMethodNSArrayBlock)block {
@@ -106,20 +1036,33 @@
   [center getDeliveredNotificationsWithCompletionHandler:^(
               NSArray<UNNotification *> *_Nonnull deliveredNotifications) {
     for (UNNotification *deliveredNotification in deliveredNotifications) {
+      UNNotificationRequest *request = deliveredNotification.request;
+      NSString *notificationId = [self publicIdentifierForRequest:request];
+      if (notificationId == nil) {
+        continue;
+      }
+
       NSMutableDictionary *triggerNotification = [NSMutableDictionary dictionary];
-      triggerNotification[@"id"] = deliveredNotification.request.identifier;
+      triggerNotification[@"id"] = notificationId;
 
       triggerNotification[@"date"] =
           [NotifeeCoreUtil convertToTimestamp:deliveredNotification.date];
       triggerNotification[@"notification"] =
-          deliveredNotification.request.content.userInfo[kNotifeeUserInfoNotification];
+          request.content.userInfo[kNotifeeUserInfoNotification];
       triggerNotification[@"trigger"] =
-          deliveredNotification.request.content.userInfo[kNotifeeUserInfoTrigger];
+          request.content.userInfo[kNotifeeUserInfoTrigger];
 
       if (triggerNotification[@"notification"] == nil) {
         // parse remote notification
-        triggerNotification[@"notification"] =
-            [NotifeeCoreUtil parseUNNotificationRequest:deliveredNotification.request];
+        triggerNotification[@"notification"] = [NotifeeCoreUtil parseUNNotificationRequest:request];
+      }
+
+      NSString *rollingPublicId = [self rollingPublicIdForRequest:request];
+      NSDictionary *notification = triggerNotification[@"notification"];
+      if (rollingPublicId != nil && [notification isKindOfClass:NSDictionary.class]) {
+        NSMutableDictionary *publicNotification = [notification mutableCopy];
+        publicNotification[@"id"] = rollingPublicId;
+        triggerNotification[@"notification"] = publicNotification;
       }
 
       [triggerNotifications addObject:triggerNotification];
@@ -133,9 +1076,41 @@
 
   [center getPendingNotificationRequestsWithCompletionHandler:^(
               NSArray<UNNotificationRequest *> *_Nonnull requests) {
+    NSDictionary *rollingRecords = [NotifeeCoreUtil getRollingTimestampTriggers];
+    NSMutableSet<NSString *> *rollingPublicIds = [NSMutableSet set];
     NSMutableArray *triggerNotifications = [[NSMutableArray alloc] init];
 
+    for (id publicId in rollingRecords) {
+      if (![publicId isKindOfClass:NSString.class]) {
+        continue;
+      }
+
+      NSDictionary *record = rollingRecords[publicId];
+      NSDictionary *notification = record[@"notification"];
+      NSDictionary *trigger = record[@"trigger"];
+      if (![notification isKindOfClass:NSDictionary.class] ||
+          ![trigger isKindOfClass:NSDictionary.class]) {
+        continue;
+      }
+
+      NSMutableDictionary *triggerNotification = [NSMutableDictionary dictionary];
+      triggerNotification[@"notification"] = notification;
+      triggerNotification[@"trigger"] = trigger;
+      [triggerNotifications addObject:triggerNotification];
+      [rollingPublicIds addObject:publicId];
+    }
+
     for (UNNotificationRequest *request in requests) {
+      NSString *rollingPublicId =
+          [NotifeeCoreUtil rollingPublicIdFromInternalNotificationId:request.identifier];
+      if (rollingPublicId != nil) {
+        continue;
+      }
+
+      if ([rollingPublicIds containsObject:request.identifier]) {
+        continue;
+      }
+
       NSMutableDictionary *triggerNotification = [NSMutableDictionary dictionary];
 
       triggerNotification[@"notification"] = request.content.userInfo[kNotifeeUserInfoNotification];
@@ -158,14 +1133,22 @@
   UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
   [center getPendingNotificationRequestsWithCompletionHandler:^(
               NSArray<UNNotificationRequest *> *_Nonnull requests) {
-    NSMutableArray<NSString *> *idsArray = [[NSMutableArray alloc] init];
+    NSMutableOrderedSet<NSString *> *ids = [NSMutableOrderedSet orderedSet];
 
     for (UNNotificationRequest *request in requests) {
       NSString *notificationId = request.identifier;
-      [idsArray addObject:notificationId];
+      NSString *rollingPublicId =
+          [NotifeeCoreUtil rollingPublicIdFromInternalNotificationId:notificationId];
+      [self addString:(rollingPublicId != nil ? rollingPublicId : notificationId)
+          toOrderedSet:ids];
     }
 
-    block(nil, idsArray);
+    NSDictionary *rollingRecords = [NotifeeCoreUtil getRollingTimestampTriggers];
+    for (id publicId in rollingRecords) {
+      [self addString:publicId toOrderedSet:ids];
+    }
+
+    block(nil, [ids array]);
   }];
 }
 
@@ -253,47 +1236,29 @@
                       withTrigger:(NSDictionary *)trigger
                         withBlock:(notifeeMethodVoidBlock)block {
   dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-    UNMutableNotificationContent *content = [self buildNotificationContent:notification
-                                                               withTrigger:trigger];
-    UNNotificationTrigger *unTrigger = [NotifeeCoreUtil triggerFromDictionary:trigger];
-
-    if (unTrigger == nil) {
-      // do nothing if trigger is null
-      return dispatch_async(dispatch_get_main_queue(), ^{
-        block(nil);
-      });
-    }
-
+    UNMutableNotificationContent *content = [self triggerNotificationContentForNotification:notification
+                                                                                    trigger:trigger];
     UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
 
     NSMutableDictionary *notificationDetail = [notification mutableCopy];
     notificationDetail[@"remote"] = @NO;
 
-    if (@available(iOS 15.0, *)) {
-      if (notification[@"ios"][@"communicationInfo"] != nil) {
-        INSendMessageIntent *intent = [NotifeeCoreUtil
-            generateSenderIntentForCommunicationNotification:notification[@"ios"]
-                                                                         [@"communicationInfo"]];
+    if ([NotifeeCoreUtil isRollingTimestampTrigger:trigger]) {
+      [self createRollingTriggerNotification:notification
+                                 withTrigger:trigger
+                      withNotificationDetail:notificationDetail
+                                      center:center
+                                       block:block];
+      return;
+    }
 
-        // Use the intent to initialize the interaction.
-        INInteraction *interaction = [[INInteraction alloc] initWithIntent:intent response:nil];
-        interaction.direction = INInteractionDirectionIncoming;
-        [interaction donateInteractionWithCompletion:^(NSError *donateError) {
-          if (donateError)
-            NSLog(@"NotifeeCore: Could not donate interaction for communication notification: %@",
-                  donateError);
-        }];
+    UNNotificationTrigger *unTrigger = [NotifeeCoreUtil triggerFromDictionary:trigger];
 
-        NSError *contentUpdateError = nil;
-        UNNotificationContent *updatedContent =
-            [content contentByUpdatingWithProvider:intent error:&contentUpdateError];
-        if (contentUpdateError) {
-          NSLog(@"NotifeeCore: Could not update notification content with communication intent: %@",
-                contentUpdateError);
-        } else if (updatedContent != nil) {
-          content = [updatedContent mutableCopy];
-        }
-      }
+    if (unTrigger == nil) {
+      // do nothing if trigger is null
+      return dispatch_async(dispatch_get_main_queue(), ^{
+        block(nil);
+      });
     }
 
     UNNotificationRequest *request =
@@ -447,18 +1412,6 @@
     content.threadIdentifier = iosDict[@"threadId"];
   }
 
-  if (@available(iOS 12.0, *)) {
-    // summaryArgument
-    if (iosDict[@"summaryArgument"] != nil) {
-      content.summaryArgument = iosDict[@"summaryArgument"];
-    }
-
-    // summaryArgumentCount
-    if (iosDict[@"summaryArgumentCount"] != nil) {
-      content.summaryArgumentCount = [iosDict[@"summaryArgumentCount"] unsignedIntValue];
-    }
-  }
-
   if (@available(iOS 13.0, *)) {
     // targetContentId
     if (iosDict[@"targetContentId"] != nil) {
@@ -512,12 +1465,7 @@
         }
       }
 
-      if (@available(iOS 13.0, *)) {
-        categoryDictionary[@"allowAnnouncement"] = @(
-            ((notificationCategory.options & UNNotificationCategoryOptionAllowAnnouncement) != 0));
-      } else {
-        categoryDictionary[@"allowAnnouncement"] = @(NO);
-      }
+      categoryDictionary[@"allowAnnouncement"] = @(NO);
 
       categoryDictionary[@"actions"] =
           [NotifeeCoreUtil notificationActionsToDictionaryArray:notificationCategory.actions];
@@ -570,12 +1518,6 @@
       }
     }
 
-    if (@available(iOS 13.0, *)) {
-      if ([categoryDictionary[@"allowAnnouncement"] isEqual:@(YES)]) {
-        options |= UNNotificationCategoryOptionAllowAnnouncement;
-      }
-    }
-
     if (@available(iOS 12.0, *)) {
       category = [UNNotificationCategory categoryWithIdentifier:id
                                                         actions:actions
@@ -641,12 +1583,6 @@
     }
   }
 
-  if ([permissions[@"announcement"] isEqual:@(YES)]) {
-    if (@available(iOS 13.0, *)) {
-      options |= UNAuthorizationOptionAnnouncement;
-    }
-  }
-
   if ([permissions[@"carPlay"] isEqual:@(YES)]) {
     options |= UNAuthorizationOptionCarPlay;
   }