@onekeyfe/react-native-jpush 0.0.0-stage → 6.7.0-23

package/ios/jpush/JPUSHModels.m

@@ -0,0 +1,214 @@
+#import "../include/JPUSHService.h"
+#import <CoreLocation/CoreLocation.h>
+#import <UserNotifications/UserNotifications.h>
+
+@implementation JPUSHRegisterEntity
+@end
+
+@implementation JPushNotificationIdentifier
+
+- (id)copyWithZone:(NSZone *)zone {
+    JPushNotificationIdentifier *copy = [[[self class] allocWithZone:zone] init];
+    copy.identifiers = [self.identifiers copyWithZone:zone];
+    copy.notificationObj = [self.notificationObj copyWithZone:zone];
+    copy.delivered = self.delivered;
+    copy.findCompletionHandler = [self.findCompletionHandler copy];
+    return copy;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)coder {
+    self = [super init];
+    if (self) {
+        _identifiers = [coder decodeObjectForKey:@"identifiers"];
+        _delivered = [coder decodeBoolForKey:@"delivered"];
+    }
+    return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+    [coder encodeObject:self.identifiers forKey:@"identifiers"];
+    [coder encodeBool:self.delivered forKey:@"delivered"];
+}
+
+@end
+
+@implementation JPushNotificationSound
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _criticalSoundVolume = 1.0f;
+    }
+    return self;
+}
+
+- (id)copyWithZone:(NSZone *)zone {
+    JPushNotificationSound *copy = [[[self class] allocWithZone:zone] init];
+    copy.soundName = [self.soundName copyWithZone:zone];
+    copy.criticalSoundName = [self.criticalSoundName copyWithZone:zone];
+    copy.criticalSoundVolume = self.criticalSoundVolume;
+    copy.soundSetting = self.soundSetting;
+    return copy;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)coder {
+    self = [super init];
+    if (self) {
+        _soundName = [coder decodeObjectForKey:@"soundName"];
+        _criticalSoundName = [coder decodeObjectForKey:@"criticalSoundName"];
+        _criticalSoundVolume = [coder decodeFloatForKey:@"criticalSoundVolume"];
+    }
+    return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+    [coder encodeObject:self.soundName forKey:@"soundName"];
+    [coder encodeObject:self.criticalSoundName forKey:@"criticalSoundName"];
+    [coder encodeFloat:self.criticalSoundVolume forKey:@"criticalSoundVolume"];
+}
+
+@end
+
+@implementation JPushNotificationContent
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _summaryArgumentCount = 1;
+        _interruptionLevel = 1;
+        _relevanceScore = 0.0;
+    }
+    return self;
+}
+
+- (id)copyWithZone:(NSZone *)zone {
+    JPushNotificationContent *copy = [[[self class] allocWithZone:zone] init];
+    copy.title = [self.title copyWithZone:zone];
+    copy.subtitle = [self.subtitle copyWithZone:zone];
+    copy.body = [self.body copyWithZone:zone];
+    copy.badge = [self.badge copyWithZone:zone];
+    copy.action = [self.action copyWithZone:zone];
+    copy.categoryIdentifier = [self.categoryIdentifier copyWithZone:zone];
+    copy.userInfo = [self.userInfo copyWithZone:zone];
+    copy.sound = [self.sound copyWithZone:zone];
+    copy.soundSetting = [self.soundSetting copyWithZone:zone];
+    copy.attachments = [self.attachments copyWithZone:zone];
+    copy.threadIdentifier = [self.threadIdentifier copyWithZone:zone];
+    copy.launchImageName = [self.launchImageName copyWithZone:zone];
+    copy.summaryArgument = [self.summaryArgument copyWithZone:zone];
+    copy.summaryArgumentCount = self.summaryArgumentCount;
+    copy.targetContentIdentifier = [self.targetContentIdentifier copyWithZone:zone];
+    copy.interruptionLevel = self.interruptionLevel;
+    copy.relevanceScore = self.relevanceScore;
+    copy.filterCriteria = [self.filterCriteria copyWithZone:zone];
+    return copy;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)coder {
+    self = [super init];
+    if (self) {
+        _title = [coder decodeObjectForKey:@"title"];
+        _subtitle = [coder decodeObjectForKey:@"subtitle"];
+        _body = [coder decodeObjectForKey:@"body"];
+        _badge = [coder decodeObjectForKey:@"badge"];
+        _action = [coder decodeObjectForKey:@"action"];
+        _categoryIdentifier = [coder decodeObjectForKey:@"categoryIdentifier"];
+        _userInfo = [coder decodeObjectForKey:@"userInfo"];
+        _sound = [coder decodeObjectForKey:@"sound"];
+        _threadIdentifier = [coder decodeObjectForKey:@"threadIdentifier"];
+    }
+    return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+    [coder encodeObject:self.title forKey:@"title"];
+    [coder encodeObject:self.subtitle forKey:@"subtitle"];
+    [coder encodeObject:self.body forKey:@"body"];
+    [coder encodeObject:self.badge forKey:@"badge"];
+    [coder encodeObject:self.action forKey:@"action"];
+    [coder encodeObject:self.categoryIdentifier forKey:@"categoryIdentifier"];
+    [coder encodeObject:self.userInfo forKey:@"userInfo"];
+    [coder encodeObject:self.sound forKey:@"sound"];
+    [coder encodeObject:self.threadIdentifier forKey:@"threadIdentifier"];
+}
+
+@end
+
+@implementation JPushNotificationTrigger
+
+- (id)copyWithZone:(NSZone *)zone {
+    JPushNotificationTrigger *copy = [[[self class] allocWithZone:zone] init];
+    copy.repeat = self.repeat;
+    copy.fireDate = [self.fireDate copyWithZone:zone];
+    copy.region = [self.region copyWithZone:zone];
+    copy.dateComponents = [self.dateComponents copyWithZone:zone];
+    copy.timeInterval = self.timeInterval;
+    return copy;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)coder {
+    self = [super init];
+    if (self) {
+        _repeat = [coder decodeBoolForKey:@"repeat"];
+        _fireDate = [coder decodeObjectForKey:@"fireDate"];
+        _dateComponents = [coder decodeObjectForKey:@"dateComponents"];
+        _timeInterval = [coder decodeDoubleForKey:@"timeInterval"];
+    }
+    return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+    [coder encodeBool:self.repeat forKey:@"repeat"];
+    [coder encodeObject:self.fireDate forKey:@"fireDate"];
+    [coder encodeObject:self.dateComponents forKey:@"dateComponents"];
+    [coder encodeDouble:self.timeInterval forKey:@"timeInterval"];
+}
+
+@end
+
+@implementation JPushNotificationRequest
+
+- (id)copyWithZone:(NSZone *)zone {
+    JPushNotificationRequest *copy = [[[self class] allocWithZone:zone] init];
+    copy.requestIdentifier = [self.requestIdentifier copyWithZone:zone];
+    copy.content = [self.content copyWithZone:zone];
+    copy.trigger = [self.trigger copyWithZone:zone];
+    copy.completionHandler = [self.completionHandler copy];
+    return copy;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)coder {
+    self = [super init];
+    if (self) {
+        _requestIdentifier = [coder decodeObjectForKey:@"requestIdentifier"];
+        _content = [coder decodeObjectForKey:@"content"];
+        _trigger = [coder decodeObjectForKey:@"trigger"];
+    }
+    return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)coder {
+    [coder encodeObject:self.requestIdentifier forKey:@"requestIdentifier"];
+    [coder encodeObject:self.content forKey:@"content"];
+    [coder encodeObject:self.trigger forKey:@"trigger"];
+}
+
+@end
+
+@implementation JPushInAppMessage
+@end
+
+@implementation JPushCollectControl
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _gps = NO;
+        _bssid = NO;
+        _ssid = NO;
+        _cell = NO;
+    }
+    return self;
+}
+
+@end

