affise-attribution-lib 1.0.0

package/android/src/main/java/com/affise/attribution/react/factories/AffiseSubtypeEventsFactory.kt

@@ -0,0 +1,266 @@
+package com.affise.attribution.react.factories
+
+import com.affise.attribution.events.Event
+import com.affise.attribution.events.subscription.*
+import com.affise.attribution.react.ext.toJSONObject
+import org.json.JSONObject
+
+class AffiseSubtypeEventsFactory : AffiseBaseEvensFactory() {
+
+    override fun event(map: Map<*, *>?): Event? {
+        return when (map?.get(KEY_SUBTYPE)) {
+            SubscriptionParameters.AFFISE_SUB_INITIAL_SUBSCRIPTION -> eventInitialSubscriptionEvent(map)
+            SubscriptionParameters.AFFISE_SUB_INITIAL_TRIAL -> eventInitialTrialEvent(map)
+            SubscriptionParameters.AFFISE_SUB_INITIAL_OFFER -> eventInitialOfferEvent(map)
+            SubscriptionParameters.AFFISE_SUB_FAILED_TRIAL -> eventFailedTrialEvent(map)
+            SubscriptionParameters.AFFISE_SUB_FAILED_OFFERISE -> eventFailedOfferiseEvent(map)
+            SubscriptionParameters.AFFISE_SUB_FAILED_SUBSCRIPTION -> eventFailedSubscriptionEvent(map)
+            SubscriptionParameters.AFFISE_SUB_FAILED_TRIAL_FROM_RETRY -> eventFailedTrialFromRetryEvent(map)
+            SubscriptionParameters.AFFISE_SUB_FAILED_OFFER_FROM_RETRY -> eventFailedOfferFromRetryEvent(map)
+            SubscriptionParameters.AFFISE_SUB_FAILED_SUBSCRIPTION_FROM_RETRY -> eventFailedSubscriptionFromRetryEvent(map)
+            SubscriptionParameters.AFFISE_SUB_TRIAL_IN_RETRY -> eventTrialInRetryEvent(map)
+            SubscriptionParameters.AFFISE_SUB_OFFER_IN_RETRY -> eventOfferInRetryEvent(map)
+            SubscriptionParameters.AFFISE_SUB_SUBSCRIPTION_IN_RETRY -> eventSubscriptionInRetryEvent(map)
+            SubscriptionParameters.AFFISE_SUB_CONVERTED_TRIAL -> eventConvertedTrialEvent(map)
+            SubscriptionParameters.AFFISE_SUB_CONVERTED_OFFER -> eventConvertedOfferEvent(map)
+            SubscriptionParameters.AFFISE_SUB_REACTIVATED_SUBSCRIPTION -> eventReactivatedSubscriptionEvent(map)
+            SubscriptionParameters.AFFISE_SUB_RENEWED_SUBSCRIPTION -> eventRenewedSubscriptionEvent(map)
+            SubscriptionParameters.AFFISE_SUB_CONVERTED_TRIAL_FROM_RETRY -> eventConvertedTrialFromRetryEvent(map)
+            SubscriptionParameters.AFFISE_SUB_CONVERTED_OFFER_FROM_RETRY -> eventConvertedOfferFromRetryEvent(map)
+            SubscriptionParameters.AFFISE_SUB_RENEWED_SUBSCRIPTION_FROM_RETRY -> eventRenewedSubscriptionFromRetryEvent(map)
+            else -> null
+        }
+    }
+
+    private fun getDataJSONObject(map: Map<*, *>): JSONObject {
+        return (map[KEY_DATA] as? Map<*, *>)?.toJSONObject() ?: JSONObject()
+    }
+
+    private fun eventInitialSubscriptionEvent(map: Map<*, *>): InitialSubscriptionEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return InitialSubscriptionEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventInitialTrialEvent(map: Map<*, *>): InitialTrialEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return InitialTrialEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventInitialOfferEvent(map: Map<*, *>): InitialOfferEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return InitialOfferEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventFailedTrialEvent(map: Map<*, *>): FailedTrialEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return FailedTrialEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventFailedOfferiseEvent(map: Map<*, *>): FailedOfferiseEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return FailedOfferiseEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventFailedSubscriptionEvent(map: Map<*, *>): FailedSubscriptionEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return FailedSubscriptionEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventFailedTrialFromRetryEvent(map: Map<*, *>): FailedTrialFromRetryEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return FailedTrialFromRetryEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventFailedOfferFromRetryEvent(map: Map<*, *>): FailedOfferFromRetryEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return FailedOfferFromRetryEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventFailedSubscriptionFromRetryEvent(map: Map<*, *>): FailedSubscriptionFromRetryEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return FailedSubscriptionFromRetryEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventTrialInRetryEvent(map: Map<*, *>): TrialInRetryEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return TrialInRetryEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventOfferInRetryEvent(map: Map<*, *>): OfferInRetryEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return OfferInRetryEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventSubscriptionInRetryEvent(map: Map<*, *>): SubscriptionInRetryEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return SubscriptionInRetryEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventConvertedTrialEvent(map: Map<*, *>): ConvertedTrialEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return ConvertedTrialEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventConvertedOfferEvent(map: Map<*, *>): ConvertedOfferEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return ConvertedOfferEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventReactivatedSubscriptionEvent(map: Map<*, *>): ReactivatedSubscriptionEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return ReactivatedSubscriptionEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventRenewedSubscriptionEvent(map: Map<*, *>): RenewedSubscriptionEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return RenewedSubscriptionEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventConvertedTrialFromRetryEvent(map: Map<*, *>): ConvertedTrialFromRetryEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return ConvertedTrialFromRetryEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventConvertedOfferFromRetryEvent(map: Map<*, *>): ConvertedOfferFromRetryEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return ConvertedOfferFromRetryEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+
+    private fun eventRenewedSubscriptionFromRetryEvent(map: Map<*, *>): RenewedSubscriptionFromRetryEvent {
+        val userData = getUserData(map)
+        val data = getDataJSONObject(map)
+
+        return RenewedSubscriptionFromRetryEvent(
+            data,
+            userData,
+        ).apply {
+            addPredefinedParameters(this, map)
+        }
+    }
+}

