react-native-smartlinks 2.0.0

package/ios/Linklytics/Models/OfflineEvent.swift

@@ -0,0 +1,80 @@
+import Foundation
+
+public struct AnyCodable: Codable {
+    public let value: Any
+
+    public init(_ value: Any) {
+        self.value = value
+    }
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.singleValueContainer()
+        if let x = try? container.decode(String.self) {
+            value = x
+        } else if let x = try? container.decode(Int.self) {
+            value = x
+        } else if let x = try? container.decode(Double.self) {
+            value = x
+        } else if let x = try? container.decode(Bool.self) {
+            value = x
+        } else if let x = try? container.decode([String: AnyCodable].self) {
+            value = x.mapValues { $0.value }
+        } else if let x = try? container.decode([AnyCodable].self) {
+            value = x.map { $0.value }
+        } else {
+            throw DecodingError.dataCorruptedError(in: container, debugDescription: "AnyCodable value cannot be decoded")
+        }
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.singleValueContainer()
+        if let x = value as? String {
+            try container.encode(x)
+        } else if let x = value as? Int {
+            try container.encode(x)
+        } else if let x = value as? Double {
+            try container.encode(x)
+        } else if let x = value as? Bool {
+            try container.encode(x)
+        } else if let x = value as? [String: Any] {
+            try container.encode(x.mapValues { AnyCodable($0) })
+        } else if let x = value as? [Any] {
+            try container.encode(x.map { AnyCodable($0) })
+        } else {
+            throw EncodingError.invalidValue(value, EncodingError.Context(codingPath: container.codingPath, debugDescription: "AnyCodable value cannot be encoded"))
+        }
+    }
+}
+
+public struct OfflineEvent: Codable {
+    let id: String
+    let eventName: String
+    let parameters: [String: AnyCodable]
+    let deviceInfo: [String: AnyCodable]
+    let timestamp: Int64
+    var retryCount: Int
+    let appUserId: String?
+    let isDebug: Bool
+
+    init(eventName: String, parameters: [String: Any], deviceInfo: [String: Any] = [:], timestamp: Int64 = Int64(Date().timeIntervalSince1970 * 1000), appUserId: String? = nil, isDebug: Bool = false) {
+        self.id = UUID().uuidString
+        self.eventName = eventName
+        self.parameters = parameters.mapValues { AnyCodable($0) }
+        self.deviceInfo = deviceInfo.mapValues { AnyCodable($0) }
+        self.timestamp = timestamp
+        self.retryCount = 0
+        self.appUserId = appUserId
+        self.isDebug = isDebug
+    }
+
+    init(id: String, eventName: String, parameters: [String: AnyCodable], deviceInfo: [String: AnyCodable], timestamp: Int64, retryCount: Int, appUserId: String?, isDebug: Bool) {
+        self.id = id
+        self.eventName = eventName
+        self.parameters = parameters
+        self.deviceInfo = deviceInfo
+        self.timestamp = timestamp
+        self.retryCount = retryCount
+        self.appUserId = appUserId
+        self.isDebug = isDebug
+    }
+}

package/ios/Linklytics/NetworkManager.swift