package/ios/jpush/JPUSHNotificationManager.h

@@ -0,0 +1,34 @@
+#import <Foundation/Foundation.h>
+#if __has_include("JPUSHService.h")
+#import "JPUSHService.h"
+#else
+#import "../include/JPUSHService.h"
+#endif
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface JPUSHNotificationManager : NSObject
+
++ (instancetype)shared;
+
+@property (nonatomic, weak, nullable) id<JPUSHRegisterDelegate> registerDelegate;
+@property (nonatomic, weak, nullable) id<JPUSHNotiInMessageDelegate> notiInMessageDelegate;
+@property (nonatomic, weak, nullable) id<JPUSHInAppMessageDelegate> inAppMessageDelegate;
+@property (nonatomic, weak, nullable) id<JPUSHGeofenceDelegate> geofenceDelegate;
+
+- (void)registerWithConfig:(JPUSHRegisterEntity *)config
+                  delegate:(nullable id<JPUSHRegisterDelegate>)delegate;
+
+- (void)registerTypes:(NSUInteger)types categories:(nullable NSSet *)categories;
+
+- (void)addNotification:(JPushNotificationRequest *)request;
+- (void)removeNotification:(nullable JPushNotificationIdentifier *)identifier;
+- (void)findNotification:(JPushNotificationIdentifier *)identifier;
+
+- (void)requestAuthorization:(nullable void (^)(JPAuthorizationStatus status))completion;
+- (void)getAuthorizationStatus:(nullable void (^)(JPAuthorizationStatus status))completion;
+- (void)openNotificationSettings:(nullable void (^)(BOOL success))completion;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/jpush/JPUSHNotificationManager.m

