@ammarahmed/notifee-react-native 7.3.0

package/ios/NotifeeCore/NotifeeCoreDelegateHolder.h

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import <Foundation/Foundation.h>
+#import "NotifeeCore.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface NotifeeCoreDelegateHolder : NSObject
+
+@property(nonatomic, weak) id<NotifeeCoreDelegate> delegate;
+@property(atomic, strong) NSMutableArray<NSDictionary *> *pendingEvents;
+
++ (instancetype)instance;
+
+- (void)didReceiveNotifeeCoreEvent:(NSDictionary *)event;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NotifeeCore/NotifeeCoreDelegateHolder.m

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import "NotifeeCoreDelegateHolder.h"
+
+@implementation NotifeeCoreDelegateHolder {
+  struct {
+    unsigned int didReceiveNotificationEvent : 1;
+  } delegateRespondsTo;
+}
+
+@synthesize delegate;
+
++ (instancetype)instance {
+  static dispatch_once_t once;
+  __strong static NotifeeCoreDelegateHolder *sharedInstance;
+  dispatch_once(&once, ^{
+    sharedInstance = [[NotifeeCoreDelegateHolder alloc] init];
+    sharedInstance.pendingEvents = [[NSMutableArray alloc] init];
+  });
+  return sharedInstance;
+}
+
+- (void)setDelegate:(id<NotifeeCoreDelegate>)aDelegate {
+  if (delegate != aDelegate) {
+    delegate = aDelegate;
+    self->delegateRespondsTo.didReceiveNotificationEvent =
+        (unsigned int)[delegate respondsToSelector:@selector(didReceiveNotifeeCoreEvent:)];
+    if (_pendingEvents.count > 0) {
+      // make sure events are only processed once the module that wraps core has
+      // set its delegate
+      static dispatch_once_t once;
+      // TODO temp workaround to delay initial start until RN module can queue
+      // events
+      dispatch_once(&once, ^{
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)),
+                       dispatch_get_main_queue(), ^{
+                         for (NSDictionary *event in self->_pendingEvents) {
+                           [self didReceiveNotifeeCoreEvent:event];
+                         }
+                         self->_pendingEvents = [[NSMutableArray alloc] init];
+                       });
+      });
+    }
+  }
+}
+
+- (void)didReceiveNotifeeCoreEvent:(NSDictionary *)notificationEvent {
+  if (self->delegateRespondsTo.didReceiveNotificationEvent) {
+    [self->delegate didReceiveNotifeeCoreEvent:notificationEvent];
+  } else {
+    [self->_pendingEvents addObject:notificationEvent];
+  }
+}
+
+@end

package/ios/NotifeeCore/NotifeeCoreDownloadDelegate.h

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+#define MAX_DOWNLOAD_ATTACHMENT_SIZE 50000000
+
+@interface NotifeeCoreDownloadDelegate : NSObject <NSURLSessionDataDelegate> {
+  NSError *error;
+  NSURLResponse *response;
+  BOOL done;
+  NSFileHandle *outputHandle;
+}
+
+@property(readonly, getter=isDone) BOOL done;
+@property(readonly) NSError *error;
+@property(readonly) NSURLResponse *response;
+
+- (id)initWithFilePath:(NSString *)path;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NotifeeCore/NotifeeCoreDownloadDelegate.m

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import "NotifeeCoreDownloadDelegate.h"
+
+@implementation NotifeeCoreDownloadDelegate
+@synthesize error, response, done;
+
+- (void)URLSession:(NSURLSession *)session
+          dataTask:(NSURLSessionDataTask *)dataTask
+    didReceiveData:(NSData *)data {
+  [outputHandle writeData:data];
+}
+
+- (void)URLSession:(NSURLSession *)session
+              dataTask:(NSURLSessionDataTask *)dataTask
+    didReceiveResponse:(NSURLResponse *)aResponse
+     completionHandler:(void (^)(NSURLSessionResponseDisposition))completionHandler {
+  response = aResponse;
+  long long expectedLength = response.expectedContentLength;
+  if (expectedLength > MAX_DOWNLOAD_ATTACHMENT_SIZE) {  // Cancel download task if attachment is
+                                                        // more than allowed
+    completionHandler(NSURLSessionResponseCancel);
+    return;
+  }
+  completionHandler(NSURLSessionResponseAllow);
+}
+
+- (void)URLSession:(NSURLSession *)session didBecomeInvalidWithError:(NSError *)anError {
+  error = anError;
+  done = YES;
+
+  [outputHandle closeFile];
+}
+
+- (void)URLSession:(NSURLSession *)session
+                    task:(NSURLSessionTask *)task
+    didCompleteWithError:(NSError *)anError {
+  done = YES;
+  error = anError;
+  [outputHandle closeFile];
+}
+
+- (id)initWithFilePath:(NSString *)path {
+  if (self = [super init]) {
+    if ([[NSFileManager defaultManager] fileExistsAtPath:path])
+      [[NSFileManager defaultManager] removeItemAtPath:path error:nil];
+
+    [[NSFileManager defaultManager] createFileAtPath:path contents:nil attributes:nil];
+    outputHandle = [NSFileHandle fileHandleForWritingAtPath:path];
+  }
+  return self;
+}
+@end