@@ -0,0 +1,360 @@
+import Foundation
+
+class NetworkManager {
+    
+    // MARK: - Properties
+    private let urlSession: URLSession
+    private let apiKey: String
+    private let isDebugMode: Bool
+    
+    // MARK: - Initialization
+    init(apiKey: String, debugMode: Bool = false) {
+        self.apiKey = apiKey
+        self.isDebugMode = debugMode
+        
+        let config = URLSessionConfiguration.default
+        config.timeoutIntervalForRequest = 30
+        config.timeoutIntervalForResource = 60
+        self.urlSession = URLSession(configuration: config)
+    }
+    
+    // MARK: - Public Methods
+    
+    // MARK: - Public Methods
+    
+    func sendEvent(event: OfflineEvent, completion: @escaping (Result<Data?, Error>) -> Void) {
+        let endpoint = SdkConstants.getEventEndpoint(version: Linklytics.apiVersionString)
+        
+        guard let url = URL(string: endpoint) else {
+            completion(.failure(NetworkError.invalidURL))
+            return
+        }
+        
+        // Prepare body with metadata
+        let requestBody: [String: Any] = [
+            "event_name": event.eventName,
+            "params": event.parameters.mapValues { $0.value },
+            "device_info": event.deviceInfo.mapValues { $0.value },
+            "event_id": event.id,
+            "timestamp": event.timestamp,
+            "debug": event.isDebug
+        ]
+        
+        sendRequest(url: url, body: requestBody, completion: completion)
+    }
+
+    func sendEvent(eventName: String, parameters: [String: Any], completion: @escaping (Result<Data?, Error>) -> Void) {
+        // Legacy/Direct support helper -> routes to new logic if needed, or just wraps creation
+        // But for consistency we should use the new sendEvent(event:) internally if possible, 
+        // OR just duplicate logic. Since BatchEventManager creates OfflineEvents, 
+        // let's update this to create a temporary OfflineEvent for consistency?
+        // Actually, just keep direct implementation but add ID/Timestamp
+        
+        let endpoint = SdkConstants.getEventEndpoint(version: Linklytics.apiVersionString)
+         guard let url = URL(string: endpoint) else {
+            completion(.failure(NetworkError.invalidURL))
+            return
+        }
+        
+        let requestBody: [String: Any] = [
+            "event_name": eventName,
+            "params": parameters,
+            "event_id": UUID().uuidString,
+            "timestamp": Int64(Date().timeIntervalSince1970 * 1000)
+        ]
+        
+        sendRequest(url: url, body: requestBody, completion: completion)
+    }
+    
+    func sendBatchEvents(events: [OfflineEvent], appUserId: String? = nil, debug: Bool? = nil, completion: @escaping (Result<Data?, Error>) -> Void) {
+        let endpoint = SdkConstants.getBatchEventsEndpoint(version: Linklytics.apiVersionString)
+        
+         guard let url = URL(string: endpoint) else {
+            completion(.failure(NetworkError.invalidURL))
+            return
+        }
+        
+        let eventsList = events.map { event -> [String: Any] in
+            return [
+                "event_name": event.eventName,
+                "params": event.parameters.mapValues { $0.value },
+                "device_info": event.deviceInfo.mapValues { $0.value },
+                "event_id": event.id,
+                "timestamp": event.timestamp,
+                "debug": event.isDebug
+            ]
+        }
+        
+        var requestBody: [String: Any] = [
+            "events": eventsList
+        ]
+        
+        if let appUserId = appUserId {
+            requestBody["app_user_id"] = appUserId
+        }
+        
+        if let debug = debug {
+            requestBody["debug"] = debug
+        }
+        
+        sendRequest(url: url, body: requestBody, completion: completion)
+    }
+    
+    private func sendRequest(url: URL, body: [String: Any], completion: @escaping (Result<Data?, Error>) -> Void) {
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: body) else {
+            completion(.failure(NetworkError.serializationError))
+            return
+        }
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue(apiKey, forHTTPHeaderField: "api-key")
+        request.httpBody = jsonData
+        
+        if isDebugMode {
+            print("Linklytics: Sending HTTP request to \(url.absoluteString)")
+             if let jsonString = String(data: jsonData, encoding: .utf8) {
+                print("Linklytics: Request body: \(jsonString)")
+            }
+        }
+        
+        urlSession.dataTask(with: request) { [weak self] data, response, error in
+            if let error = error {
+                if self?.isDebugMode == true {
+                    print("Linklytics: Request failed: \(error)")
+                }
+                completion(.failure(error))
+                return
+            }
+            
+            if let httpResponse = response as? HTTPURLResponse {
+                if self?.isDebugMode == true {
+                    print("Linklytics: Response code: \(httpResponse.statusCode)")
+                }
+                // Check for 200..299
+                if !(200...299).contains(httpResponse.statusCode) {
+                    // Create error based on status
+                    // For now just continue, but logically this might be a server error we should retry?
+                    // BatchEventManager handles retry on failure result.
+                    // If we return success here for 500, we won't retry.
+                    // So we should return failure for non-200.
+                     completion(.failure(NSError(domain: "Linklytics", code: httpResponse.statusCode, userInfo: nil)))
+                     return
+                }
+            }
+            
+            completion(.success(data))
+        }.resume()
+    }
+
+    // Keep existing fetchDeferredLink and others...
+    
+    func fetchDeferredLink(fingerprint: String, appUserId: String, deviceInfo: [String: String], completion: @escaping (Result<Data?, Error>) -> Void) {
+        let endpoint = SdkConstants.getDeferredLinksEndpoint(version: Linklytics.apiVersionString)
+        
+        guard let url = URL(string: endpoint) else {
+            completion(.failure(NetworkError.invalidURL))
+            return
+        }
+        
+        let requestBody: [String: Any] = [
+            "fingerprint": fingerprint,
+            "app_user_id": appUserId,
+            "platform": "ios",
+            "device_info": deviceInfo
+        ]
+        
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: requestBody) else {
+            completion(.failure(NetworkError.serializationError))
+            return
+        }
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue(apiKey, forHTTPHeaderField: "api-key")
+        request.httpBody = jsonData
+        
+        if isDebugMode {
+            print("Linklytics: Fetching deferred deep link from \(endpoint)")
+            if let jsonString = String(data: jsonData, encoding: .utf8) {
+                print("Linklytics: Request body: \(jsonString)")
+            }
+        }
+        
+        urlSession.dataTask(with: request) { [weak self] data, response, error in
+            if let error = error {
+                completion(.failure(error))
+                return
+            }
+            
+            guard let data = data else {
+                completion(.failure(NetworkError.noData))
+                return
+            }
+            
+            if let httpResponse = response as? HTTPURLResponse {
+                if self?.isDebugMode == true {
+                    print("Linklytics: Deferred link response code: \(httpResponse.statusCode)")
+                    if let bodyString = String(data: data, encoding: .utf8) {
+                        print("Linklytics: Deferred link response body: \(bodyString)")
+                    } else {
+                        print("Linklytics: Deferred link response body: <non-UTF8 data, size=\(data.count) bytes>")
+                    }
+                }
+                if httpResponse.statusCode == 404 || httpResponse.statusCode == 204 {
+                    completion(.failure(NetworkError.noData))
+                    return
+                }
+            }
+            
+            completion(.success(data))
+        }.resume()
+    }
+    
+    func generateDynamicLink(url: String, parameters: [String: String]?, completion: @escaping (Result<DynamicLinkResponse, Error>) -> Void) {
+        let endpoint = SdkConstants.getDynamicLinksEndpoint(version: Linklytics.apiVersionString)
+        
+        guard let requestURL = URL(string: endpoint) else {
+            completion(.failure(NetworkError.invalidURL))
+            return
+        }
+        
+        let requestBody: [String: Any] = [
+            "route": url,
+            "params": parameters ?? [:],
+        ]
+        
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: requestBody) else {
+            completion(.failure(NetworkError.serializationError))
+            return
+        }
+        
+        var request = URLRequest(url: requestURL)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue(apiKey, forHTTPHeaderField: "api-key")
+        request.httpBody = jsonData
+        
+        if isDebugMode {
+            print("Linklytics: Generating dynamic link at \(endpoint)")
+            print("Linklytics: Input parameters: \(parameters ?? [:])")
+            print("Linklytics: Request body object: \(requestBody)")
+            if let jsonString = String(data: jsonData, encoding: .utf8) {
+                print("Linklytics: Request body JSON: \(jsonString)")
+            }
+        }
+        
+        urlSession.dataTask(with: request) { [weak self] data, response, error in
+            if let error = error {
+                if self?.isDebugMode == true {
+                    print("Linklytics: Failed to generate dynamic link, error: \(error)")
+                }
+                completion(.failure(error))
+                return
+            }
+            
+            guard let data = data else {
+                completion(.failure(NetworkError.noData))
+                return
+            }
+            
+            if let httpResponse = response as? HTTPURLResponse {
+                if self?.isDebugMode == true {
+                    print("Linklytics: Dynamic link response code: \(httpResponse.statusCode)")
+                    if let bodyString = String(data: data, encoding: .utf8) {
+                        print("Linklytics: Dynamic link response body: \(bodyString)")
+                    } else {
+                        print("Linklytics: Dynamic link response body: <non-UTF8 data, size=\(data.count) bytes>")
+                    }
+                }
+            }
+            
+            do {
+                let dynamicLinkResponse = try JSONDecoder().decode(DynamicLinkResponse.self, from: data)
+                completion(.success(dynamicLinkResponse))
+            } catch {
+                if self?.isDebugMode == true {
+                    print("Linklytics: Failed to decode dynamic link response: \(error)")
+                }
+                completion(.failure(error))
+            }
+        }.resume()
+    }
+    
+    func getApp(completion: @escaping (Result<AppResponse, Error>) -> Void) {
+        let endpoint = SdkConstants.getAppEndpoint(version: Linklytics.apiVersionString)
+        
+        guard let url = URL(string: endpoint) else {
+            completion(.failure(NetworkError.invalidURL))
+            return
+        }
+        
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue(apiKey, forHTTPHeaderField: "api-key")
+        
+        if isDebugMode {
+            print("Linklytics: Getting app info from \(endpoint)")
+        }
+        
+        urlSession.dataTask(with: request) { [weak self] data, response, error in
+            if let error = error {
+                if self?.isDebugMode == true {
+                    print("Linklytics: Failed to get app info, error: \(error)")
+                }
+                completion(.failure(error))
+                return
+            }
+            
+            guard let data = data else {
+                completion(.failure(NetworkError.noData))
+                return
+            }
+            
+            if let httpResponse = response as? HTTPURLResponse {
+                if self?.isDebugMode == true {
+                    print("Linklytics: App info response code: \(httpResponse.statusCode)")
+                    if let bodyString = String(data: data, encoding: .utf8) {
+                        print("Linklytics: App info response body: \(bodyString)")
+                    } else {
+                        print("Linklytics: App info response body: <non-UTF8 data, size=\(data.count) bytes>")
+                    }
+                }
+            }
+            
+            do {
+                let appResponse = try JSONDecoder().decode(AppResponse.self, from: data)
+                completion(.success(appResponse))
+            } catch {
+                if self?.isDebugMode == true {
+                    print("Linklytics: Failed to decode app response: \(error)")
+                }
+                completion(.failure(error))
+            }
+        }.resume()
+    }
+}
+
+// MARK: - Network Errors
+enum NetworkError: Error {
+    case invalidURL
+    case serializationError
+    case noData
+    case notImplemented
+    
+    var localizedDescription: String {
+        switch self {
+        case .invalidURL:
+            return "Invalid URL"
+        case .serializationError:
+            return "Failed to serialize request data"
+        case .noData:
+            return "No data received"
+        case .notImplemented:
+            return "Feature not implemented"
+        }
+    }
+}