@@ -0,0 +1,360 @@
+#import "JPUSHNotificationManager.h"
+#import <UserNotifications/UserNotifications.h>
+#if __has_include(<UIKit/UIKit.h>)
+#import <UIKit/UIKit.h>
+#endif
+
+@interface JPUSHNotificationManager () <UNUserNotificationCenterDelegate>
+@end
+
+@implementation JPUSHNotificationManager
+
++ (instancetype)shared {
+    static JPUSHNotificationManager *instance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [[JPUSHNotificationManager alloc] init];
+    });
+    return instance;
+}
+
+- (nullable UNUserNotificationCenter *)safeNotificationCenter {
+    if ([NSBundle mainBundle].bundleIdentifier.length == 0) {
+        return nil;
+    }
+    @try {
+        return [UNUserNotificationCenter currentNotificationCenter];
+    } @catch (NSException *exception) {
+        return nil;
+    }
+}
+
+- (void)registerWithConfig:(JPUSHRegisterEntity *)config
+                  delegate:(id<JPUSHRegisterDelegate>)delegate {
+    self.registerDelegate = delegate;
+    [self registerTypes:(NSUInteger)config.types categories:config.categories];
+}
+
+- (void)registerTypes:(NSUInteger)types categories:(NSSet *)categories {
+    UNUserNotificationCenter *center = [self safeNotificationCenter];
+    if (center == nil) {
+        return;
+    }
+    if (types != 0 || center.delegate == nil) {
+        center.delegate = self;
+    }
+    if (categories.count > 0) {
+        [center setNotificationCategories:categories];
+    }
+
+    UNAuthorizationOptions options = UNAuthorizationOptionNone;
+    if (types & JPAuthorizationOptionBadge) {
+        options |= UNAuthorizationOptionBadge;
+    }
+    if (types & JPAuthorizationOptionSound) {
+        options |= UNAuthorizationOptionSound;
+    }
+    if (types & JPAuthorizationOptionAlert) {
+        options |= UNAuthorizationOptionAlert;
+    }
+    if (types & JPAuthorizationOptionCarPlay) {
+        options |= UNAuthorizationOptionCarPlay;
+    }
+    if (@available(iOS 12.0, *)) {
+        if (types & JPAuthorizationOptionCriticalAlert) {
+            options |= UNAuthorizationOptionCriticalAlert;
+        }
+        if (types & JPAuthorizationOptionProvidesAppNotificationSettings) {
+            options |= UNAuthorizationOptionProvidesAppNotificationSettings;
+        }
+        if (types & JPAuthorizationOptionProvisional) {
+            options |= UNAuthorizationOptionProvisional;
+        }
+    }
+
+    if (options == UNAuthorizationOptionNone) {
+        return;
+    }
+
+    __weak typeof(self) weakSelf = self;
+    [center requestAuthorizationWithOptions:options completionHandler:^(BOOL granted, NSError * _Nullable error) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+#if __has_include(<UIKit/UIKit.h>)
+            if (granted) {
+                [[UIApplication sharedApplication] registerForRemoteNotifications];
+            }
+#endif
+            __strong typeof(weakSelf) strongSelf = weakSelf;
+            if ([strongSelf.registerDelegate respondsToSelector:@selector(jpushNotificationAuthorization:withInfo:)]) {
+                JPAuthorizationStatus status = granted ? JPAuthorizationStatusAuthorized : JPAuthorizationStatusDenied;
+                NSDictionary *info = error ? @{@"error": error.localizedDescription ?: @""} : @{};
+                [strongSelf.registerDelegate jpushNotificationAuthorization:status withInfo:info];
+            }
+        });
+    }];
+}
+
+- (void)addNotification:(JPushNotificationRequest *)request {
+    if (request == nil || request.content == nil) {
+        if (request.completionHandler != nil) {
+            request.completionHandler(nil);
+        }
+        return;
+    }
+
+    NSString *identifier = request.requestIdentifier.length > 0
+        ? request.requestIdentifier
+        : [NSUUID UUID].UUIDString;
+
+    UNMutableNotificationContent *content = [[UNMutableNotificationContent alloc] init];
+    if (request.content.title != nil) {
+        content.title = request.content.title;
+    }
+    if (request.content.subtitle != nil) {
+        content.subtitle = request.content.subtitle;
+    }
+    if (request.content.body != nil) {
+        content.body = request.content.body;
+    }
+    if (request.content.badge != nil) {
+        content.badge = request.content.badge;
+    }
+    if (request.content.categoryIdentifier.length > 0) {
+        content.categoryIdentifier = request.content.categoryIdentifier;
+    }
+    if (request.content.threadIdentifier.length > 0) {
+        content.threadIdentifier = request.content.threadIdentifier;
+    }
+    if (request.content.userInfo != nil) {
+        content.userInfo = request.content.userInfo;
+    }
+    if (request.content.soundSetting.soundSetting != nil) {
+        content.sound = request.content.soundSetting.soundSetting;
+    } else if (request.content.soundSetting.soundName.length > 0) {
+        content.sound = [UNNotificationSound soundNamed:request.content.soundSetting.soundName];
+    } else if (request.content.sound.length > 0) {
+        content.sound = [UNNotificationSound soundNamed:request.content.sound];
+    } else {
+        content.sound = [UNNotificationSound defaultSound];
+    }
+    if (request.content.attachments.count > 0) {
+        content.attachments = request.content.attachments;
+    }
+
+    UNNotificationTrigger *trigger = nil;
+    if (request.trigger != nil) {
+        if (request.trigger.dateComponents != nil) {
+            trigger = [UNCalendarNotificationTrigger triggerWithDateMatchingComponents:request.trigger.dateComponents
+                                                                               repeats:request.trigger.repeat];
+        } else if (request.trigger.timeInterval > 0) {
+            NSTimeInterval interval = request.trigger.repeat ? MAX(60.0, request.trigger.timeInterval) : request.trigger.timeInterval;
+            trigger = [UNTimeIntervalNotificationTrigger triggerWithTimeInterval:interval
+                                                                         repeats:request.trigger.repeat];
+        } else if (request.trigger.fireDate != nil) {
+            NSTimeInterval delta = [request.trigger.fireDate timeIntervalSinceNow];
+            if (delta > 0) {
+                trigger = [UNTimeIntervalNotificationTrigger triggerWithTimeInterval:delta repeats:NO];
+            }
+        }
+    }
+
+    UNNotificationRequest *unRequest = [UNNotificationRequest requestWithIdentifier:identifier
+                                                                            content:content
+                                                                            trigger:trigger];
+    UNUserNotificationCenter *center = [self safeNotificationCenter];
+    if (center == nil) {
+        if (request.completionHandler != nil) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                request.completionHandler(unRequest);
+            });
+        }
+        return;
+    }
+    [center addNotificationRequest:unRequest
+             withCompletionHandler:^(NSError * _Nullable error) {
+        if (request.completionHandler != nil) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                request.completionHandler(error == nil ? unRequest : nil);
+            });
+        }
+    }];
+}
+
+- (void)removeNotification:(JPushNotificationIdentifier *)identifier {
+    UNUserNotificationCenter *center = [self safeNotificationCenter];
+    if (center == nil) {
+        return;
+    }
+    if (identifier == nil || identifier.identifiers.count == 0) {
+        [center removeAllPendingNotificationRequests];
+        [center removeAllDeliveredNotifications];
+        return;
+    }
+    if (identifier.delivered) {
+        [center removeDeliveredNotificationsWithIdentifiers:identifier.identifiers];
+    } else {
+        [center removePendingNotificationRequestsWithIdentifiers:identifier.identifiers];
+    }
+}
+
+- (void)findNotification:(JPushNotificationIdentifier *)identifier {
+    if (identifier == nil || identifier.findCompletionHandler == nil) {
+        return;
+    }
+    UNUserNotificationCenter *center = [self safeNotificationCenter];
+    if (center == nil) {
+        dispatch_async(dispatch_get_main_queue(), ^{
+            identifier.findCompletionHandler(@[]);
+        });
+        return;
+    }
+    NSSet<NSString *> *filterSet = identifier.identifiers.count > 0
+        ? [NSSet setWithArray:identifier.identifiers]
+        : nil;
+
+    if (identifier.delivered) {
+        [center getDeliveredNotificationsWithCompletionHandler:^(NSArray<UNNotification *> * _Nonnull notifications) {
+            NSMutableArray *matched = [NSMutableArray array];
+            for (UNNotification *item in notifications) {
+                if (filterSet == nil || [filterSet containsObject:item.request.identifier]) {
+                    [matched addObject:item.request];
+                }
+            }
+            dispatch_async(dispatch_get_main_queue(), ^{
+                identifier.findCompletionHandler(matched);
+            });
+        }];
+    } else {
+        [center getPendingNotificationRequestsWithCompletionHandler:^(NSArray<UNNotificationRequest *> * _Nonnull requests) {
+            NSMutableArray *matched = [NSMutableArray array];
+            for (UNNotificationRequest *req in requests) {
+                if (filterSet == nil || [filterSet containsObject:req.identifier]) {
+                    [matched addObject:req];
+                }
+            }
+            dispatch_async(dispatch_get_main_queue(), ^{
+                identifier.findCompletionHandler(matched);
+            });
+        }];
+    }
+}
+
+- (void)requestAuthorization:(void (^)(JPAuthorizationStatus status))completion {
+    UNUserNotificationCenter *center = [self safeNotificationCenter];
+    if (center == nil) {
+        if (completion != nil) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                completion(JPAuthorizationNotDetermined);
+            });
+        }
+        return;
+    }
+    UNAuthorizationOptions options = (UNAuthorizationOptionBadge | UNAuthorizationOptionSound | UNAuthorizationOptionAlert);
+    [center requestAuthorizationWithOptions:options completionHandler:^(BOOL granted, NSError * _Nullable error) {
+        (void)error;
+        JPAuthorizationStatus status = granted ? JPAuthorizationStatusAuthorized : JPAuthorizationStatusDenied;
+        dispatch_async(dispatch_get_main_queue(), ^{
+#if __has_include(<UIKit/UIKit.h>)
+            if (granted) {
+                [[UIApplication sharedApplication] registerForRemoteNotifications];
+            }
+#endif
+            if (completion != nil) {
+                completion(status);
+            }
+        });
+    }];
+}
+
+- (void)getAuthorizationStatus:(void (^)(JPAuthorizationStatus status))completion {
+    UNUserNotificationCenter *center = [self safeNotificationCenter];
+    if (center == nil) {
+        if (completion != nil) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                completion(JPAuthorizationNotDetermined);
+            });
+        }
+        return;
+    }
+    [center getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings * _Nonnull settings) {
+        JPAuthorizationStatus status = JPAuthorizationNotDetermined;
+        switch (settings.authorizationStatus) {
+            case UNAuthorizationStatusDenied:
+                status = JPAuthorizationStatusDenied;
+                break;
+            case UNAuthorizationStatusAuthorized:
+                status = JPAuthorizationStatusAuthorized;
+                break;
+            case UNAuthorizationStatusProvisional:
+                status = JPAuthorizationStatusProvisional;
+                break;
+#if defined(__IPHONE_14_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_14_0
+            case UNAuthorizationStatusEphemeral:
+                status = JPAuthorizationStatusAuthorized;
+                break;
+#endif
+            default:
+                status = JPAuthorizationNotDetermined;
+                break;
+        }
+        if (completion != nil) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                completion(status);
+            });
+        }
+    }];
+}
+
+- (void)openNotificationSettings:(void (^)(BOOL success))completion {
+    dispatch_async(dispatch_get_main_queue(), ^{
+#if __has_include(<UIKit/UIKit.h>)
+        NSURL *url = [NSURL URLWithString:UIApplicationOpenSettingsURLString];
+        if (url != nil && [[UIApplication sharedApplication] canOpenURL:url]) {
+            [[UIApplication sharedApplication] openURL:url options:@{} completionHandler:completion];
+            return;
+        }
+#endif
+        if (completion != nil) {
+            completion(NO);
+        }
+    });
+}
+
+#pragma mark - UNUserNotificationCenterDelegate
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+       willPresentNotification:(UNNotification *)notification
+         withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler {
+    if ([self.registerDelegate respondsToSelector:@selector(jpushNotificationCenter:willPresentNotification:withCompletionHandler:)]) {
+        [self.registerDelegate jpushNotificationCenter:center
+                               willPresentNotification:notification
+                                 withCompletionHandler:^(NSInteger options) {
+            completionHandler((UNNotificationPresentationOptions)options);
+        }];
+    } else {
+        completionHandler(UNNotificationPresentationOptionBadge |
+                          UNNotificationPresentationOptionSound |
+                          UNNotificationPresentationOptionAlert);
+    }
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+didReceiveNotificationResponse:(UNNotificationResponse *)response
+         withCompletionHandler:(void (^)(void))completionHandler {
+    if ([self.registerDelegate respondsToSelector:@selector(jpushNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:)]) {
+        [self.registerDelegate jpushNotificationCenter:center
+                        didReceiveNotificationResponse:response
+                                 withCompletionHandler:completionHandler];
+    } else {
+        completionHandler();
+    }
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+   openSettingsForNotification:(UNNotification *)notification {
+    if ([self.registerDelegate respondsToSelector:@selector(jpushNotificationCenter:openSettingsForNotification:)]) {
+        [self.registerDelegate jpushNotificationCenter:center openSettingsForNotification:notification];
+    }
+}
+
+@end