react-native-qpush 0.0.0-stage → 1.0.0

package/ios/QPushPushSupport.swift

@@ -0,0 +1,249 @@
+import Foundation
+import UIKit
+
+// MARK: - Logging
+
+/// Leveled logger using the same numeric levels as the JS `LogLevel` enum.
+enum QPushLog {
+  static var level: Int = 3 // Warn
+
+  static func error(_ message: @autoclosure () -> String) { log(2, "ERROR", message()) }
+  static func warn(_ message: @autoclosure () -> String) { log(3, "WARN", message()) }
+  static func info(_ message: @autoclosure () -> String) { log(4, "INFO", message()) }
+  static func debug(_ message: @autoclosure () -> String) { log(5, "DEBUG", message()) }
+
+  private static func log(_ threshold: Int, _ tag: String, _ message: String) {
+    guard level >= threshold else { return }
+    NSLog("[QPush] %@: %@", tag, message)
+  }
+}
+
+// MARK: - Storage
+
+/// Key/value storage shared with the JS layer. `app_id`, `server_url` and
+/// `subscription_id` are mirrored into the App Group `group.{bundle_id}.qpush`
+/// so the Notification Service Extension can read them.
+final class QPushStorage {
+  static let shared = QPushStorage()
+
+  static let appIdKey = "app_id"
+  static let serverUrlKey = "server_url"
+  static let subscriptionIdKey = "subscription_id"
+  static let sharedKeys: Set<String> = [appIdKey, serverUrlKey, subscriptionIdKey]
+
+  private static let autoOpenUrlsKey = "qpush_native_auto_open_urls"
+  /// Info.plist switch (Boolean) disabling URL opening on notification tap.
+  private static let suppressLaunchUrlsPlistKey = "QPush_suppress_launch_urls"
+  /// Optional Info.plist override of the App Group name.
+  static let appGroupPlistKey = "QPushAppGroup"
+
+  private let defaults: UserDefaults
+  private let appGroupDefaults: UserDefaults?
+
+  private init() {
+    defaults = UserDefaults(suiteName: "com.qpush.sdk.storage") ?? UserDefaults.standard
+    appGroupDefaults = UserDefaults(suiteName: QPushStorage.appGroupName())
+    // Mirror existing values (e.g. the App Group was added after install).
+    for key in QPushStorage.sharedKeys {
+      if let value = defaults.string(forKey: key), appGroupDefaults?.string(forKey: key) != value {
+        appGroupDefaults?.set(value, forKey: key)
+      }
+    }
+  }
+
+  /// `group.{main app bundle id}.qpush`, overridable with `QPushAppGroup` in Info.plist.
+  static func appGroupName() -> String {
+    if let custom = Bundle.main.object(forInfoDictionaryKey: appGroupPlistKey) as? String, !custom.isEmpty {
+      return custom
+    }
+    let bundleId = Bundle.main.bundleIdentifier ?? ""
+    return "group.\(bundleId).qpush"
+  }
+
+  func string(_ key: String) -> String? {
+    return defaults.string(forKey: key)
+  }
+
+  func set(_ value: String, forKey key: String) {
+    defaults.set(value, forKey: key)
+    if QPushStorage.sharedKeys.contains(key) {
+      appGroupDefaults?.set(value, forKey: key)
+    }
+  }
+
+  func remove(_ key: String) {
+    defaults.removeObject(forKey: key)
+    if QPushStorage.sharedKeys.contains(key) {
+      appGroupDefaults?.removeObject(forKey: key)
+    }
+  }
+
+  var autoOpenUrls: Bool {
+    get {
+      if defaults.object(forKey: QPushStorage.autoOpenUrlsKey) != nil {
+        return defaults.bool(forKey: QPushStorage.autoOpenUrlsKey)
+      }
+      let suppress = Bundle.main.object(forInfoDictionaryKey: QPushStorage.suppressLaunchUrlsPlistKey) as? Bool ?? false
+      return !suppress
+    }
+    set {
+      defaults.set(newValue, forKey: QPushStorage.autoOpenUrlsKey)
+    }
+  }
+}
+
+// MARK: - HTTP
+
+/// Native calls that do not need the JS runtime (notification open / receipt).
+enum QPushHTTP {
+  static let sdkVersion = "qpush-react-native/1.0.0"
+  private static let deviceTypeIOS = 0
+  private static let maxAttempts = 3
+
+  static func reportReceived(notificationId: String) {
+    guard var body = baseBody() else { return }
+    body["device_type"] = deviceTypeIOS
+    put(path: "/notifications/\(encode(notificationId))/report_received", body: body, attempt: 1)
+  }
+
+  static func reportOpened(notificationId: String, actionId: String?) {
+    guard var body = baseBody() else { return }
+    body["opened"] = true
+    body["device_type"] = deviceTypeIOS
+    if let actionId = actionId, !actionId.isEmpty { body["action_id"] = actionId }
+    put(path: "/notifications/\(encode(notificationId))", body: body, attempt: 1)
+  }
+
+  private static func encode(_ segment: String) -> String {
+    var allowed = CharacterSet.urlPathAllowed
+    allowed.remove(charactersIn: "/")
+    return segment.addingPercentEncoding(withAllowedCharacters: allowed) ?? segment
+  }
+
+  static func trimTrailingSlashes(_ value: String) -> String {
+    var result = value
+    while result.hasSuffix("/") { result.removeLast() }
+    return result
+  }
+
+  private static func baseBody() -> [String: Any]? {
+    let storage = QPushStorage.shared
+    guard let appId = storage.string(QPushStorage.appIdKey), !appId.isEmpty else {
+      QPushLog.warn("Cannot report notification event: SDK was never initialized")
+      return nil
+    }
+    var body: [String: Any] = ["app_id": appId]
+    if let subscriptionId = storage.string(QPushStorage.subscriptionIdKey) {
+      body["subscription_id"] = subscriptionId
+    }
+    return body
+  }
+
+  private static func put(path: String, body: [String: Any], attempt: Int) {
+    let storage = QPushStorage.shared
+    guard let base = storage.string(QPushStorage.serverUrlKey), !base.isEmpty,
+          let url = URL(string: QPushHTTP.trimTrailingSlashes(base) + path),
+          let data = try? JSONSerialization.data(withJSONObject: body, options: [])
+    else { return }
+
+    var request = URLRequest(url: url, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: 15)
+    request.httpMethod = "PUT"
+    request.httpBody = data
+    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+    request.setValue("application/json", forHTTPHeaderField: "Accept")
+    request.setValue(sdkVersion, forHTTPHeaderField: "SDK-Version")
+    if let subscriptionId = storage.string(QPushStorage.subscriptionIdKey) {
+      request.setValue(subscriptionId, forHTTPHeaderField: "QPush-Subscription-Id")
+    }
+
+    URLSession.shared.dataTask(with: request) { _, response, error in
+      let status = (response as? HTTPURLResponse)?.statusCode ?? 0
+      QPushLog.debug("PUT \(path) -> \(status)")
+      let retryable = error != nil || status == 429 || status >= 500
+      if retryable && attempt < QPushHTTP.maxAttempts {
+        DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(attempt)) {
+          QPushHTTP.put(path: path, body: body, attempt: attempt + 1)
+        }
+      }
+    }.resume()
+  }
+}
+
+// MARK: - Device info
+
+enum QPushDeviceInfo {
+  static func collect() -> [String: Any] {
+    var info: [String: Any] = ["platform": "ios"]
+    info["deviceModel"] = modelIdentifier()
+    info["deviceOs"] = UIDevice.current.systemVersion
+    if let version = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String {
+      info["appVersion"] = version
+    }
+    info["timezone"] = TimeZone.current.identifier
+    let locale = Locale.preferredLanguages.first ?? Locale.current.identifier
+    info["locale"] = locale
+    if let language = locale.split(whereSeparator: { $0 == "-" || $0 == "_" }).first {
+      info["language"] = String(language).lowercased()
+    }
+    if let country = regionCode() { info["country"] = country }
+    info["rooted"] = false
+    if let testType = provisioningTestType() {
+      info["testType"] = testType
+    } else {
+      info["testType"] = NSNull()
+    }
+    return info
+  }
+
+  private static func regionCode() -> String? {
+    if #available(iOS 16.0, *) {
+      return Locale.current.region?.identifier
+    }
+    return Locale.current.regionCode
+  }
+
+  /// `iPhone15,2`-style identifier (simulator: the simulated model).
+  static func modelIdentifier() -> String {
+    if let simulated = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"] {
+      return simulated
+    }
+    var systemInfo = utsname()
+    uname(&systemInfo)
+    let mirror = Mirror(reflecting: systemInfo.machine)
+    let identifier = mirror.children.reduce(into: "") { result, element in
+      guard let value = element.value as? Int8, value != 0 else { return }
+      result.append(Character(UnicodeScalar(UInt8(value))))
+    }
+    return identifier.isEmpty ? UIDevice.current.model : identifier
+  }
+
+  /// `1` development (sandbox APNs), `2` ad-hoc, `nil` App Store / TestFlight / enterprise.
+  static func provisioningTestType() -> Int? {
+    #if targetEnvironment(simulator)
+    return 1
+    #else
+    guard let path = Bundle.main.path(forResource: "embedded", ofType: "mobileprovision"),
+          let data = FileManager.default.contents(atPath: path),
+          let content = String(data: data, encoding: .isoLatin1),
+          let start = content.range(of: "<?xml"),
+          let end = content.range(of: "</plist>")
+    else {
+      return nil
+    }
+    let plistText = String(content[start.lowerBound..<end.upperBound])
+    guard let plistData = plistText.data(using: .isoLatin1),
+          let plist = (try? PropertyListSerialization.propertyList(from: plistData, options: [], format: nil)) as? [String: Any]
+    else {
+      return nil
+    }
+    let entitlements = plist["Entitlements"] as? [String: Any]
+    if let environment = entitlements?["aps-environment"] as? String, environment == "development" {
+      return 1
+    }
+    if plist["ProvisionedDevices"] != nil {
+      return 2
+    }
+    return nil
+    #endif
+  }
+}

