react-native-qpush 0.0.0-stage → 1.0.0

package/ios/QPushPushCore.swift

@@ -0,0 +1,457 @@
+import Foundation
+import UIKit
+import UserNotifications
+
+/// Native singleton shared by the React Native module and the Objective-C
+/// hooks (app delegate swizzling + UNUserNotificationCenter delegate proxy in
+/// QPushPushHooks.m, which call the `@objc` class methods below at runtime).
+///
+/// All mutable state is confined to the main queue.
+@objc(QPushPushCore)
+public final class QPushPushCore: NSObject {
+  static let shared = QPushPushCore()
+
+  static let clickEvent = "QPushPushClick"
+  static let foregroundWillDisplayEvent = "QPushPushForegroundWillDisplay"
+  static let pushTokenEvent = "QPushPushToken"
+  static let supportedEvents = [clickEvent, foregroundWillDisplayEvent, pushTokenEvent]
+
+  /// JS must answer `foregroundWillDisplay` within this time, else the notification is shown.
+  private static let foregroundResponseTimeout: TimeInterval = 1.0
+  /// After `preventDefault()`, JS may still call `display()` during this window.
+  private static let preventedExpiry: TimeInterval = 25.0
+  private static let registrationTimeout: TimeInterval = 30.0
+  private static let maxPendingEvents = 50
+
+  private struct PendingDisplay {
+    let completion: (UNNotificationPresentationOptions) -> Void
+    let options: UNNotificationPresentationOptions
+    var prevented: Bool
+  }
+
+  private weak var emitter: QPushPush?
+  private var jsReady = false
+  private var pendingEvents: [(name: String, body: [String: Any])] = []
+  private var pendingDisplays: [String: PendingDisplay] = [:]
+  private var registrationWaiters: [([String: Any]) -> Void] = []
+  private var lastToken: String?
+  private var backgroundTasks: [Int: UIBackgroundTaskIdentifier] = [:]
+
+  private override init() {
+    super.init()
+  }
+
+  // MARK: - Module lifecycle
+
+  func attach(_ module: QPushPush) {
+    onMain {
+      self.emitter = module
+      self.jsReady = false
+    }
+  }
+
+  func setJsReady() {
+    onMain {
+      self.jsReady = true
+      let events = self.pendingEvents
+      self.pendingEvents.removeAll()
+      for event in events {
+        self.emit(event.name, event.body)
+      }
+    }
+  }
+
+  private func canSendToJs() -> Bool {
+    guard jsReady, let emitter = emitter else { return false }
+    return emitter.hasListeners
+  }
+
+  /// Emits now when JS is listening, otherwise queues (cold-start clicks).
+  func emit(_ name: String, _ body: [String: Any]) {
+    onMain {
+      if self.canSendToJs(), let emitter = self.emitter {
+        emitter.sendEvent(withName: name, body: body)
+        return
+      }
+      self.pendingEvents.append((name: name, body: body))
+      if self.pendingEvents.count > QPushPushCore.maxPendingEvents {
+        self.pendingEvents.removeFirst()
+      }
+    }
+  }
+
+  // MARK: - APNs registration (called from the swizzled app delegate)
+
+  @objc(handleDeviceToken:)
+  public static func handleDeviceToken(_ deviceToken: Data) {
+    let token = deviceToken.map { String(format: "%02x", $0) }.joined()
+    shared.didRegister(token: token)
+  }
+
+  @objc(handleRegistrationError:)
+  public static func handleRegistrationError(_ error: NSError) {
+    shared.didFailToRegister(error)
+  }
+
+  private func didRegister(token: String) {
+    onMain {
+      QPushLog.debug("APNs token received")
+      let changed = self.lastToken != token
+      self.lastToken = token
+      self.resolveRegistration(["token": token])
+      if changed { self.emit(QPushPushCore.pushTokenEvent, ["token": token]) }
+    }
+  }
+
+  private func didFailToRegister(_ error: NSError) {
+    onMain {
+      QPushLog.error("APNs registration failed: \(error.localizedDescription)")
+      self.resolveRegistration([
+        "token": NSNull(),
+        "notificationTypes": -10,
+        "error": error.localizedDescription,
+      ])
+    }
+  }
+
+  private func resolveRegistration(_ result: [String: Any]) {
+    let waiters = registrationWaiters
+    registrationWaiters.removeAll()
+    for waiter in waiters { waiter(result) }
+  }
+
+  /// Calls `registerForRemoteNotifications`; resolves with the hex token or an error.
+  func registerForPush(_ completion: @escaping ([String: Any]) -> Void) {
+    onMain {
+      var finished = false
+      let waiter: ([String: Any]) -> Void = { result in
+        if finished { return }
+        finished = true
+        completion(result)
+      }
+      self.registrationWaiters.append(waiter)
+      UIApplication.shared.registerForRemoteNotifications()
+      DispatchQueue.main.asyncAfter(deadline: .now() + QPushPushCore.registrationTimeout) {
+        guard !finished else { return }
+        let result: [String: Any] = [
+          "error": "Timed out waiting for the APNs token",
+          "token": QPushPushCore.orNull(self.lastToken),
+        ]
+        waiter(result)
+      }
+    }
+  }
+
+  // MARK: - Permission
+
+  static func permissionString(_ status: UNAuthorizationStatus) -> String {
+    switch status {
+    case .authorized:
+      return "granted"
+    case .denied:
+      return "denied"
+    case .notDetermined:
+      return "notDetermined"
+    case .provisional:
+      return "provisional"
+    default:
+      if #available(iOS 14.0, *), status == .ephemeral {
+        return "ephemeral"
+      }
+      return "notDetermined"
+    }
+  }
+
+  func permissionStatus(_ completion: @escaping (String) -> Void) {
+    UNUserNotificationCenter.current().getNotificationSettings { settings in
+      completion(QPushPushCore.permissionString(settings.authorizationStatus))
+    }
+  }
+
+  private static func isGranted(_ status: String) -> Bool {
+    return status == "granted" || status == "provisional" || status == "ephemeral"
+  }
+
+  func requestPermission(fallbackToSettings: Bool, completion: @escaping (Bool) -> Void) {
+    let center = UNUserNotificationCenter.current()
+    center.getNotificationSettings { settings in
+      switch settings.authorizationStatus {
+      case .notDetermined, .provisional:
+        center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
+          if let error = error { QPushLog.warn("requestAuthorization failed: \(error.localizedDescription)") }
+          if granted {
+            DispatchQueue.main.async { UIApplication.shared.registerForRemoteNotifications() }
+          }
+          completion(granted)
+        }
+      case .denied:
+        if fallbackToSettings {
+          self.openSettingsThenCheck(completion)
+        } else {
+          completion(false)
+        }
+      default:
+        completion(true)
+      }
+    }
+  }
+
+  func registerForProvisionalAuthorization(_ completion: @escaping (Bool) -> Void) {
+    UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge, .provisional]) { granted, _ in
+      if granted {
+        DispatchQueue.main.async { UIApplication.shared.registerForRemoteNotifications() }
+      }
+      completion(granted)
+    }
+  }
+
+  func canRequestPermission(_ completion: @escaping (Bool) -> Void) {
+    UNUserNotificationCenter.current().getNotificationSettings { settings in
+      completion(settings.authorizationStatus == .notDetermined || settings.authorizationStatus == .provisional)
+    }
+  }
+
+  /// Opens the app's notification settings and resolves when the user comes back.
+  private func openSettingsThenCheck(_ completion: @escaping (Bool) -> Void) {
+    DispatchQueue.main.async {
+      let urlString: String
+      if #available(iOS 16.0, *) {
+        urlString = UIApplication.openNotificationSettingsURLString
+      } else {
+        urlString = UIApplication.openSettingsURLString
+      }
+      guard let url = URL(string: urlString) else {
+        completion(false)
+        return
+      }
+      var observer: NSObjectProtocol?
+      observer = NotificationCenter.default.addObserver(
+        forName: UIApplication.didBecomeActiveNotification,
+        object: nil,
+        queue: .main
+      ) { _ in
+        if let token = observer { NotificationCenter.default.removeObserver(token) }
+        observer = nil
+        self.permissionStatus { status in completion(QPushPushCore.isGranted(status)) }
+      }
+      UIApplication.shared.open(url, options: [:]) { opened in
+        if !opened {
+          if let token = observer { NotificationCenter.default.removeObserver(token) }
+          observer = nil
+          completion(false)
+        }
+      }
+    }
+  }
+
+  // MARK: - Foreground presentation (called from the UNUserNotificationCenter proxy)
+
+  @objc(handleWillPresent:completionHandler:)
+  public static func handleWillPresent(
+    _ notification: UNNotification,
+    completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
+  ) {
+    shared.willPresent(notification, completion: completionHandler)
+  }
+
+  static func defaultPresentationOptions() -> UNNotificationPresentationOptions {
+    if #available(iOS 14.0, *) {
+      return [.banner, .list, .sound, .badge]
+    }
+    return [.alert, .sound, .badge]
+  }
+
+  private func willPresent(_ notification: UNNotification, completion: @escaping (UNNotificationPresentationOptions) -> Void) {
+    let userInfo = notification.request.content.userInfo
+    // Receipt fallback for apps without the Notification Service Extension (idempotent).
+    if let notificationId = QPushPushCore.notificationId(userInfo) {
+      QPushHTTP.reportReceived(notificationId: notificationId)
+    }
+    let options = QPushPushCore.defaultPresentationOptions()
+    onMain {
+      guard self.canSendToJs() else {
+        completion(options)
+        return
+      }
+      let displayId = UUID().uuidString
+      self.pendingDisplays[displayId] = PendingDisplay(completion: completion, options: options, prevented: false)
+      self.emit(QPushPushCore.foregroundWillDisplayEvent, [
+        "displayId": displayId,
+        "rawPayload": QPushPushCore.jsonSafe(userInfo),
+      ])
+      DispatchQueue.main.asyncAfter(deadline: .now() + QPushPushCore.foregroundResponseTimeout) {
+        self.finishDisplay(displayId, show: true, onlyIfNotPrevented: true)
+      }
+    }
+  }
+
+  func displayForeground(_ displayId: String) {
+    onMain { self.finishDisplay(displayId, show: true, onlyIfNotPrevented: false) }
+  }
+
+  func preventForeground(_ displayId: String) {
+    onMain {
+      guard var pending = self.pendingDisplays[displayId] else { return }
+      pending.prevented = true
+      self.pendingDisplays[displayId] = pending
+      DispatchQueue.main.asyncAfter(deadline: .now() + QPushPushCore.preventedExpiry) {
+        self.finishDisplay(displayId, show: false, onlyIfNotPrevented: false)
+      }
+    }
+  }
+
+  private func finishDisplay(_ displayId: String, show: Bool, onlyIfNotPrevented: Bool) {
+    guard let pending = pendingDisplays[displayId] else { return }
+    if onlyIfNotPrevented && pending.prevented { return }
+    pendingDisplays.removeValue(forKey: displayId)
+    pending.completion(show ? pending.options : [])
+  }
+
+  // MARK: - Click (called from the UNUserNotificationCenter proxy)
+
+  @objc(handleDidReceive:completionHandler:)
+  public static func handleDidReceive(_ response: UNNotificationResponse, completionHandler: @escaping () -> Void) {
+    shared.didReceive(response, completion: completionHandler)
+  }
+
+  private func didReceive(_ response: UNNotificationResponse, completion: @escaping () -> Void) {
+    let userInfo = response.notification.request.content.userInfo
+    guard let qpush = userInfo["qpush"] as? [String: Any],
+          let notificationId = QPushPushCore.notificationId(userInfo)
+    else {
+      completion()
+      return
+    }
+    var actionId: String?
+    switch response.actionIdentifier {
+    case UNNotificationDefaultActionIdentifier:
+      actionId = nil
+    case UNNotificationDismissActionIdentifier:
+      completion()
+      return
+    default:
+      actionId = response.actionIdentifier
+    }
+
+    let buttons = qpush["buttons"] as? [[String: Any]] ?? []
+    let buttonUrl = buttons.first { ($0["id"] as? String) == actionId && actionId != nil }?["url"] as? String
+    let url = (buttonUrl?.isEmpty == false ? buttonUrl : nil) ?? (qpush["url"] as? String)
+
+    QPushHTTP.reportOpened(notificationId: notificationId, actionId: actionId)
+    emit(QPushPushCore.clickEvent, [
+      "rawPayload": QPushPushCore.jsonSafe(userInfo),
+      "actionId": QPushPushCore.orNull(actionId),
+      "url": QPushPushCore.orNull(url),
+    ])
+
+    if let url = url, !url.isEmpty, QPushStorage.shared.autoOpenUrls, let target = URL(string: url) {
+      DispatchQueue.main.async {
+        UIApplication.shared.open(target, options: [:], completionHandler: nil)
+      }
+    }
+    completion()
+  }
+
+  // MARK: - Notification center helpers
+
+  func clearAll() {
+    UNUserNotificationCenter.current().removeAllDeliveredNotifications()
+    onMain { self.setBadge(0) }
+  }
+
+  func removeNotification(_ notificationId: String) {
+    let center = UNUserNotificationCenter.current()
+    center.getDeliveredNotifications { notifications in
+      let identifiers = notifications
+        .filter { QPushPushCore.notificationId($0.request.content.userInfo) == notificationId }
+        .map { $0.request.identifier }
+      if !identifiers.isEmpty { center.removeDeliveredNotifications(withIdentifiers: identifiers) }
+    }
+  }
+
+  func removeGroupedNotifications(_ groupKey: String) {
+    let center = UNUserNotificationCenter.current()
+    center.getDeliveredNotifications { notifications in
+      let identifiers = notifications
+        .filter { $0.request.content.threadIdentifier == groupKey }
+        .map { $0.request.identifier }
+      if !identifiers.isEmpty { center.removeDeliveredNotifications(withIdentifiers: identifiers) }
+    }
+  }
+
+  /// Clears the badge and returns the previous value.
+  func clearBadge(_ completion: @escaping (Int) -> Void) {
+    onMain {
+      let previous = UIApplication.shared.applicationIconBadgeNumber
+      if previous > 0 { self.setBadge(0) }
+      completion(previous)
+    }
+  }
+
+  private func setBadge(_ value: Int) {
+    if #available(iOS 16.0, *) {
+      UNUserNotificationCenter.current().setBadgeCount(value) { error in
+        if let error = error { QPushLog.warn("setBadgeCount failed: \(error.localizedDescription)") }
+      }
+    } else {
+      UIApplication.shared.applicationIconBadgeNumber = value
+    }
+  }
+
+  // MARK: - Background tasks (lets the JS queue flush after backgrounding)
+
+  func beginBackgroundTask(_ completion: @escaping (Int) -> Void) {
+    onMain {
+      var identifier = UIBackgroundTaskIdentifier.invalid
+      identifier = UIApplication.shared.beginBackgroundTask(withName: "QPushFlush") {
+        self.endBackgroundTask(identifier.rawValue)
+      }
+      if identifier == .invalid {
+        completion(-1)
+        return
+      }
+      self.backgroundTasks[identifier.rawValue] = identifier
+      completion(identifier.rawValue)
+    }
+  }
+
+  func endBackgroundTask(_ taskId: Int) {
+    onMain {
+      guard let identifier = self.backgroundTasks.removeValue(forKey: taskId) else { return }
+      UIApplication.shared.endBackgroundTask(identifier)
+    }
+  }
+
+  // MARK: - Utilities
+
+  /// `value` or `NSNull` (serialized as `null` by the bridge).
+  static func orNull(_ value: String?) -> Any {
+    if let value = value { return value }
+    return NSNull()
+  }
+
+  static func notificationId(_ userInfo: [AnyHashable: Any]) -> String? {
+    guard let qpush = userInfo["qpush"] as? [String: Any],
+          let notificationId = qpush["id"] as? String,
+          !notificationId.isEmpty
+    else { return nil }
+    return notificationId
+  }
+
+  /// `userInfo` with string keys only (what the RN bridge can serialize).
+  static func jsonSafe(_ userInfo: [AnyHashable: Any]) -> [String: Any] {
+    var result: [String: Any] = [:]
+    for (key, value) in userInfo {
+      if let key = key as? String { result[key] = value }
+    }
+    return result
+  }
+
+  private func onMain(_ block: @escaping () -> Void) {
+    if Thread.isMainThread {
+      block()
+    } else {
+      DispatchQueue.main.async(execute: block)
+    }
+  }
+}