package/ios/Linklytics/SdkConstants.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+struct SdkConstants {
+    static let baseURL = "https://smartlinks.live"
+    private static let eventsEndpointVersioned = "/api/version/events"
+    private static let deferredLinksEndpoint = "/api/version/deferred-links"
+    private static let dynamicLinksEndpoint = "/api/version/links/create"
+    private static let appEndpoint = "/api/version/app"
+
+    static func getEventEndpoint(version: String) -> String {
+        return baseURL + eventsEndpointVersioned.replacingOccurrences(of: "version", with: version)
+    }
+
+    static func getDeferredLinksEndpoint(version: String) -> String {
+        return baseURL + deferredLinksEndpoint.replacingOccurrences(of: "version", with: version)
+    }
+
+    static func getDynamicLinksEndpoint(version: String) -> String {
+        return baseURL + dynamicLinksEndpoint.replacingOccurrences(of: "version", with: version)
+    }
+
+    static func getAppEndpoint(version: String) -> String {
+        return baseURL + appEndpoint.replacingOccurrences(of: "version", with: version)
+    }
+
+    static func getBatchEventsEndpoint(version: String) -> String {
+        return baseURL + eventsEndpointVersioned.replacingOccurrences(of: "version", with: version) + "/batch"
+    }
+}

package/ios/PrivacyInfo.xcprivacy