package/ios/NotifeeCore/NotifeeCoreExtensionHelper.h

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import <Foundation/Foundation.h>
+#import <UserNotifications/UserNotifications.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+static NSString *const kPayloadOptionsName = @"notifee_options";
+static NSString *const kPayloadOptionsImageURLName = @"image";
+
+@interface NotifeeCoreExtensionHelper : NSObject
+@property(nonatomic, strong) void (^contentHandler)(UNNotificationContent *c);
+@property(nonatomic, strong) UNMutableNotificationContent *modifiedContent;
+
++ (NotifeeCoreExtensionHelper *)instance NS_SWIFT_NAME(serviceExtension());
+
+- (void)populateNotificationContent:(UNNotificationRequest *_Nullable)request
+                        withContent:(UNMutableNotificationContent *)content
+                 withContentHandler:(void (^)(UNNotificationContent *_Nonnull))contentHandler;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NotifeeCore/NotifeeCoreExtensionHelper.m

@@ -0,0 +1,224 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import "NotifeeCoreExtensionHelper.h"
+#import "Intents/Intents.h"
+#import "NotifeeCore.h"
+#import "NotifeeCoreUtil.h"
+
+static NSString *const kNoExtension = @"";
+static NSString *const kImagePathPrefix = @"image/";
+
+@implementation NotifeeCoreExtensionHelper
++ (NotifeeCoreExtensionHelper *)instance {
+  static dispatch_once_t once;
+  static NotifeeCoreExtensionHelper *instance;
+  dispatch_once(&once, ^{
+    instance = [[self alloc] init];
+  });
+
+  return instance;
+}
+
+- (void)populateNotificationContent:(UNNotificationRequest *_Nullable)request
+                        withContent:(UNMutableNotificationContent *)content
+                 withContentHandler:(void (^)(UNNotificationContent *_Nonnull))contentHandler {
+  self.contentHandler = [contentHandler copy];
+  self.modifiedContent = content;
+
+  if (!content.userInfo[@"notifee_options"]) {
+    [self deliverNotification];
+    return;
+  }
+
+  // fcm: apns: { payload: {notifee_options: {} } }
+  NSMutableDictionary *options = [self.modifiedContent.userInfo[@"notifee_options"] mutableCopy];
+
+  options[@"remote"] = @YES;
+
+  // Convert options to Notification and set defaults
+  if (options[@"data"] == nil) {
+    options[@"data"] = [NSDictionary dictionary];
+  }
+
+  // Pass id to event handler
+  if (request != nil && options[@"id"] == nil) {
+    options[@"id"] = request.identifier;
+  }
+
+  if (options[@"title"] == nil && content.title != nil) {
+    options[@"title"] = self.modifiedContent.title;
+  }
+
+  if (options[@"body"] == nil) {
+    options[@"body"] = self.modifiedContent.body;
+  }
+
+  self.modifiedContent = [NotifeeCore buildNotificationContent:options withTrigger:nil];
+  [self processCommunicationData:options];
+}
+
+- (void)processCommunicationData:(NSMutableDictionary *)options {
+  if (options[@"ios"] == nil || options[@"ios"][@"communicationInfo"] == nil) {
+    [self handleAttachmentsAndDeliverNotificaiton:options];
+    return;
+  }
+
+  if (@available(iOS 15.0, *)) {
+    NSMutableDictionary *communicationInfo = [options[@"ios"][@"communicationInfo"] mutableCopy];
+    communicationInfo[@"body"] = options[@"body"];
+    INSendMessageIntent *intent = [NotifeeCoreUtil
+        generateSenderIntentForCommunicationNotifciation:options[@"ios"][@"communicationInfo"]];
+    // Use the intent to initialize the interaction.
+    INInteraction *interaction = [[INInteraction alloc] initWithIntent:intent response:nil];
+    interaction.direction = INInteractionDirectionIncoming;
+
+    NSError *error = nil;
+    UNNotificationContent *updatedContent =
+        [self.modifiedContent contentByUpdatingWithProvider:intent error:&error];
+    if (error) {
+      NSLog(@"NotifeeCoreExtensionHelper: Could not update notification content: %@", error);
+      [self handleAttachmentsAndDeliverNotificaiton:options];
+      return;
+    }
+
+    NSLog(@"NotifeeCoreExtensionHelper: Processing communication notification");
+    self.modifiedContent = [updatedContent mutableCopy];
+    [self handleAttachmentsAndDeliverNotificaiton:options];
+
+    [interaction donateInteractionWithCompletion:^(NSError *error) {
+      if (error)
+        NSLog(@"NotifeeCoreExtensionHelper: Could not donate interaction for communication "
+              @"notification: %@",
+              error);
+    }];
+  } else {
+    // Skip, Communication notifications not supported on iOS 15
+    [self handleAttachmentsAndDeliverNotificaiton:options];
+  }
+}
+
+- (void)handleAttachmentsAndDeliverNotificaiton:(NSMutableDictionary *)options {
+  NSMutableDictionary *attachmentDict = [NSMutableDictionary new];
+
+  if (options[@"ios"] != nil && options[@"ios"][@"attachments"] != nil &&
+      [options[@"ios"][@"attachments"] isKindOfClass:[NSArray class]] &&
+      [options[@"ios"][@"attachments"] count] != 0) {
+    attachmentDict = options[@"ios"][@"attachments"][0];
+  }
+
+  // Check if image url is in payload and parse it if attachmentDict is empty
+  NSString *currentImageURL = options[kPayloadOptionsImageURLName];
+  if ([attachmentDict count] == 0 && ![currentImageURL isEqual:[NSNull null]] &&
+      currentImageURL.length > 1) {
+    // make into an attachment dict
+    attachmentDict[@"url"] = currentImageURL;
+  }
+
+  if ([attachmentDict count] == 0) {
+    [self deliverNotification];
+    return;
+  }
+
+  // Attempt to download attachment
+  [self loadAttachment:attachmentDict
+      completionHandler:^(UNNotificationAttachment *attachment) {
+        if (attachment != nil) {
+          self.modifiedContent.attachments = @[ attachment ];
+        }
+
+        [self deliverNotification];
+      }];
+}
+
+- (NSString *)fileExtensionForResponse:(NSURLResponse *)response {
+  NSString *suggestedPathExtension = [response.suggestedFilename pathExtension];
+  if (suggestedPathExtension.length > 0) {
+    return [NSString stringWithFormat:@".%@", suggestedPathExtension];
+  }
+  if ([response.MIMEType containsString:kImagePathPrefix]) {
+    return [response.MIMEType stringByReplacingOccurrencesOfString:kImagePathPrefix
+                                                        withString:@"."];
+  }
+  return kNoExtension;
+}
+
+- (void)loadAttachment:(NSDictionary *)attachmentDict
+     completionHandler:(void (^)(UNNotificationAttachment *))completionHandler {
+  @try {
+    __block UNNotificationAttachment *attachment = nil;
+    NSString *attachmentIdentifier = attachmentDict[@"id"];
+    NSURL *attachmentURL = [NSURL URLWithString:attachmentDict[@"url"]];
+
+    NSURLSession *session = [NSURLSession
+        sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration]];
+    [[session
+        downloadTaskWithURL:attachmentURL
+          completionHandler:^(NSURL *temporaryFileLocation, NSURLResponse *response,
+                              NSError *error) {
+            if (error != nil) {
+              NSLog(
+                  @"NotifeeCoreExtensionHelper: An exception occurred while attempting to download "
+                  @"image with URL %@: "
+                  @"%@",
+                  attachmentURL, error);
+              completionHandler(attachment);
+              return;
+            }
+
+            NSFileManager *fileManager = [NSFileManager defaultManager];
+            NSString *fileExtension = [self fileExtensionForResponse:response];
+            NSURL *localURL = [NSURL
+                fileURLWithPath:[temporaryFileLocation.path stringByAppendingString:fileExtension]];
+            [fileManager moveItemAtURL:temporaryFileLocation toURL:localURL error:&error];
+            if (error) {
+              NSLog(@"NotifeeCoreExtensionHelper: Failed to move the image file to local location: "
+                    @"%@, error %@",
+                    localURL, error);
+              completionHandler(attachment);
+              return;
+            }
+
+            attachment = [UNNotificationAttachment
+                attachmentWithIdentifier:attachmentIdentifier
+                                     URL:localURL
+                                 options:[NotifeeCoreUtil
+                                             attachmentOptionsFromDictionary:attachmentDict]
+                                   error:&error];
+            if (error) {
+              NSLog(
+                  @"NotifeeCoreExtensionHelper: Failed to create attachment with URL: %@, error %@",
+                  localURL, error);
+              completionHandler(attachment);
+              return;
+            }
+            completionHandler(attachment);
+          }] resume];
+  } @catch (NSException *exception) {
+    NSLog(@"NotifeeCoreExtensionHelper: Failed to create attachment: %@, error %@", attachmentDict,
+          exception.reason);
+    completionHandler(nil);
+  }
+}
+
+- (void)deliverNotification {
+  if (self.contentHandler) {
+    self.contentHandler(self.modifiedContent);
+  }
+}
+
+@end