package/ios_nse_template/Info.plist

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>$(DEVELOPMENT_LANGUAGE)</string>
+  <key>CFBundleDisplayName</key>
+  <string>QPushNotificationServiceExtension</string>
+  <key>CFBundleExecutable</key>
+  <string>$(EXECUTABLE_NAME)</string>
+  <key>CFBundleIdentifier</key>
+  <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>$(PRODUCT_NAME)</string>
+  <key>CFBundlePackageType</key>
+  <string>XPC!</string>
+  <key>CFBundleShortVersionString</key>
+  <string>{{VERSION}}</string>
+  <key>CFBundleVersion</key>
+  <string>{{BUILD_NUMBER}}</string>
+  <key>QPushAppGroup</key>
+  <string>{{APP_GROUP}}</string>
+  <key>NSExtension</key>
+  <dict>
+    <key>NSExtensionPointIdentifier</key>
+    <string>com.apple.usernotifications.service</string>
+    <key>NSExtensionPrincipalClass</key>
+    <string>$(PRODUCT_MODULE_NAME).NotificationService</string>
+  </dict>
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<key>NSAllowsLocalNetworking</key>
+		<true/>
+	</dict>
+</dict>
+</plist>

package/ios_nse_template/NotificationService.entitlements

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>com.apple.security.application-groups</key>
+  <array>
+    <string>{{APP_GROUP}}</string>
+  </array>
+</dict>
+</plist>