package/ios/AffiseAttributionNative-Bridging-Header.h

@@ -0,0 +1,3 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>
+#import <React/RCTEventEmitter.h>

package/ios/AffiseAttributionNative.m

@@ -0,0 +1,90 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(AffiseAttributionNative, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(
+  nativeInit: (NSDictionary)initProperties
+)
+
+RCT_EXTERN_METHOD(
+  nativeSendEvent: (NSDictionary)event
+)
+
+RCT_EXTERN_METHOD(
+  nativeSendEvents
+)
+
+RCT_EXTERN_METHOD(
+  nativeAddPushToken: (NSString)pushToken
+)
+
+RCT_EXTERN_METHOD(
+  nativeRegisterWebView
+)
+
+RCT_EXTERN_METHOD(
+  nativeUnregisterWebView
+)
+
+RCT_EXTERN_METHOD(
+  nativeRegisterDeeplinkCallback
+)
+
+RCT_EXTERN_METHOD(
+  nativeSetSecretId: (NSString)secretId
+)
+
+RCT_EXTERN_METHOD(
+  nativeSetAutoCatchingTypes: (NSArray)types
+)
+
+RCT_EXTERN_METHOD(
+  nativeSetOfflineModeEnabled: (BOOL)enabled
+)
+
+RCT_EXTERN_METHOD(
+  nativeIsOfflineModeEnabled:
+  (RCTPromiseResolveBlock)resolve
+  withRejecter: (RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(
+  nativeSetBackgroundTrackingEnabled: (BOOL)enabled
+)
+
+RCT_EXTERN_METHOD(
+  nativeIsBackgroundTrackingEnabled:
+  (RCTPromiseResolveBlock)resolve
+  withRejecter: (RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(
+  nativeSetTrackingEnabled: (BOOL)enabled
+)
+
+RCT_EXTERN_METHOD(
+  nativeIsTrackingEnabled:
+  (RCTPromiseResolveBlock)resolve
+  withRejecter: (RCTPromiseRejectBlock)reject
+)
+
+RCT_EXTERN_METHOD(
+  nativeForget: (NSString)userData
+)
+
+RCT_EXTERN_METHOD(
+  nativeSetEnabledMetrics: (BOOL)enabled
+)
+
+RCT_EXTERN_METHOD(
+  nativeCrashApplication
+)
+
+RCT_EXTERN_METHOD(
+  nativeGetReferrer:
+  (RCTPromiseResolveBlock)resolve
+  withRejecter: (RCTPromiseRejectBlock)reject
+)
+
+@end

package/ios/AffiseAttributionNative.swift

@@ -0,0 +1,148 @@
+import AffiseAttributionLib
+import React
+
+
+@objc(AffiseAttributionNative)
+class AffiseAttributionNative: RCTEventEmitter {
+
+    static private let DEEPLINK_CALLBACK_EVENT = "affiseDeeplinkEvent"
+    static private let DEEPLINK_CALLBACK_URI_PARAMETER = "uri"
+    
+    var app: UIApplication? = nil
+    var launchOptions: [UIApplication.LaunchOptionsKey: Any]?
+
+    private let evensFactory: AffiseEvensFactory = AffiseEvensFactory()
+    
+    @objc
+    override static func requiresMainQueueSetup() -> Bool{
+        return true;
+    }
+
+    @objc
+    override func constantsToExport() -> [AnyHashable: Any]!{
+        return [:];
+    }
+    
+    override func supportedEvents() -> [String]! {
+        return [AffiseAttributionNative.DEEPLINK_CALLBACK_EVENT];
+    }
+
+    @objc(nativeInit:)
+    public func nativeInit(initProperties: NSDictionary) -> Void {       
+        app = UIApplication.shared
+        launchOptions = bridge.launchOptions as? [UIApplication.LaunchOptionsKey: Any]
+        if app == nil {
+            RCTLogWarn("Affise init UIApplication not found")
+            return
+        }
+        if let properties = (initProperties as? [String: Any?])?.toAffiseInitProperties {
+            Affise.shared.load(app: app!, initProperties: properties, launchOptions: launchOptions)
+        } else {
+            RCTLogWarn("Affise init properties parse \(initProperties)")
+        }
+    }
+    
+    @objc(nativeSendEvent:)
+    public func nativeSendEvent(event: NSDictionary) -> Void {
+       if let event = evensFactory.event(event as? [String: Any?]) {
+           Affise.shared.sendEvent(event: event)
+       } else {
+
+       }
+    }
+    
+    @objc
+    public func nativeSendEvents() -> Void {
+        Affise.shared.sendEvents()
+    }
+    
+    @objc(nativeAddPushToken:)
+    public func nativeAddPushToken(pushToken: NSString) -> Void {
+        Affise.shared.addPushToken(pushToken: pushToken as String)
+    }
+    
+    @objc
+    public func nativeRegisterWebView() -> Void {
+        // Affise.shared.registerWebView(webView)
+        RCTLogInfo("NotImplemented")
+    }
+    
+    @objc
+    public func nativeUnregisterWebView() -> Void {
+    //    Affise.shared.unregisterWebView()
+        RCTLogInfo("NotImplemented")
+    }
+    
+    @objc
+    public func nativeRegisterDeeplinkCallback() -> Void {
+        RCTLogWarn("!> nativeRegisterDeeplinkCallback")
+        Affise.shared.registerDeeplinkCallback {url in
+            self.sendEvent(
+                withName: AffiseAttributionNative.DEEPLINK_CALLBACK_EVENT,
+                body: [
+                    AffiseAttributionNative.DEEPLINK_CALLBACK_URI_PARAMETER: url.absoluteString
+                ]
+            )
+        }
+    }
+    
+    @objc(nativeSetSecretId:)
+    public func nativeSetSecretId(secretId: NSString) -> Void {
+        Affise.shared.setSecretId(secretId: secretId as String)
+    }
+    
+    @objc(nativeSetAutoCatchingTypes:)
+    public func nativeSetAutoCatchingTypes(types: NSArray) -> Void {
+        RCTLogInfo("NotImplemented")
+    }
+    
+    @objc(nativeSetOfflineModeEnabled:)
+    public func nativeSetOfflineModeEnabled(enabled: Bool) -> Void {
+        Affise.shared.setOfflineModeEnabled(enabled: enabled)
+    }
+    
+    @objc(nativeIsOfflineModeEnabled:withRejecter:)
+    public func nativeIsOfflineModeEnabled(resolve:RCTPromiseResolveBlock, reject:RCTPromiseRejectBlock) -> Void {
+        resolve(Affise.shared.isOfflineModeEnabled())
+    }
+    
+    @objc(nativeSetBackgroundTrackingEnabled:)
+    public func nativeSetBackgroundTrackingEnabled(enabled: Bool) -> Void {
+        Affise.shared.setBackgroundTrackingEnabled(enabled: enabled)
+    }
+    
+    @objc(nativeIsBackgroundTrackingEnabled:withRejecter:)
+    public func nativeIsBackgroundTrackingEnabled(resolve:RCTPromiseResolveBlock, reject:RCTPromiseRejectBlock) -> Void {
+        resolve(Affise.shared.isBackgroundTrackingEnabled())
+    }
+    
+    @objc(nativeSetTrackingEnabled:)
+    public func nativeSetTrackingEnabled(enabled: Bool) -> Void {
+        Affise.shared.setTrackingEnabled(enabled: enabled)
+    }
+    
+    @objc(nativeIsTrackingEnabled:withRejecter:)
+    public func nativeIsTrackingEnabled(resolve:RCTPromiseResolveBlock, reject:RCTPromiseRejectBlock) -> Void {
+        resolve(Affise.shared.isTrackingEnabled())
+    }
+    
+    @objc(nativeForget:)
+    public func nativeForget(userData: NSString) -> Void {
+        RCTLogInfo("NotImplemented")
+    }
+    
+    @objc(nativeSetEnabledMetrics:)
+    public func nativeSetEnabledMetrics(enabled: Bool) -> Void {
+        RCTLogInfo("NotImplemented")
+    }
+    
+    @objc
+    public func nativeCrashApplication() -> Void {
+        RCTLogInfo("NotImplemented")
+    }
+    
+    @objc(nativeGetReferrer:withRejecter:)
+    public func nativeGetReferrer(resolve:RCTPromiseResolveBlock, reject:RCTPromiseRejectBlock) -> Void {
+        RCTLogInfo("NotImplemented")
+    }
+}