package/ios/NotifeeCore/NotifeeCoreUtil.h

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import <Foundation/Foundation.h>
+
+#import <UserNotifications/UserNotifications.h>
+#import "Intents/Intents.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+static NSString *kNotifeeUserInfoNotification = @"__notifee_notification";
+static NSString *kNotifeeUserInfoTrigger = @"__notifee_trigger";
+
+// TimeUnit constants for IntervalTrigger
+static NSString *kNotifeeCoreTimeUnitSeconds = @"SECONDS";
+static NSString *kNotifeeCoreTimeUnitMinutes = @"MINUTES";
+static NSString *kNotifeeCoreTimeUnitHours = @"HOURS";
+static NSString *kNotifeeCoreTimeUnitDays = @"DAYS";
+
+// Enum representing trigger notification types
+typedef NS_ENUM(NSInteger, NotifeeCoreTriggerType) {
+  NotifeeCoreTriggerTypeTimestamp = 0,
+  NotifeeCoreTriggerTypeInterval = 1
+};
+
+// Enum representing repeat frequency for TimestampTrigger
+typedef NS_ENUM(NSInteger, NotifeeCoreRepeatFrequency) {
+  NotifeeCoreRepeatFrequencyHourly = 0,
+  NotifeeCoreRepeatFrequencyDaily = 1,
+  NotifeeCoreRepeatFrequencyWeekly = 2,
+  NotifeeCoreRepeatFrequencyMonthly = 3
+};
+
+@interface NotifeeCoreUtil : NSObject
+
++ (NSNumber *)numberForUNNotificationSetting:(UNNotificationSetting)setting;
+
++ (NSMutableArray<NSDictionary *> *)notificationActionsToDictionaryArray:
+    (NSArray<UNNotificationAction *> *)notificationActions;
+
++ (NSMutableArray<UNNotificationAction *> *)notificationActionsFromDictionaryArray:
+    (NSArray<NSDictionary *> *)actionDictionaries;
+
++ (NSMutableArray<UNNotificationAttachment *> *)notificationAttachmentsFromDictionaryArray:
+    (NSArray<NSDictionary *> *)attachmentDictionaries;
+
++ (NSDictionary *)attachmentOptionsFromDictionary:(NSDictionary *)optionsDict;
+
++ (NSMutableArray<NSNumber *> *)intentIdentifiersFromStringArray:(NSArray<NSString *> *)identifiers;
+
++ (NSMutableArray<NSString *> *)intentIdentifiersFromNumberArray:(NSArray<NSNumber *> *)identifiers;
+
++ (UNNotificationTrigger *)triggerFromDictionary:(NSDictionary *)triggerDict;
+
++ (NSNumber *)convertToTimestamp:(NSDate *)date;
+
++ (NSDictionary *)parseUNNotificationRequest:(UNNotificationRequest *)request;
+
++ (INSendMessageIntent *)generateSenderIntentForCommunicationNotifciation:
+    (NSMutableDictionary *)options;
+
++ (BOOL)isAppExtension;
+
++ (nullable instancetype)notifeeUIApplication;
+
+@end
+
+NS_ASSUME_NONNULL_END