package/ios_nse_template/NotificationService.swift

@@ -0,0 +1,44 @@
+import UserNotifications
+
+// Provided by the `QPushPushExtension` pod. If you prefer not to use the pod,
+// add `QPushNotificationServiceExtension.swift` (from
+// node_modules/react-native-qpush/ios/Extension/) to this target instead.
+#if canImport(QPushPushExtension)
+import QPushPushExtension
+#endif
+
+class NotificationService: UNNotificationServiceExtension {
+  var contentHandler: ((UNNotificationContent) -> Void)?
+  var receivedRequest: UNNotificationRequest!
+  var bestAttemptContent: UNMutableNotificationContent?
+
+  override func didReceive(
+    _ request: UNNotificationRequest,
+    withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void
+  ) {
+    self.receivedRequest = request
+    self.contentHandler = contentHandler
+    self.bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)
+
+    guard let bestAttemptContent = bestAttemptContent else {
+      contentHandler(request.content)
+      return
+    }
+
+    // Customize `bestAttemptContent` here if you need to, then let QPush
+    // attach the image, register the action buttons and confirm delivery.
+    QPushNotificationServiceExtension.didReceiveNotificationExtensionRequest(
+      request,
+      with: bestAttemptContent,
+      withContentHandler: contentHandler
+    )
+  }
+
+  override func serviceExtensionTimeWillExpire() {
+    // Called just before the extension is terminated: deliver what we have.
+    guard let contentHandler = contentHandler, let bestAttemptContent = bestAttemptContent else { return }
+    if QPushNotificationServiceExtension.serviceExtensionTimeWillExpireRequest(receivedRequest, with: bestAttemptContent) {
+      contentHandler(bestAttemptContent)
+    }
+  }
+}

