capacitor-push-signal 0.0.1

package/dist/plugin.js

@@ -0,0 +1,103 @@
+var capacitorPushSignal = (function (exports, core) {
+    'use strict';
+
+    const PushSignal = core.registerPlugin('PushSignal', {
+        web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.PushSignalWeb()),
+    });
+    const messageListeners = new Set();
+    const pressListeners = new Set();
+    let nativeCallbacksBound = false;
+    function normalizeMessage(raw) {
+        const data = {};
+        if (raw.data && typeof raw.data === 'object') {
+            for (const [key, value] of Object.entries(raw.data)) {
+                if (value == null) {
+                    continue;
+                }
+                data[key] = typeof value === 'string' ? value : String(value);
+            }
+        }
+        return {
+            id: raw.id,
+            title: raw.title,
+            body: raw.body,
+            data,
+        };
+    }
+    function normalizeCredentials(raw) {
+        return {
+            platform: raw.platform,
+            token: raw.token,
+            environment: raw.environment,
+        };
+    }
+    function bindNativeCallbacks() {
+        if (nativeCallbacksBound) {
+            return;
+        }
+        nativeCallbacksBound = true;
+        void PushSignal.addListener('onMessage', (raw) => {
+            const message = normalizeMessage(raw);
+            for (const listener of [...messageListeners]) {
+                try {
+                    Promise.resolve(listener(message)).then(() => undefined, () => undefined);
+                }
+                catch (_a) {
+                    // Ignore listener failures so one bad subscriber cannot break delivery.
+                }
+            }
+        });
+        void PushSignal.addListener('onNotificationPress', (raw) => {
+            const message = normalizeMessage(raw);
+            pressListeners.forEach((listener) => listener(message));
+        });
+        void PushSignal.startListening();
+    }
+    function initialize(config = {}) {
+        return PushSignal.initialize(config);
+    }
+    function getCredentials() {
+        return PushSignal.getCredentials().then(normalizeCredentials);
+    }
+    function onMessage(listener) {
+        bindNativeCallbacks();
+        messageListeners.add(listener);
+        return () => {
+            messageListeners.delete(listener);
+        };
+    }
+    function onNotificationPress(listener) {
+        bindNativeCallbacks();
+        pressListeners.add(listener);
+        return () => {
+            pressListeners.delete(listener);
+        };
+    }
+    bindNativeCallbacks();
+
+    class PushSignalWeb extends core.WebPlugin {
+        async initialize(config) {
+        }
+        async getCredentials() {
+            throw this.unimplemented('Push credentials are not supported on web');
+        }
+        async startListening() {
+            return;
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        PushSignalWeb: PushSignalWeb
+    });
+
+    exports.PushSignal = PushSignal;
+    exports.getCredentials = getCredentials;
+    exports.initialize = initialize;
+    exports.onMessage = onMessage;
+    exports.onNotificationPress = onNotificationPress;
+
+    return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/pushSignal.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst PushSignal = registerPlugin('PushSignal', {\n    web: () => import('./web').then((m) => new m.PushSignalWeb()),\n});\nconst messageListeners = new Set();\nconst pressListeners = new Set();\nlet nativeCallbacksBound = false;\nfunction normalizeMessage(raw) {\n    const data = {};\n    if (raw.data && typeof raw.data === 'object') {\n        for (const [key, value] of Object.entries(raw.data)) {\n            if (value == null) {\n                continue;\n            }\n            data[key] = typeof value === 'string' ? value : String(value);\n        }\n    }\n    return {\n        id: raw.id,\n        title: raw.title,\n        body: raw.body,\n        data,\n    };\n}\nfunction normalizeCredentials(raw) {\n    return {\n        platform: raw.platform,\n        token: raw.token,\n        environment: raw.environment,\n    };\n}\nfunction bindNativeCallbacks() {\n    if (nativeCallbacksBound) {\n        return;\n    }\n    nativeCallbacksBound = true;\n    void PushSignal.addListener('onMessage', (raw) => {\n        const message = normalizeMessage(raw);\n        for (const listener of [...messageListeners]) {\n            try {\n                Promise.resolve(listener(message)).then(() => undefined, () => undefined);\n            }\n            catch (_a) {\n                // Ignore listener failures so one bad subscriber cannot break delivery.\n            }\n        }\n    });\n    void PushSignal.addListener('onNotificationPress', (raw) => {\n        const message = normalizeMessage(raw);\n        pressListeners.forEach((listener) => listener(message));\n    });\n    void PushSignal.startListening();\n}\nexport function initialize(config = {}) {\n    return PushSignal.initialize(config);\n}\nexport function getCredentials() {\n    return PushSignal.getCredentials().then(normalizeCredentials);\n}\nexport function onMessage(listener) {\n    bindNativeCallbacks();\n    messageListeners.add(listener);\n    return () => {\n        messageListeners.delete(listener);\n    };\n}\nexport function onNotificationPress(listener) {\n    bindNativeCallbacks();\n    pressListeners.add(listener);\n    return () => {\n        pressListeners.delete(listener);\n    };\n}\nbindNativeCallbacks();\nexport { PushSignal };\n//# sourceMappingURL=pushSignal.js.map","import { WebPlugin } from '@capacitor/core';\nexport class PushSignalWeb extends WebPlugin {\n    async initialize(config) {\n        void config;\n    }\n    async getCredentials() {\n        throw this.unimplemented('Push credentials are not supported on web');\n    }\n    async startListening() {\n        return;\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":"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"}

package/ios/Sources/PushSignalCore/PushSignalCenter.m

@@ -0,0 +1,583 @@
+#import "PushSignalCenter.h"
+#import "PushSignalLaunchStore.h"
+#import <objc/runtime.h>
+#import <UIKit/UIKit.h>
+
+@interface PushSignalAppDelegateHook : NSObject
+@end
+
+@interface UNUserNotificationCenter (PushSignal)
+- (void)pushSignal_setDelegate:(id<UNUserNotificationCenterDelegate>)delegate;
+@end
+
+@implementation PushSignalCenter {
+  NSLock *_lock;
+  BOOL _didInstall;
+  BOOL _didSwizzleAppDelegate;
+  BOOL _didSwizzleNotificationCenter;
+  NSString *_deviceToken;
+  NSError *_registrationError;
+  NSMutableArray<void (^)(NSString *_Nullable, NSError *_Nullable)> *_tokenWaiters;
+  NSDictionary *_pendingPress;
+  NSMutableArray<NSDictionary *> *_pendingMessages;
+  NSDictionary *_pendingLaunchOptions;
+  BOOL _didCaptureLaunchNotification;
+  NSMutableDictionary<NSString *, NSDate *> *_recentMessageIds;
+  __weak id<UNUserNotificationCenterDelegate> _forwardingDelegate;
+  void (^_onMessage)(NSDictionary *);
+  void (^_onNotificationPress)(NSDictionary *);
+}
+
++ (instancetype)shared {
+  static PushSignalCenter *sharedInstance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [[PushSignalCenter alloc] init];
+  });
+  return sharedInstance;
+}
+
++ (void)installEarly {
+  [[PushSignalCenter shared] install];
+}
+
++ (void)bootstrapWithLaunchOptions:(NSDictionary *)launchOptions {
+  PushSignalCenter *center = [PushSignalCenter shared];
+  center->_pendingLaunchOptions = [launchOptions copy];
+  [center install];
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _lock = [[NSLock alloc] init];
+    _tokenWaiters = [NSMutableArray array];
+    _pendingMessages = [NSMutableArray array];
+    _recentMessageIds = [NSMutableDictionary dictionary];
+  }
+  return self;
+}
+
+- (void)install {
+  if ([NSThread isMainThread]) {
+    [self installOnMain];
+  } else {
+    dispatch_async(dispatch_get_main_queue(), ^{
+      [self installOnMain];
+    });
+  }
+}
+
+- (void)installOnMain {
+  [self swizzleNotificationCenterDelegateIfNeeded];
+
+  if (_didInstall) {
+    [UNUserNotificationCenter currentNotificationCenter].delegate = self;
+    [self swizzleAppDelegate];
+    [self captureLaunchNotificationIfNeeded];
+    return;
+  }
+
+  _didInstall = YES;
+  [UNUserNotificationCenter currentNotificationCenter].delegate = self;
+  [self swizzleAppDelegate];
+  [self captureLaunchNotificationIfNeeded];
+}
+
+- (void)rememberForwardingDelegate:(id<UNUserNotificationCenterDelegate>)delegate {
+  if (delegate != nil && delegate != self) {
+    _forwardingDelegate = delegate;
+  }
+}
+
+- (void)setOnMessage:(void (^)(NSDictionary *))callback {
+  _onMessage = [callback copy];
+  [self flushPendingMessages];
+}
+
+- (void)setOnNotificationPress:(void (^)(NSDictionary *))callback {
+  _onNotificationPress = [callback copy];
+  [self flushPendingPress];
+}
+
+- (void)fetchCredentialsWithResolver:(void (^)(NSDictionary *))resolve
+                            rejecter:(void (^)(NSError *))reject {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self installOnMain];
+    [[UIApplication sharedApplication] registerForRemoteNotifications];
+
+    [self waitForTokenWithCompletion:^(NSString *token, NSError *error) {
+      if (error != nil) {
+        reject(error);
+        return;
+      }
+      NSMutableDictionary *credentials = [NSMutableDictionary dictionary];
+      credentials[@"platform"] = @"ios";
+      credentials[@"token"] = token ?: @"";
+      credentials[@"environment"] = [self currentEnvironment];
+      resolve(credentials);
+    }];
+  });
+}
+
+- (void)handleDeviceToken:(NSData *)deviceToken {
+  const unsigned char *bytes = (const unsigned char *)deviceToken.bytes;
+  NSMutableString *token = [NSMutableString stringWithCapacity:deviceToken.length * 2];
+  for (NSUInteger i = 0; i < deviceToken.length; i++) {
+    [token appendFormat:@"%02x", bytes[i]];
+  }
+  [self finishRegistrationWithToken:token error:nil];
+}
+
+- (void)handleRegistrationError:(NSError *)error {
+  [self finishRegistrationWithToken:nil error:error];
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+       willPresentNotification:(UNNotification *)notification
+         withCompletionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
+  [self deliverMessage:[PushSignalCenter messageFromNotification:notification]];
+  [self forwardWillPresent:center
+              notification:notification
+                ourOptions:[PushSignalCenter foregroundPresentationOptions]
+         completionHandler:completionHandler];
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+didReceiveNotificationResponse:(UNNotificationResponse *)response
+         withCompletionHandler:(void (^)(void))completionHandler {
+  [self emitPress:[PushSignalCenter messageFromNotification:response.notification]];
+  SEL selector = @selector(userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:);
+  id<UNUserNotificationCenterDelegate> forwarding = _forwardingDelegate;
+  if (forwarding != nil && [forwarding respondsToSelector:selector]) {
+    [forwarding userNotificationCenter:center
+        didReceiveNotificationResponse:response
+                 withCompletionHandler:completionHandler];
+  } else {
+    completionHandler();
+  }
+}
+
+#pragma mark - Token
+
+- (void)waitForTokenWithCompletion:(void (^)(NSString *_Nullable, NSError *_Nullable))completion {
+  [_lock lock];
+  if (_deviceToken != nil) {
+    NSString *token = _deviceToken;
+    [_lock unlock];
+    completion(token, nil);
+    return;
+  }
+  if (_registrationError != nil) {
+    NSError *error = _registrationError;
+    [_lock unlock];
+    completion(nil, error);
+    return;
+  }
+  [_tokenWaiters addObject:[completion copy]];
+  [_lock unlock];
+
+  __weak PushSignalCenter *weakSelf = self;
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(20 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
+    NSError *timeout = [NSError errorWithDomain:@"PushSignal"
+                                           code:1
+                                       userInfo:@{
+                                         NSLocalizedDescriptionKey :
+                                             @"APNs registration timed out. Use a physical iOS device and enable the Push Notifications capability."
+                                       }];
+    [weakSelf finishRegistrationWithToken:nil error:timeout];
+  });
+}
+
+- (void)finishRegistrationWithToken:(NSString *)token error:(NSError *)error {
+  [_lock lock];
+  if (token != nil) {
+    _deviceToken = token;
+    _registrationError = nil;
+  } else if (_deviceToken == nil) {
+    _registrationError = error;
+  }
+  NSArray *waiters = [_tokenWaiters copy];
+  [_tokenWaiters removeAllObjects];
+  [_lock unlock];
+
+  for (void (^waiter)(NSString *, NSError *) in waiters) {
+    waiter(token, error);
+  }
+}
+
+#pragma mark - Messages
+
+- (void)deliverMessage:(NSDictionary *)message {
+  if (![self shouldEmit:message]) {
+    return;
+  }
+
+  void (^callback)(NSDictionary *) = nil;
+  [_lock lock];
+  callback = _onMessage;
+  if (callback == nil) {
+    [_pendingMessages addObject:message];
+    [_lock unlock];
+    return;
+  }
+  [_lock unlock];
+
+  [self emitToJs:callback message:message];
+}
+
+- (void)emitToJs:(void (^)(NSDictionary *))callback message:(NSDictionary *)message {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    callback(message);
+  });
+}
+
+- (void)flushPendingMessages {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    void (^callback)(NSDictionary *) = nil;
+    NSArray<NSDictionary *> *queued = nil;
+    [self->_lock lock];
+    callback = self->_onMessage;
+    queued = [self->_pendingMessages copy];
+    [self->_pendingMessages removeAllObjects];
+    [self->_lock unlock];
+
+    if (callback == nil || queued.count == 0) {
+      return;
+    }
+    for (NSDictionary *message in queued) {
+      [self emitToJs:callback message:message];
+    }
+  });
+}
+
+- (BOOL)shouldEmit:(NSDictionary *)message {
+  NSString *messageId = message[@"id"];
+  NSString *title = message[@"title"] ?: @"";
+  NSString *body = message[@"body"] ?: @"";
+  NSString *key = messageId ?: [NSString stringWithFormat:@"%@|%@", title, body];
+
+  [_lock lock];
+  NSDate *now = [NSDate date];
+  NSMutableArray<NSString *> *expired = [NSMutableArray array];
+  [_recentMessageIds enumerateKeysAndObjectsUsingBlock:^(NSString *k, NSDate *date, BOOL *stop) {
+    if ([now timeIntervalSinceDate:date] >= 5) {
+      [expired addObject:k];
+    }
+  }];
+  [_recentMessageIds removeObjectsForKeys:expired];
+
+  NSDate *last = _recentMessageIds[key];
+  if (last != nil && [now timeIntervalSinceDate:last] < 2) {
+    [_lock unlock];
+    return NO;
+  }
+  _recentMessageIds[key] = now;
+  [_lock unlock];
+  return YES;
+}
+
+- (void)forwardWillPresent:(UNUserNotificationCenter *)center
+              notification:(UNNotification *)notification
+                ourOptions:(UNNotificationPresentationOptions)ourOptions
+         completionHandler:(void (^)(UNNotificationPresentationOptions))completionHandler {
+  SEL selector = @selector(userNotificationCenter:willPresentNotification:withCompletionHandler:);
+  id<UNUserNotificationCenterDelegate> forwarding = _forwardingDelegate;
+  if (forwarding == nil || ![forwarding respondsToSelector:selector]) {
+    completionHandler(ourOptions);
+    return;
+  }
+
+  [forwarding userNotificationCenter:center
+             willPresentNotification:notification
+               withCompletionHandler:^(UNNotificationPresentationOptions forwarded) {
+                 completionHandler(ourOptions | forwarded);
+               }];
+}
+
++ (UNNotificationPresentationOptions)foregroundPresentationOptions {
+  if (@available(iOS 14.0, *)) {
+    return UNNotificationPresentationOptionBanner | UNNotificationPresentationOptionList |
+           UNNotificationPresentationOptionSound | UNNotificationPresentationOptionBadge;
+  }
+  return UNNotificationPresentationOptionAlert | UNNotificationPresentationOptionSound |
+         UNNotificationPresentationOptionBadge;
+}
+
+- (void)emitPress:(NSDictionary *)message {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (self->_onNotificationPress != nil) {
+      self->_onNotificationPress(message);
+    } else {
+      self->_pendingPress = message;
+    }
+  });
+}
+
+- (void)flushPendingPress {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    if (self->_pendingPress == nil || self->_onNotificationPress == nil) {
+      return;
+    }
+    NSDictionary *pending = self->_pendingPress;
+    self->_pendingPress = nil;
+    self->_onNotificationPress(pending);
+  });
+}
+
+- (void)captureLaunchNotificationIfNeeded {
+  if (_didCaptureLaunchNotification) {
+    return;
+  }
+
+  if (_pendingLaunchOptions == nil) {
+    _pendingLaunchOptions = PushSignalCopyLaunchOptions();
+  }
+
+  NSDictionary *launchOptions = _pendingLaunchOptions;
+  if (launchOptions == nil) {
+    return;
+  }
+
+  _didCaptureLaunchNotification = YES;
+
+  id payload = launchOptions[UIApplicationLaunchOptionsRemoteNotificationKey];
+  if (![payload isKindOfClass:[NSDictionary class]]) {
+    return;
+  }
+
+  [self emitPress:[PushSignalCenter messageFromUserInfo:payload
+                                             fallbackId:@"launch"
+                                                  title:nil
+                                                   body:nil]];
+}
+
+- (NSString *)currentEnvironment {
+  NSString *environment = [PushSignalCenter apsEnvironment];
+  if (environment != nil) {
+    return environment;
+  }
+#if DEBUG
+  return @"sandbox";
+#else
+  return @"production";
+#endif
+}
+
++ (nullable NSString *)apsEnvironment {
+  NSURL *url = [[NSBundle mainBundle] URLForResource:@"embedded" withExtension:@"mobileprovision"];
+  if (url == nil) {
+    return nil;
+  }
+  NSData *data = [NSData dataWithContentsOfURL:url];
+  if (data == nil) {
+    return nil;
+  }
+  NSString *contents = [[NSString alloc] initWithData:data encoding:NSASCIIStringEncoding];
+  if (contents == nil) {
+    return nil;
+  }
+
+  NSRegularExpression *regex =
+      [NSRegularExpression regularExpressionWithPattern:@"<key>aps-environment</key>\\s*<string>(\\w+)</string>"
+                                                options:0
+                                                  error:nil];
+  NSTextCheckingResult *match =
+      [regex firstMatchInString:contents options:0 range:NSMakeRange(0, contents.length)];
+  if (match == nil || match.numberOfRanges < 2) {
+    return nil;
+  }
+
+  NSString *value = [contents substringWithRange:[match rangeAtIndex:1]];
+  if ([value isEqualToString:@"development"]) {
+    return @"sandbox";
+  }
+  if ([value isEqualToString:@"production"]) {
+    return @"production";
+  }
+  return nil;
+}
+
++ (NSDictionary *)messageFromNotification:(UNNotification *)notification {
+  UNNotificationContent *content = notification.request.content;
+  return [self messageFromUserInfo:content.userInfo
+                        fallbackId:notification.request.identifier
+                             title:content.title.length > 0 ? content.title : nil
+                              body:content.body.length > 0 ? content.body : nil];
+}
+
++ (NSDictionary *)messageFromUserInfo:(NSDictionary *)userInfo
+                           fallbackId:(NSString *)fallbackId
+                                title:(NSString *)title
+                                 body:(NSString *)body {
+  id aps = userInfo[@"aps"];
+  id alert = [aps isKindOfClass:[NSDictionary class]] ? aps[@"alert"] : nil;
+  NSString *resolvedTitle = title;
+  NSString *resolvedBody = body;
+
+  if ([alert isKindOfClass:[NSString class]]) {
+    resolvedBody = resolvedBody ?: (NSString *)alert;
+  } else if ([alert isKindOfClass:[NSDictionary class]]) {
+    resolvedTitle = resolvedTitle ?: [self stringify:alert[@"title"]];
+    resolvedBody = resolvedBody ?: [self stringify:alert[@"body"]];
+  }
+
+  NSMutableDictionary *data = [NSMutableDictionary dictionary];
+  [userInfo enumerateKeysAndObjectsUsingBlock:^(id key, id value, BOOL *stop) {
+    NSString *stringKey = [NSString stringWithFormat:@"%@", key];
+    if ([stringKey isEqualToString:@"aps"]) {
+      return;
+    }
+    NSString *stringValue = [self stringify:value];
+    if (stringValue != nil) {
+      data[stringKey] = stringValue;
+    }
+  }];
+
+  NSMutableDictionary *message = [NSMutableDictionary dictionary];
+  NSString *messageId = [self stringify:userInfo[@"gcm.message_id"]] ?: fallbackId;
+  if (messageId != nil) {
+    message[@"id"] = messageId;
+  }
+  if (resolvedTitle != nil) {
+    message[@"title"] = resolvedTitle;
+  }
+  if (resolvedBody != nil) {
+    message[@"body"] = resolvedBody;
+  }
+  message[@"data"] = data;
+  return message;
+}
+
++ (nullable NSString *)stringify:(id)value {
+  if (value == nil || value == [NSNull null]) {
+    return nil;
+  }
+  if ([value isKindOfClass:[NSString class]]) {
+    return (NSString *)value;
+  }
+  if ([value isKindOfClass:[NSNumber class]]) {
+    return [(NSNumber *)value stringValue];
+  }
+  if ([NSJSONSerialization isValidJSONObject:value]) {
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:value options:0 error:nil];
+    if (jsonData != nil) {
+      return [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
+    }
+  }
+  return [NSString stringWithFormat:@"%@", value];
+}
+
+#pragma mark - Swizzling
+
+- (void)swizzleAppDelegate {
+  if (_didSwizzleAppDelegate) {
+    return;
+  }
+  id appDelegate = [UIApplication sharedApplication].delegate;
+  if (appDelegate == nil) {
+    return;
+  }
+  _didSwizzleAppDelegate = YES;
+
+  Class target = object_getClass(appDelegate);
+  Class source = [PushSignalAppDelegateHook class];
+
+  [self swizzleTarget:target
+             original:@selector(application:didRegisterForRemoteNotificationsWithDeviceToken:)
+          replacement:@selector(pushSignal_application:didRegisterForRemoteNotificationsWithDeviceToken:)
+               source:source];
+  [self swizzleTarget:target
+             original:@selector(application:didFailToRegisterForRemoteNotificationsWithError:)
+          replacement:@selector(pushSignal_application:didFailToRegisterForRemoteNotificationsWithError:)
+               source:source];
+}
+
+- (void)swizzleNotificationCenterDelegateIfNeeded {
+  if (_didSwizzleNotificationCenter) {
+    return;
+  }
+  _didSwizzleNotificationCenter = YES;
+
+  Class target = [UNUserNotificationCenter class];
+  SEL original = @selector(setDelegate:);
+  SEL replacement = @selector(pushSignal_setDelegate:);
+
+  Method originalMethod = class_getInstanceMethod(target, original);
+  Method replacementMethod = class_getInstanceMethod(target, replacement);
+  if (originalMethod == NULL || replacementMethod == NULL) {
+    return;
+  }
+  method_exchangeImplementations(originalMethod, replacementMethod);
+}
+
+- (void)swizzleTarget:(Class)target
+             original:(SEL)original
+          replacement:(SEL)replacement
+               source:(Class)source {
+  Method replacementMethod = class_getInstanceMethod(source, replacement);
+  if (replacementMethod == NULL) {
+    return;
+  }
+
+  IMP replacementImp = method_getImplementation(replacementMethod);
+  const char *types = method_getTypeEncoding(replacementMethod);
+  Class superClass = class_getSuperclass(target);
+  Method superMethod = superClass != Nil ? class_getInstanceMethod(superClass, original) : NULL;
+
+  if (class_addMethod(target, original, replacementImp, types)) {
+    if (superMethod != NULL) {
+      class_addMethod(
+          target, replacement, method_getImplementation(superMethod), method_getTypeEncoding(superMethod));
+    }
+    return;
+  }
+
+  if (!class_addMethod(target, replacement, replacementImp, types)) {
+    return;
+  }
+  Method originalMethod = class_getInstanceMethod(target, original);
+  Method addedReplacement = class_getInstanceMethod(target, replacement);
+  if (originalMethod == NULL || addedReplacement == NULL) {
+    return;
+  }
+  method_exchangeImplementations(originalMethod, addedReplacement);
+}
+
+@end
+
+@implementation PushSignalAppDelegateHook
+
+- (void)pushSignal_application:(UIApplication *)application
+    didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
+  [[PushSignalCenter shared] handleDeviceToken:deviceToken];
+  // After swizzle, this selector holds the original AppDelegate implementation (if any).
+  SEL original = @selector(pushSignal_application:didRegisterForRemoteNotificationsWithDeviceToken:);
+  if ([self respondsToSelector:original]) {
+    [self pushSignal_application:application didRegisterForRemoteNotificationsWithDeviceToken:deviceToken];
+  }
+}
+
+- (void)pushSignal_application:(UIApplication *)application
+    didFailToRegisterForRemoteNotificationsWithError:(NSError *)error {
+  [[PushSignalCenter shared] handleRegistrationError:error];
+  SEL original = @selector(pushSignal_application:didFailToRegisterForRemoteNotificationsWithError:);
+  if ([self respondsToSelector:original]) {
+    [self pushSignal_application:application didFailToRegisterForRemoteNotificationsWithError:error];
+  }
+}
+
+@end
+
+@implementation UNUserNotificationCenter (PushSignal)
+
+- (void)pushSignal_setDelegate:(id<UNUserNotificationCenterDelegate>)delegate {
+  if (delegate != nil && [delegate isKindOfClass:[PushSignalCenter class]]) {
+    [self pushSignal_setDelegate:delegate];
+    return;
+  }
+
+  [[PushSignalCenter shared] rememberForwardingDelegate:delegate];
+  [self pushSignal_setDelegate:[PushSignalCenter shared]];
+}
+
+@end