@ammarahmed/notifee-react-native 7.3.0

package/ios/NotifeeCore/NotifeeCore+NSNotificationCenter.m

@@ -0,0 +1,72 @@
+/**
+ * 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 <UIKit/UIKit.h>
+#import "NotifeeCore+NSNotificationCenter.h"
+#import "NotifeeCore+UNUserNotificationCenter.h"
+
+@implementation NotifeeCoreNSNotificationCenter
+
++ (instancetype)instance {
+  static dispatch_once_t once;
+  __strong static NotifeeCoreNSNotificationCenter *sharedInstance;
+  dispatch_once(&once, ^{
+    sharedInstance = [[NotifeeCoreNSNotificationCenter alloc] init];
+  });
+  return sharedInstance;
+}
+
+- (void)observe {
+  static dispatch_once_t once;
+  __weak NotifeeCoreNSNotificationCenter *weakSelf = self;
+  dispatch_once(&once, ^{
+    NotifeeCoreNSNotificationCenter *strongSelf = weakSelf;
+    // Application
+    // ObjC -> Initialize other delegates & observers
+    [[NSNotificationCenter defaultCenter]
+        addObserver:strongSelf
+           selector:@selector(application_onDidFinishLaunchingNotification:)
+               name:UIApplicationDidFinishLaunchingNotification
+             object:nil];
+    [[NSNotificationCenter defaultCenter]
+        addObserver:strongSelf
+           selector:@selector(messaging_didReceiveRemoteNotification:)
+               name:@"RNFBMessagingDidReceiveRemoteNotification"
+             object:nil];
+  });
+}
+
+// start observing immediately on class load - specifically for
+// UIApplicationDidFinishLaunchingNotification
++ (void)load {
+  [[self instance] observe];
+}
+
+#pragma mark -
+#pragma mark Application Notifications
+
+- (void)application_onDidFinishLaunchingNotification:(nonnull NSNotification *)notification {
+  // setup our delegates after app finishes launching
+  // these methods are idempotent so can safely be called multiple times
+  [[NotifeeCoreUNUserNotificationCenter instance] observe];
+}
+
+- (void)messaging_didReceiveRemoteNotification:(nonnull NSNotification *)notification {
+  // update me with logic
+}
+
+@end

package/ios/NotifeeCore/NotifeeCore+NSURLSession.h

@@ -0,0 +1,25 @@
+/**
+ * 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
+@interface NotifeeCoreNSURLSession : NSObject
++ (NSString *)downloadItemAtURL:(NSURL *)url toFile:(NSString *)localPath error:(NSError **)error;
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NotifeeCore/NotifeeCore+NSURLSession.m

@@ -0,0 +1,55 @@
+/**
+ * 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 "NotifeeCore+NSURLSession.h"
+#import "NotifeeCoreDownloadDelegate.h"
+
+@implementation NotifeeCoreNSURLSession
+
++ (NSString *)downloadItemAtURL:(NSURL *)url toFile:(NSString *)localPath error:(NSError **)error {
+  NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:url];
+
+  NotifeeCoreDownloadDelegate *delegate =
+      [[NotifeeCoreDownloadDelegate alloc] initWithFilePath:localPath];
+
+  // The session is created with the defaultSessionConfiguration
+  // default timeoutIntervalForRequest is 60 seconds.
+  NSURLSession *session =
+      [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration]
+                                    delegate:delegate
+                               delegateQueue:nil];
+
+  NSURLSessionDataTask *task = [session dataTaskWithRequest:request];
+
+  [task resume];
+
+  [session finishTasksAndInvalidate];
+
+  while (![delegate isDone]) {
+    [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:1.0]];
+  }
+
+  NSError *delegateError = [delegate error];
+  if (delegateError != nil) {
+    if (error) *error = delegateError;
+    return nil;
+  }
+
+  return delegate.response.suggestedFilename;
+}
+
+@end

package/ios/NotifeeCore/NotifeeCore+UNUserNotificationCenter.h

@@ -0,0 +1,37 @@
+/**
+ * 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
+
+@interface NotifeeCoreUNUserNotificationCenter : NSObject <UNUserNotificationCenterDelegate>
+
+@property(nonatomic, nullable, weak) id<UNUserNotificationCenterDelegate> originalDelegate;
+
+@property(strong, nullable) NSDictionary *initialNotification;
+
++ (_Nonnull instancetype)instance;
+
+- (void)observe;
+
+- (nullable NSDictionary *)getInitialNotification;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/NotifeeCore/NotifeeCore+UNUserNotificationCenter.m

@@ -0,0 +1,242 @@
+/**
+ * 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 "NotifeeCore+UNUserNotificationCenter.h"
+
+#import "NotifeeCoreDelegateHolder.h"
+#import "NotifeeCoreUtil.h"
+
+@implementation NotifeeCoreUNUserNotificationCenter
+struct {
+  unsigned int willPresentNotification : 1;
+  unsigned int didReceiveNotificationResponse : 1;
+  unsigned int openSettingsForNotification : 1;
+} originalUNCDelegateRespondsTo;
+
++ (instancetype)instance {
+  static dispatch_once_t once;
+  __strong static NotifeeCoreUNUserNotificationCenter *sharedInstance;
+  dispatch_once(&once, ^{
+    sharedInstance = [[NotifeeCoreUNUserNotificationCenter alloc] init];
+    sharedInstance.initialNotification = nil;
+  });
+  return sharedInstance;
+}
+
+- (void)observe {
+  static dispatch_once_t once;
+  __weak NotifeeCoreUNUserNotificationCenter *weakSelf = self;
+  dispatch_once(&once, ^{
+    NotifeeCoreUNUserNotificationCenter *strongSelf = weakSelf;
+    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+    if (center.delegate != nil) {
+      _originalDelegate = center.delegate;
+      originalUNCDelegateRespondsTo.openSettingsForNotification = (unsigned int)[_originalDelegate
+          respondsToSelector:@selector(userNotificationCenter:openSettingsForNotification:)];
+      originalUNCDelegateRespondsTo.willPresentNotification = (unsigned int)[_originalDelegate
+          respondsToSelector:@selector(userNotificationCenter:
+                                      willPresentNotification:withCompletionHandler:)];
+      originalUNCDelegateRespondsTo.didReceiveNotificationResponse =
+          (unsigned int)[_originalDelegate
+              respondsToSelector:@selector(userNotificationCenter:
+                                     didReceiveNotificationResponse:withCompletionHandler:)];
+    }
+    center.delegate = strongSelf;
+  });
+}
+
+- (nullable NSDictionary *)getInitialNotification {
+  if (_initialNotification != nil) {
+    NSDictionary *initialNotificationCopy = [_initialNotification copy];
+    _initialNotification = nil;
+    return initialNotificationCopy;
+  }
+
+  return nil;
+}
+
+#pragma mark - UNUserNotificationCenter Delegate Methods
+
+// The method will be called on the delegate only if the application is in the
+// foreground. If the the handler is not called in a timely manner then the
+// notification will not be presented. The application can choose to have the
+// notification presented as a sound, badge, alert and/or in the notification
+// list. This decision should be based on whether the information in the
+// notification is otherwise visible to the user.
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+       willPresentNotification:(UNNotification *)notification
+         withCompletionHandler:
+             (void (^)(UNNotificationPresentationOptions options))completionHandler {
+  NSDictionary *notifeeNotification =
+      notification.request.content.userInfo[kNotifeeUserInfoNotification];
+
+  // we only care about notifications created through notifee
+  if (notifeeNotification != nil) {
+    UNNotificationPresentationOptions presentationOptions = UNNotificationPresentationOptionNone;
+    NSDictionary *foregroundPresentationOptions =
+        notifeeNotification[@"ios"][@"foregroundPresentationOptions"];
+
+    BOOL alert = [foregroundPresentationOptions[@"alert"] boolValue];
+    BOOL badge = [foregroundPresentationOptions[@"badge"] boolValue];
+    BOOL sound = [foregroundPresentationOptions[@"sound"] boolValue];
+    BOOL banner = [foregroundPresentationOptions[@"banner"] boolValue];
+    BOOL list = [foregroundPresentationOptions[@"list"] boolValue];
+
+    if (badge) {
+      presentationOptions |= UNNotificationPresentationOptionBadge;
+    }
+
+    if (sound) {
+      presentationOptions |= UNNotificationPresentationOptionSound;
+    }
+
+    // if list or banner is true, ignore alert property
+    if (banner || list) {
+      if (banner) {
+        if (@available(iOS 14, *)) {
+          presentationOptions |= UNNotificationPresentationOptionBanner;
+        } else {
+          // for iOS 13 we need to set alert
+          presentationOptions |= UNNotificationPresentationOptionAlert;
+        }
+      }
+
+      if (list) {
+        if (@available(iOS 14, *)) {
+          presentationOptions |= UNNotificationPresentationOptionList;
+        } else {
+          // for iOS 13 we need to set alert
+          presentationOptions |= UNNotificationPresentationOptionAlert;
+        }
+      }
+    } else if (alert) {
+      // TODO: remove alert once it has been fully removed from the notifee API
+      presentationOptions |= UNNotificationPresentationOptionAlert;
+    }
+
+    NSDictionary *notifeeTrigger = notification.request.content.userInfo[kNotifeeUserInfoTrigger];
+    if (notifeeTrigger != nil) {
+      // post DELIVERED event
+      [[NotifeeCoreDelegateHolder instance] didReceiveNotifeeCoreEvent:@{
+        @"type" : @(NotifeeCoreEventTypeDelivered),
+        @"detail" : @{
+          @"notification" : notifeeNotification,
+        }
+      }];
+    }
+
+    completionHandler(presentationOptions);
+
+  } else if (_originalDelegate != nil && originalUNCDelegateRespondsTo.willPresentNotification) {
+    [_originalDelegate userNotificationCenter:center
+                      willPresentNotification:notification
+                        withCompletionHandler:completionHandler];
+  }
+}
+
+// The method will be called when the user responded to the notification by
+// opening the application, dismissing the notification or choosing a
+// UNNotificationAction. The delegate must be set before the application returns
+// from application:didFinishLaunchingWithOptions:.
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+    didReceiveNotificationResponse:(UNNotificationResponse *)response
+             withCompletionHandler:(void (^)(void))completionHandler {
+  NSDictionary *notifeeNotification =
+      response.notification.request.content.userInfo[kNotifeeUserInfoNotification];
+
+  // handle notification outside of notifee
+  if (notifeeNotification == nil) {
+    notifeeNotification =
+        [NotifeeCoreUtil parseUNNotificationRequest:response.notification.request];
+  }
+
+  if (notifeeNotification != nil) {
+    if ([response.actionIdentifier isEqualToString:UNNotificationDismissActionIdentifier]) {
+      // post DISMISSED event, only triggers if notification has a categoryId
+      [[NotifeeCoreDelegateHolder instance] didReceiveNotifeeCoreEvent:@{
+        @"type" : @(NotifeeCoreEventTypeDismissed),
+        @"detail" : @{
+          @"notification" : notifeeNotification,
+        }
+      }];
+      return;
+    }
+
+    NSNumber *eventType;
+    NSMutableDictionary *event = [NSMutableDictionary dictionary];
+    NSMutableDictionary *eventDetail = [NSMutableDictionary dictionary];
+    NSMutableDictionary *eventDetailPressAction = [NSMutableDictionary dictionary];
+
+    if ([response.actionIdentifier isEqualToString:UNNotificationDefaultActionIdentifier]) {
+      eventType = @1;  // PRESS
+      // event.detail.pressAction.id
+      eventDetailPressAction[@"id"] = @"default";
+    } else {
+      eventType = @2;  // ACTION_PRESS
+      // event.detail.pressAction.id
+      eventDetailPressAction[@"id"] = response.actionIdentifier;
+    }
+
+    if ([response isKindOfClass:UNTextInputNotificationResponse.class]) {
+      // event.detail.input
+      eventDetail[@"input"] = [(UNTextInputNotificationResponse *)response userText];
+    }
+
+    // event.type
+    event[@"type"] = eventType;
+
+    // event.detail.notification
+    eventDetail[@"notification"] = notifeeNotification;
+
+    // event.detail.pressAction
+    eventDetail[@"pressAction"] = eventDetailPressAction;
+
+    // event.detail
+    event[@"detail"] = eventDetail;
+
+    // store notification for getInitialNotification
+    _initialNotification = [eventDetail copy];
+
+    // post PRESS/ACTION_PRESS event
+    [[NotifeeCoreDelegateHolder instance] didReceiveNotifeeCoreEvent:event];
+
+    // TODO figure out if this is needed or if we can just complete immediately
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(15 * NSEC_PER_SEC)),
+                   dispatch_get_main_queue(), ^{
+                     completionHandler();
+                   });
+
+  } else if (_originalDelegate != nil &&
+             originalUNCDelegateRespondsTo.didReceiveNotificationResponse) {
+    [_originalDelegate userNotificationCenter:center
+               didReceiveNotificationResponse:response
+                        withCompletionHandler:completionHandler];
+  }
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+    openSettingsForNotification:(nullable UNNotification *)notification {
+  if (_originalDelegate != nil && originalUNCDelegateRespondsTo.openSettingsForNotification) {
+    if (@available(iOS 12.0, macOS 10.14, macCatalyst 13.0, *)) {
+      [_originalDelegate userNotificationCenter:center openSettingsForNotification:notification];
+    } else {
+      // Fallback on earlier versions
+    }
+  }
+}
+
+@end

package/ios/NotifeeCore/NotifeeCore.h

@@ -0,0 +1,118 @@
+/**
+ * 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>
+//! Project version number for NotifeeCore.
+FOUNDATION_EXPORT double NotifeeCoreVersionNumber;
+#import <UserNotifications/UserNotifications.h>
+
+//! Project version string for NotifeeCore.
+FOUNDATION_EXPORT const unsigned char NotifeeCoreVersionString[];
+
+// Import all the public headers of your framework using statements like #import
+// <NotifeeCore/PublicHeader.h> #import <NotifeeCore/Example.h> END public
+// headers import
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^notifeeMethodVoidBlock)(NSError *_Nullable);
+
+typedef void (^notifeeMethodNSDictionaryBlock)(NSError *_Nullable, NSDictionary *_Nullable);
+
+typedef void (^notifeeMethodNSArrayBlock)(NSError *_Nullable, NSArray *_Nullable);
+
+typedef void (^notifeeMethodBooleanBlock)(NSError *_Nullable, BOOL);
+
+typedef void (^notifeeMethodNSIntegerBlock)(NSError *_Nullable, NSInteger);
+
+typedef NS_ENUM(NSInteger, NotifeeCoreNotificationType) {
+  NotifeeCoreNotificationTypeAll = 0,
+  NotifeeCoreNotificationTypeDisplayed = 1,
+  NotifeeCoreNotificationTypeTrigger = 2
+};
+
+typedef NS_ENUM(NSInteger, NotifeeCoreEventType) {
+  NotifeeCoreEventTypeDismissed = 0,
+  NotifeeCoreEventTypeDelivered = 3,
+  NotifeeCoreEventTypeTriggerNotificationCreated = 7,
+};
+
+@class NotifeeCore;
+
+@protocol NotifeeCoreDelegate <NSObject>
+@optional
+- (void)didReceiveNotifeeCoreEvent:(NSDictionary *_Nonnull)event;
+@end
+
+@interface NotifeeCore : NSObject
+
++ (void)setCoreDelegate:(id<NotifeeCoreDelegate>)coreDelegate;
+
++ (void)cancelNotification:(NSString *)notificationId
+      withNotificationType:(NSInteger)notificationType
+                 withBlock:(notifeeMethodVoidBlock)block;
+
++ (void)cancelAllNotifications:(NSInteger)notificationType withBlock:(notifeeMethodVoidBlock)block;
+
++ (void)cancelAllNotificationsWithIds:(NSInteger)notificationType
+                              withIds:(NSArray<NSString *> *)ids
+                            withBlock:(notifeeMethodVoidBlock)block;
+
++ (void)displayNotification:(NSDictionary *)notification withBlock:(notifeeMethodVoidBlock)block;
+
++ (void)createTriggerNotification:(NSDictionary *)notification
+                      withTrigger:(NSDictionary *)trigger
+                        withBlock:(notifeeMethodVoidBlock)block;
+
++ (void)getTriggerNotificationIds:(notifeeMethodNSArrayBlock)block;
+
++ (void)getDisplayedNotifications:(notifeeMethodNSArrayBlock)block;
+
++ (void)getTriggerNotifications:(notifeeMethodNSArrayBlock)block;
+
++ (void)requestPermission:(NSDictionary *)permissions
+                withBlock:(notifeeMethodNSDictionaryBlock)block;
+
++ (void)getNotificationCategories:(notifeeMethodNSArrayBlock)block;
+
++ (void)setNotificationCategories:(NSArray<NSDictionary *> *)categories
+                        withBlock:(notifeeMethodVoidBlock)block;
+
++ (void)getNotificationSettings:(notifeeMethodNSDictionaryBlock)block;
+
++ (void)getInitialNotification:(notifeeMethodNSDictionaryBlock)block;
+
++ (void)setBadgeCount:(NSInteger)count withBlock:(notifeeMethodVoidBlock)block;
+
++ (void)getBadgeCount:(notifeeMethodNSIntegerBlock)block;
+
++ (void)incrementBadgeCount:(NSInteger)incrementBy withBlock:(notifeeMethodVoidBlock)block;
+
++ (void)decrementBadgeCount:(NSInteger)decrementBy withBlock:(notifeeMethodVoidBlock)block;
+
++ (nullable instancetype)notifeeUIApplication;
+
++ (UNMutableNotificationContent *)buildNotificationContent:(NSDictionary *)notification
+                                               withTrigger:(NSDictionary *_Nullable)trigger;
+
++ (void)populateNotificationContent:(UNNotificationRequest *_Nullable)request
+                        withContent:(UNMutableNotificationContent *)content
+                 withContentHandler:(void (^)(UNNotificationContent *_Nonnull))contentHandler;
+
+@end
+
+NS_ASSUME_NONNULL_END