package/lib/NativeQPushPush.d.ts

@@ -0,0 +1,44 @@
+/**
+ * TurboModule spec of the native module `QPushPush`.
+ *
+ * The native implementations are classic bridge modules
+ * (`ReactContextBaseJavaModule` / `RCTEventEmitter`). They work on the old
+ * architecture and, through React Native's interop layer, on the New
+ * Architecture / bridgeless mode. This spec documents the contract and gives
+ * typed access through `TurboModuleRegistry` (which falls back to
+ * `NativeModules` on the old architecture). Codegen is intentionally not
+ * configured in package.json, so no generated code is required at build time.
+ */
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    /** DeviceInfo (see src/core/subscription.ts). */
+    getDeviceInfo(): Promise<Object>;
+    /**
+     * Android: FCM params from android_params.js (or null for the default
+     * FirebaseApp). iOS: ignored. Resolves `{ token, notificationTypes?, error? }`.
+     */
+    registerForPush(fcmParams: Object | null): Promise<Object>;
+    /** 'notDetermined' | 'denied' | 'granted' | 'provisional' | 'ephemeral' */
+    getPermissionStatus(): Promise<string>;
+    requestPermission(fallbackToSettings: boolean): Promise<boolean>;
+    registerForProvisionalAuthorization(): Promise<boolean>;
+    canRequestPermission(): Promise<boolean>;
+    clearAll(): void;
+    removeNotification(notificationId: string): void;
+    removeGroupedNotifications(groupKey: string): void;
+    clearBadge(): Promise<number>;
+    setJsReady(): void;
+    displayForegroundNotification(displayId: string): void;
+    preventForegroundDisplay(displayId: string): void;
+    setAutoOpenUrls(enabled: boolean): void;
+    setLogLevel(level: number): void;
+    beginBackgroundTask(): Promise<number>;
+    endBackgroundTask(taskId: number): void;
+    addListener(eventName: string): void;
+    removeListeners(count: number): void;
+}
+declare const _default: Spec | null;
+export default _default;

package/lib/NativeQPushPush.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+exports.default = react_native_1.TurboModuleRegistry.get('QPushPush');

package/lib/QPush.d.ts