package/ios/QPushPushHooks.m

@@ -0,0 +1,237 @@
+// Captures the APNs token and notification callbacks without requiring the
+// developer to edit the AppDelegate (same approach as OneSignal):
+//
+//  1. +load swizzles -[UIApplication setDelegate:]. When UIKit installs the app
+//     delegate (inside UIApplicationMain, before didFinishLaunching), the
+//     delegate class gets didRegisterForRemoteNotificationsWithDeviceToken: and
+//     didFailToRegisterForRemoteNotificationsWithError: hooks that call QPush
+//     first and then the app's own implementation (if any).
+//  2. -[UNUserNotificationCenter setDelegate:] is swizzled so a proxy owned by
+//     QPush always stays the delegate. Whatever delegate the app or another
+//     library sets is kept as the proxy's forward target: QPush notifications
+//     are handled by QPush, everything else is forwarded untouched.
+//
+// The Swift side (`QPushPushCore`) is reached through the Objective-C runtime
+// so this file does not depend on the generated "-Swift.h" header name.
+
+#import <Foundation/Foundation.h>
+#import <UIKit/UIKit.h>
+#import <UserNotifications/UserNotifications.h>
+#import <objc/message.h>
+#import <objc/runtime.h>
+
+#pragma mark - Swift entry points
+
+/// Class methods of the Swift `QPushPushCore` (`@objc` names), looked up at
+/// runtime. Declared here only so the selectors are known to the compiler.
+@protocol QPushPushCoreEntryPoints
++ (void)handleDeviceToken:(NSData *)deviceToken;
++ (void)handleRegistrationError:(NSError *)error;
++ (void)handleWillPresent:(UNNotification *)notification
+        completionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler;
++ (void)handleDidReceive:(UNNotificationResponse *)response completionHandler:(void (^)(void))completionHandler;
+@end
+
+static Class QPushCoreClass(void) {
+  static Class cls = Nil;
+  if (cls == Nil) {
+    cls = NSClassFromString(@"QPushPushCore");
+  }
+  return cls;
+}
+
+static BOOL QPushCoreSend1(SEL selector, id argument) {
+  Class cls = QPushCoreClass();
+  if (cls == Nil || ![cls respondsToSelector:selector]) {
+    return NO;
+  }
+  ((void (*)(id, SEL, id))objc_msgSend)(cls, selector, argument);
+  return YES;
+}
+
+static BOOL QPushCoreSend2(SEL selector, id first, id second) {
+  Class cls = QPushCoreClass();
+  if (cls == Nil || ![cls respondsToSelector:selector]) {
+    return NO;
+  }
+  ((void (*)(id, SEL, id, id))objc_msgSend)(cls, selector, first, second);
+  return YES;
+}
+
+static BOOL QPushIsQPushNotification(UNNotification *notification) {
+  id qpush = notification.request.content.userInfo[@"qpush"];
+  return [qpush isKindOfClass:[NSDictionary class]];
+}
+
+#pragma mark - UNUserNotificationCenter delegate proxy
+
+@interface QPushNotificationCenterProxy : NSObject <UNUserNotificationCenterDelegate>
+@property (nonatomic, weak) id<UNUserNotificationCenterDelegate> forwardDelegate;
++ (instancetype)shared;
+@end
+
+@implementation QPushNotificationCenterProxy
+
++ (instancetype)shared {
+  static QPushNotificationCenterProxy *instance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    instance = [[QPushNotificationCenterProxy alloc] init];
+  });
+  return instance;
+}
+
+- (BOOL)respondsToSelector:(SEL)aSelector {
+  if ([super respondsToSelector:aSelector]) {
+    return YES;
+  }
+  id forward = self.forwardDelegate;
+  return forward != nil && [forward respondsToSelector:aSelector];
+}
+
+- (id)forwardingTargetForSelector:(SEL)aSelector {
+  id forward = self.forwardDelegate;
+  if (forward != nil && [forward respondsToSelector:aSelector]) {
+    return forward;
+  }
+  return [super forwardingTargetForSelector:aSelector];
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+       willPresentNotification:(UNNotification *)notification
+         withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler {
+  if (QPushIsQPushNotification(notification) &&
+      QPushCoreSend2(@selector(handleWillPresent:completionHandler:), notification, completionHandler)) {
+    return;
+  }
+  id<UNUserNotificationCenterDelegate> forward = self.forwardDelegate;
+  if (forward != nil && [forward respondsToSelector:_cmd]) {
+    [forward userNotificationCenter:center willPresentNotification:notification withCompletionHandler:completionHandler];
+    return;
+  }
+  completionHandler(UNNotificationPresentationOptionNone);
+}
+
+- (void)userNotificationCenter:(UNUserNotificationCenter *)center
+    didReceiveNotificationResponse:(UNNotificationResponse *)response
+             withCompletionHandler:(void (^)(void))completionHandler {
+  if (QPushIsQPushNotification(response.notification) &&
+      QPushCoreSend2(@selector(handleDidReceive:completionHandler:), response, completionHandler)) {
+    return;
+  }
+  id<UNUserNotificationCenterDelegate> forward = self.forwardDelegate;
+  if (forward != nil && [forward respondsToSelector:_cmd]) {
+    [forward userNotificationCenter:center didReceiveNotificationResponse:response withCompletionHandler:completionHandler];
+    return;
+  }
+  completionHandler();
+}
+
+@end
+
+#pragma mark - Swizzling
+
+static IMP QPushOriginalAppSetDelegate = NULL;
+static IMP QPushOriginalCenterSetDelegate = NULL;
+static NSMutableSet<NSString *> *QPushHookedDelegateClasses = nil;
+
+static void QPushCenterSetDelegate(id self, SEL _cmd, id<UNUserNotificationCenterDelegate> delegate) {
+  QPushNotificationCenterProxy *proxy = [QPushNotificationCenterProxy shared];
+  if (delegate != (id)proxy) {
+    proxy.forwardDelegate = delegate;
+  }
+  ((void (*)(id, SEL, id))QPushOriginalCenterSetDelegate)(self, _cmd, proxy);
+}
+
+static void QPushInstallNotificationCenterProxy(void) {
+  UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
+  id current = center.delegate;
+  if (current != (id)[QPushNotificationCenterProxy shared]) {
+    // Goes through QPushCenterSetDelegate: `current` becomes the forward target.
+    center.delegate = current;
+  }
+}
+
+/// Adds (or wraps) `selector` on `cls`; QPush's block runs first, then the original.
+static void QPushHookTokenSuccess(Class cls) {
+  SEL selector = @selector(application:didRegisterForRemoteNotificationsWithDeviceToken:);
+  Method existing = class_getInstanceMethod(cls, selector);
+  __block IMP original = existing ? method_getImplementation(existing) : NULL;
+  IMP replacement = imp_implementationWithBlock(^(id receiver, UIApplication *application, NSData *deviceToken) {
+    QPushCoreSend1(@selector(handleDeviceToken:), deviceToken);
+    if (original != NULL) {
+      ((void (*)(id, SEL, UIApplication *, NSData *))original)(receiver, selector, application, deviceToken);
+    }
+  });
+  const char *types = existing ? method_getTypeEncoding(existing) : "v@:@@";
+  if (!class_addMethod(cls, selector, replacement, types)) {
+    // The class implements it itself: replace it and keep its implementation.
+    original = method_setImplementation(class_getInstanceMethod(cls, selector), replacement);
+  }
+}
+
+static void QPushHookTokenFailure(Class cls) {
+  SEL selector = @selector(application:didFailToRegisterForRemoteNotificationsWithError:);
+  Method existing = class_getInstanceMethod(cls, selector);
+  __block IMP original = existing ? method_getImplementation(existing) : NULL;
+  IMP replacement = imp_implementationWithBlock(^(id receiver, UIApplication *application, NSError *error) {
+    QPushCoreSend1(@selector(handleRegistrationError:), error);
+    if (original != NULL) {
+      ((void (*)(id, SEL, UIApplication *, NSError *))original)(receiver, selector, application, error);
+    }
+  });
+  const char *types = existing ? method_getTypeEncoding(existing) : "v@:@@";
+  if (!class_addMethod(cls, selector, replacement, types)) {
+    original = method_setImplementation(class_getInstanceMethod(cls, selector), replacement);
+  }
+}
+
+static void QPushHookAppDelegateClass(Class cls) {
+  if (cls == Nil) {
+    return;
+  }
+  NSString *name = NSStringFromClass(cls);
+  @synchronized([QPushNotificationCenterProxy class]) {
+    if (QPushHookedDelegateClasses == nil) {
+      QPushHookedDelegateClasses = [NSMutableSet set];
+    }
+    if ([QPushHookedDelegateClasses containsObject:name]) {
+      return;
+    }
+    [QPushHookedDelegateClasses addObject:name];
+  }
+  QPushHookTokenSuccess(cls);
+  QPushHookTokenFailure(cls);
+}
+
+static void QPushAppSetDelegate(id self, SEL _cmd, id<UIApplicationDelegate> delegate) {
+  // Hook before UIKit caches which delegate methods are implemented.
+  if (delegate != nil) {
+    QPushHookAppDelegateClass(object_getClass(delegate));
+  }
+  ((void (*)(id, SEL, id))QPushOriginalAppSetDelegate)(self, _cmd, delegate);
+  // Must be in place before didFinishLaunching returns to receive the
+  // response of the notification that launched the app.
+  QPushInstallNotificationCenterProxy();
+}
+
+@interface QPushPushHooks : NSObject
+@end
+
+@implementation QPushPushHooks
+
++ (void)load {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    Method centerSetDelegate = class_getInstanceMethod([UNUserNotificationCenter class], @selector(setDelegate:));
+    if (centerSetDelegate != NULL) {
+      QPushOriginalCenterSetDelegate = method_setImplementation(centerSetDelegate, (IMP)QPushCenterSetDelegate);
+    }
+    Method appSetDelegate = class_getInstanceMethod([UIApplication class], @selector(setDelegate:));
+    if (appSetDelegate != NULL) {
+      QPushOriginalAppSetDelegate = method_setImplementation(appSetDelegate, (IMP)QPushAppSetDelegate);
+    }
+  });
+}
+
+@end