@@ -0,0 +1,14 @@
+<?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>NSPrivacyTrackingDomains</key>
+	<array/>
+	<key>NSPrivacyAccessedAPITypes</key>
+	<array/>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array/>
+	<key>NSPrivacyTracking</key>
+	<false/>
+</dict>
+</plist>

package/ios/SmartLinksModule.m

@@ -0,0 +1,150 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(SmartLinks, SmartLinksModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initialize:(NSString *)apiKey
+                  debugMode:(BOOL)debugMode
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getAppUserId:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(sendEvent:(NSString *)eventName
+                  params:(NSDictionary *)params
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(generateLink:(NSString *)route
+                  params:(NSDictionary *)params
+                  shortLink:(BOOL)shortLink
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(registerLinkListener:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(fetchApps:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(submitFeedback:(NSDictionary *)args
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(fetchAds:(NSString *)type
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(trackAdImpression:(nonnull NSNumber *)adId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(trackAdClick:(nonnull NSNumber *)adId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(processAi:(NSString *)instructionsJson
+                  files:(NSDictionary *)files
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(validatePromoCode:(NSString *)code
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(redeemPromoCode:(NSString *)code
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(verifyGooglePurchase:(NSString *)productId
+                  token:(NSString *)token
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(verifyApplePurchase:(NSString *)receiptData
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getCommunities:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getPosts:(nonnull NSNumber *)communityId
+                  authToken:(NSString *)authToken
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(socialAuthGoogle:(NSString *)accessToken
+                  project:(NSString *)project
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getBlogs:(nonnull NSNumber *)page
+                  search:(NSString *)search
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getBlogPost:(NSString *)slug
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getCommunity:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(togglePostLike:(nonnull NSNumber *)postId
+                  authToken:(NSString *)authToken
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(createPost:(NSString *)communityId
+                  title:(NSString *)title
+                  content:(NSString *)content
+                  authToken:(NSString *)authToken
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(socialAuthApple:(NSString *)accessToken
+                  project:(NSString *)project
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getComments:(NSString *)postId
+                  authToken:(NSString *)authToken
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(createComment:(NSString *)postId
+                  content:(NSString *)content
+                  authToken:(NSString *)authToken
+                  parentId:(NSString *)parentId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(toggleCommentLike:(NSString *)commentId
+                  authToken:(NSString *)authToken
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(fetchActiveNotificationAd:(NSNumber *)appId
+                  language:(NSString *)language
+                  isDebug:(BOOL)isDebug
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(registerDevice:(NSString *)fcmToken
+                  platform:(NSString *)platform
+                  deviceType:(NSString *)deviceType
+                  appVersion:(NSString *)appVersion
+                  language:(NSString *)language
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(trackNotificationAdImpression:(nonnull NSNumber *)adId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(trackNotificationAdClick:(nonnull NSNumber *)adId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end