@@ -0,0 +1,117 @@
+import { QPushCore } from './core/QPushCore';
+import type { PlatformAdapter } from './core/platform';
+import type { NotificationClickEvent, NotificationWillDisplayEvent } from './notification';
+import type { QPushInitOptions, LogLevel, NotificationPermission, PushSubscriptionChangedState, UserChangedState } from './types';
+/** Events of `QPush.Notifications.addEventListener`. */
+export interface NotificationEventTypeMap {
+    click: NotificationClickEvent;
+    foregroundWillDisplay: NotificationWillDisplayEvent;
+    permissionChange: boolean;
+}
+export type NotificationEventName = keyof NotificationEventTypeMap;
+/** Events of `QPush.User.pushSubscription.addEventListener`. */
+export interface PushSubscriptionEventTypeMap {
+    change: PushSubscriptionChangedState;
+}
+/** Events of `QPush.User.addEventListener`. */
+export interface UserEventTypeMap {
+    change: UserChangedState;
+}
+/** @internal Testing hook: replaces the platform used by the singleton. */
+export declare function __setPlatformFactoryForTests(factory: () => PlatformAdapter): QPushCore;
+/**
+ * QPush SDK entry point.
+ *
+ * ```ts
+ * QPush.initialize('APP_ID'); // qpush cloud: https://qpush.dev/api/v1
+ * await QPush.Notifications.requestPermission(true);
+ * QPush.login('user-123');
+ * ```
+ */
+export declare const QPush: {
+    /**
+     * Initializes the SDK. Call once, as early as possible (e.g. in index.js or
+     * your root component). Safe to call API methods right after it.
+     */
+    initialize(appId: string, options?: QPushInitOptions): void;
+    /** Identifies the current user with your user id (`external_id`). */
+    login(externalId: string): void;
+    /** Detaches the device from the identified user (a new anonymous user is created). */
+    logout(): void;
+    /** When `true`, nothing is sent until `setConsentGiven(true)`. Call before `initialize`. */
+    setConsentRequired(required: boolean): void;
+    setConsentGiven(given: boolean): void;
+    Debug: {
+        /** Sets the SDK log level (JS console and native logs). */
+        setLogLevel(level: LogLevel): void;
+    };
+    Notifications: {
+        /**
+         * Shows the OS permission prompt (Android 13+ / iOS). With
+         * `fallbackToSettings`, opens the app notification settings when the
+         * prompt can no longer be shown (permission permanently denied).
+         */
+        requestPermission(fallbackToSettings?: boolean): Promise<boolean>;
+        /** `true` when the app can currently display notifications. */
+        getPermissionAsync(): Promise<boolean>;
+        /** Detailed native permission state. */
+        permissionNative(): Promise<NotificationPermission>;
+        /** `true` when calling `requestPermission` would show the OS prompt. */
+        canRequestPermission(): Promise<boolean>;
+        /** iOS 12+: quiet "provisional" authorization without a prompt. Android: same as getPermissionAsync. */
+        registerForProvisionalAuthorization(): Promise<boolean>;
+        addEventListener<K extends NotificationEventName>(event: K, listener: (event: NotificationEventTypeMap[K]) => void): void;
+        removeEventListener<K extends NotificationEventName>(event: K, listener: (event: NotificationEventTypeMap[K]) => void): void;
+        /** Removes every QPush notification from the notification center and clears the badge. */
+        clearAll(): void;
+        /** Removes a single notification by its QPush notification id. */
+        removeNotification(notificationId: string): void;
+        /** Removes the notifications of a group (Android group / iOS thread-id). */
+        removeGroupedNotifications(groupKey: string): void;
+        /**
+         * Enables / disables opening the notification URL on tap (default enabled).
+         * Persisted natively, so it also applies to cold-start taps on next launches.
+         * Build-time switch: Android manifest meta-data `com.qpush.suppressLaunchURLs`
+         * / iOS Info.plist `QPush_suppress_launch_urls`.
+         */
+        setAutoOpenUrls(enabled: boolean): void;
+    };
+    User: {
+        pushSubscription: {
+            /** Subscription id of this device, `null` until the server created it. */
+            getIdAsync(): Promise<string | null>;
+            /** FCM token (Android) / hex APNs token (iOS). */
+            getTokenAsync(): Promise<string | null>;
+            /** `true` when the device can receive pushes (permission + token + not opted out). */
+            getOptedInAsync(): Promise<boolean>;
+            /** Re-enables pushes; prompts for permission when it was never asked. */
+            optIn(): void;
+            /** Disables pushes for this device without touching the OS permission. */
+            optOut(): void;
+            addEventListener<K extends keyof PushSubscriptionEventTypeMap>(_event: K, listener: (event: PushSubscriptionEventTypeMap[K]) => void): void;
+            removeEventListener<K extends keyof PushSubscriptionEventTypeMap>(_event: K, listener: (event: PushSubscriptionEventTypeMap[K]) => void): void;
+        };
+        /** Adds or updates a tag. Values are stored as strings. */
+        addTag(key: string, value: string | number | boolean): void;
+        addTags(tags: Record<string, string | number | boolean>): void;
+        removeTag(key: string): void;
+        removeTags(keys: string[]): void;
+        /** Local copy of the user's tags (refreshed from the server on app start and login). */
+        getTags(): Promise<Record<string, string>>;
+        /** Adds a custom alias (e.g. `crm_id`). Use `QPush.login` for `external_id`. */
+        addAlias(label: string, id: string): void;
+        addAliases(aliases: Record<string, string>): void;
+        removeAlias(label: string): void;
+        removeAliases(labels: string[]): void;
+        /** ISO 639-1 language code, e.g. `pt`. Defaults to the device language. */
+        setLanguage(language: string): void;
+        /** QPush user id (`qpush_id`), `null` until the server created the user. */
+        getQPushId(): Promise<string | null>;
+        /** Alias of `getQPushId` for code migrated from OneSignal. */
+        getOnesignalId(): Promise<string | null>;
+        getExternalId(): Promise<string | null>;
+        addEventListener<K extends keyof UserEventTypeMap>(_event: K, listener: (event: UserEventTypeMap[K]) => void): void;
+        removeEventListener<K extends keyof UserEventTypeMap>(_event: K, listener: (event: UserEventTypeMap[K]) => void): void;
+    };
+};
+export type QPushType = typeof QPush;