com-tapp-so-sdk 0.1.0

package/android/src/main/java/com/comtappsosdk/ComTappSoSdkModule.kt

@@ -0,0 +1,354 @@
+package com.comtappsosdk
+
+import android.util.Log
+import com.example.tapp.Tapp
+import com.example.tapp.models.Affiliate
+import com.example.tapp.models.Environment
+import com.example.tapp.services.affiliate.tapp.DeferredLinkDelegate
+import com.example.tapp.services.network.RequestModels
+import com.example.tapp.utils.Logger
+import com.example.tapp.utils.TappConfiguration
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+@ReactModule(name = ComTappSoSdkModule.NAME)
+class ComTappSoSdkModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext), TurboModule{
+
+  companion object {
+    const val NAME = "ComTappSoSdk"
+  }
+
+  private lateinit var tapp: Tapp
+
+  init {
+    Log.i(NAME, "IS_NEW_ARCHITECTURE_ENABLED: ${BuildConfig.IS_NEW_ARCHITECTURE_ENABLED}")
+  }
+
+  override fun getName(): String = NAME
+
+
+  @ReactMethod
+  fun start(authToken: String, env: String, tappToken: String) {
+    if (!::tapp.isInitialized) {
+      tapp = Tapp(reactApplicationContext)
+      // Set the deferred link delegate to emit events to JS.
+      tapp.deferredLinkDelegate = object : DeferredLinkDelegate {
+        override fun didFailResolvingUrl(response: RequestModels.FailResolvingUrlResponse) {
+          didFailResolvingURL(response)
+        }
+
+        override fun didReceiveDeferredLink(linkDataResponse: RequestModels.TappLinkDataResponse) {
+          sendDeferredLinkEvent(linkDataResponse)
+        }
+
+      override fun testListener(test: String) {
+          sendTestEvent(test)
+          //Logger.logInfo("Test listener triggered with test: $test");
+        }
+      }
+    }
+    // Map environment string to Environment enum
+    val environment = when (env.uppercase()) {
+      "SANDBOX" -> Environment.SANDBOX
+      "PRODUCTION" -> Environment.PRODUCTION
+      else -> throw IllegalArgumentException("Invalid environment: $env")
+    }
+    // Map affiliate string to Affiliate enum
+    val affiliateEnum = when ("TAPP_NATIVE") {
+      "TAPP_NATIVE" -> Affiliate.TAPP_NATIVE
+      else -> throw IllegalArgumentException("Invalid affiliate")
+    }
+    val config = TappConfiguration(authToken, environment, tappToken, affiliateEnum)
+    tapp.start(config)
+  }
+
+  @ReactMethod
+  fun url(influencer: String, adGroup: String?, creative: String?, data: ReadableMap?, promise: Promise?) {
+    if (!::tapp.isInitialized) {
+      tapp = Tapp(reactApplicationContext)
+    }
+    val dataMap = data?.toHashMap()?.mapValues { it.value.toString() } ?: emptyMap()
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        val result = tapp.url(influencer, adGroup, creative, dataMap)
+        if (result.error) {
+          promise?.resolve(result.message)
+        } else {
+          promise?.resolve(result.influencer_url)
+        }
+      } catch (e: Exception) {
+        promise?.reject("URL_ERROR", e.message ?: "An unexpected error occurred")
+      }
+    }
+  }
+
+  @ReactMethod
+  fun handleTappEvent(
+    eventAction: Double,
+    customValue: String?,
+    metadata: ReadableMap?,
+    promise: Promise
+  ) {
+    if (!::tapp.isInitialized) {
+      tapp = Tapp(reactApplicationContext)
+    }
+
+    try {
+      val action = when (eventAction.toInt()) {
+        0 -> RequestModels.EventAction.custom(customValue ?: "custom_event_autogenerated")
+        1 -> RequestModels.EventAction.tapp_add_payment_info
+        2 -> RequestModels.EventAction.tapp_add_to_cart
+        3 -> RequestModels.EventAction.tapp_add_to_wishlist
+        4 -> RequestModels.EventAction.tapp_complete_registration
+        5 -> RequestModels.EventAction.tapp_contact
+        6 -> RequestModels.EventAction.tapp_customize_product
+        7 -> RequestModels.EventAction.tapp_donate
+        8 -> RequestModels.EventAction.tapp_find_location
+        9 -> RequestModels.EventAction.tapp_initiate_checkout
+        10 -> RequestModels.EventAction.tapp_generate_lead
+        11 -> RequestModels.EventAction.tapp_purchase
+        12 -> RequestModels.EventAction.tapp_schedule
+        13 -> RequestModels.EventAction.tapp_search
+        14 -> RequestModels.EventAction.tapp_start_trial
+        15 -> RequestModels.EventAction.tapp_submit_application
+        16 -> RequestModels.EventAction.tapp_subscribe
+        17 -> RequestModels.EventAction.tapp_view_content
+        18 -> RequestModels.EventAction.tapp_click_button
+        19 -> RequestModels.EventAction.tapp_download_file
+        20 -> RequestModels.EventAction.tapp_join_group
+        21 -> RequestModels.EventAction.tapp_achieve_level
+        22 -> RequestModels.EventAction.tapp_create_group
+        23 -> RequestModels.EventAction.tapp_create_role
+        24 -> RequestModels.EventAction.tapp_link_click
+        25 -> RequestModels.EventAction.tapp_link_impression
+        26 -> RequestModels.EventAction.tapp_apply_for_loan
+        27 -> RequestModels.EventAction.tapp_loan_approval
+        28 -> RequestModels.EventAction.tapp_loan_disbursal
+        29 -> RequestModels.EventAction.tapp_login
+        30 -> RequestModels.EventAction.tapp_rate
+        31 -> RequestModels.EventAction.tapp_spend_credits
+        32 -> RequestModels.EventAction.tapp_unlock_achievement
+        33 -> RequestModels.EventAction.tapp_add_shipping_info
+        34 -> RequestModels.EventAction.tapp_earn_virtual_currency
+        35 -> RequestModels.EventAction.tapp_start_level
+        36 -> RequestModels.EventAction.tapp_complete_level
+        37 -> RequestModels.EventAction.tapp_post_score
+        38 -> RequestModels.EventAction.tapp_select_content
+        39 -> RequestModels.EventAction.tapp_begin_tutorial
+        40 -> RequestModels.EventAction.tapp_complete_tutorial
+        else -> null
+      }
+
+      if (action == null) {
+        promise.reject("INVALID_ACTION", "Invalid or unsupported event action: $eventAction")
+        return
+      }
+
+      val metaMap: Map<String, Any>? = metadata?.toSafeMetadataMap { msg ->
+        Log.w("TappRN", msg)
+      }
+
+      val tappEvent = RequestModels.TappEvent(
+        eventName = action,
+        metadata = metaMap
+      )
+
+      tapp.handleTappEvent(tappEvent)
+      promise.resolve("Tapp event handled successfully: $eventAction")
+
+    } catch (e: Exception) {
+      promise.reject("HANDLE_EVENT_ERROR", e.message ?: "An unexpected error occurred", e)
+    }
+  }
+
+  private fun ReadableMap.toSafeMetadataMap(
+    onDrop: (String) -> Unit
+  ): Map<String, Any> {
+    val out = LinkedHashMap<String, Any>()
+    val iterator = keySetIterator()
+
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      when (getType(key)) {
+        ReadableType.String -> out[key] = getString(key).orEmpty()
+        ReadableType.Boolean -> out[key] = getBoolean(key)
+        ReadableType.Number -> {
+          // RN exposes numbers as Double; keep as Double (still a Number)
+          val n = getDouble(key)
+          // JSON safety: reject NaN/Infinity
+          if (n.isFinite()) out[key] = n
+          else onDrop("Dropping metadata '$key' because value is not finite: $n")
+        }
+        ReadableType.Null -> {
+          // Skip nulls (or decide to keep nulls if your serializer supports it)
+          onDrop("Dropping metadata '$key' because value is null")
+        }
+        ReadableType.Map, ReadableType.Array -> {
+          // Not allowed by your native contract
+          onDrop("Dropping metadata '$key' because nested ${getType(key)} is not supported")
+        }
+      }
+    }
+
+    return out
+  }
+
+
+  @ReactMethod
+  fun fetchLinkData(deepLink: String?, promise: Promise?) {
+    if (!::tapp.isInitialized) {
+      tapp = Tapp(reactApplicationContext)
+    }
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        val response = tapp.fetchLinkData(deepLink ?: "")
+        if (response != null) {
+          val map: WritableMap = Arguments.createMap().apply {
+            putBoolean("error", response.error)
+            putString("message", response.message)
+            putString("tappUrl", response.tappUrl)
+            putString("attrTappUrl", response.attrTappUrl)
+            putString("influencer", response.influencer)
+            putBoolean("isFirstSession", response.isFirstSession ?: false)
+            putString("deepLink", response.deepLink)
+            val dataMap: WritableMap = Arguments.createMap()
+            response.data?.forEach { (key, value) ->
+              dataMap.putString(key, value)
+            }
+            putMap("data", dataMap)
+          }
+          withContext(Dispatchers.Main) {
+            promise?.resolve(map)
+          }
+        } else {
+          withContext(Dispatchers.Main) {
+            promise?.reject("NO_RESPONSE", "No link data response")
+          }
+        }
+      } catch (e: Exception) {
+        withContext(Dispatchers.Main) {
+          promise?.reject("FETCH_LINK_DATA_ERROR", e.message ?: "An unexpected error occurred")
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun shouldProcess(deepLink: String?, promise: Promise?) {
+    if (!::tapp.isInitialized) {
+      tapp = Tapp(reactApplicationContext)
+    }
+    try {
+      val process = tapp.shouldProcess(deepLink)
+      Logger.logInfo("shouldProcess run for deepLink: $deepLink with process $process")
+      promise?.resolve(process)
+    } catch (e: Exception) {
+      Logger.logError("SHOULD_PROCESS_ERROR ${e.message ?: "An unexpected error occurred"}")
+      promise?.resolve(false)
+    }
+  }
+
+  @ReactMethod
+  fun fetchOriginLinkData(promise: Promise?) {
+    if (!::tapp.isInitialized) {
+      tapp = Tapp(reactApplicationContext)
+    }
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        val response = tapp.fetchOriginalLinkData()
+        if (response != null) {
+          val resultMap = convertResponseToMap(response)
+          withContext(Dispatchers.Main) {
+            promise?.resolve(resultMap)
+          }
+        } else {
+          withContext(Dispatchers.Main) {
+            promise?.reject("NO_DATA", "No link data returned")
+          }
+        }
+      } catch (e: Exception) {
+        withContext(Dispatchers.Main) {
+          promise?.reject("FETCH_ORIGINAL_LINK_DATA_ERROR", e.message ?: "An unexpected error occurred", e)
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  fun simulateTestEvent() {
+     tapp.simulateTestEvent()
+  }
+
+  private fun didFailResolvingURL(response: RequestModels.FailResolvingUrlResponse) {
+    val map: WritableMap = Arguments.createMap().apply {
+      putString("url", response.url)
+      putString("error", response.error.ifEmpty { "" })
+    }
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("onDidFailResolvingURL", map)
+  }
+
+
+
+  // --- helper methods for emitting deferred link events ---
+  //TODO::ADD LINK DATA ON RETURN
+  private fun sendDeferredLinkEvent(response: RequestModels.TappLinkDataResponse) {
+    val map: WritableMap = Arguments.createMap().apply {
+      putBoolean("error", response.error)
+      putString("message", response.message)
+      putString("tappUrl", response.tappUrl)
+      putString("attrTappUrl", response.attrTappUrl)
+      putString("influencer", response.influencer)
+      putBoolean("isFirstSession", response.isFirstSession ?: false)
+      putString("deepLink", response.deepLink ?: "")
+      val dataMap: WritableMap = Arguments.createMap()
+      response.data?.forEach { (key, value) ->
+        dataMap.putString(key, value)
+      }
+      putMap("data", dataMap)
+    }
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("onDeferredLinkReceived", map)
+  }
+
+  private fun sendTestEvent(test: String) {
+    val map: WritableMap = Arguments.createMap().apply {
+      putString("test", test)
+    }
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit("onTestListener", map)
+  }
+
+  private fun convertResponseToMap(response: RequestModels.TappLinkDataResponse): WritableMap {
+    val map = Arguments.createMap()
+    map.putBoolean("error", response.error)
+    map.putString("message", response.message)
+    map.putString("tappUrl", response.tappUrl)
+    map.putString("attrTappUrl", response.attrTappUrl)
+    map.putString("influencer", response.influencer)
+    map.putBoolean("isFirstSession", response.isFirstSession ?: false)
+    val dataMap = Arguments.createMap()
+    response.data?.forEach { (key, value) ->
+      dataMap.putString(key, value)
+    }
+    map.putMap("data", dataMap)
+    return map
+  }
+}

package/android/src/main/java/com/comtappsosdk/ComTappSoSdkPackage.kt

@@ -0,0 +1,45 @@
+package com.comtappsosdk
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+import com.facebook.react.uimanager.ViewManager
+
+class ComTappSoSdkPackage : ReactPackage {
+
+  private val isTurbo: Boolean
+    get() = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+
+  // Legacy: create a list of native modules
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(ComTappSoSdkModule(reactContext))
+  }
+
+  // If you don’t have any custom view managers, return an empty list
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+
+
+  // (Optional) For TurboModules support in newer RN versions
+  fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos = HashMap<String, ReactModuleInfo>()
+      moduleInfos[ComTappSoSdkModule.NAME] = ReactModuleInfo(
+        ComTappSoSdkModule.NAME,
+        ComTappSoSdkModule.NAME,
+        false,
+        false,
+        true,
+        false,
+        isTurbo // This flag can control TurboModules
+      )
+      moduleInfos
+    }
+  }
+}
+

package/ios/ComTappSoSdk.h

@@ -0,0 +1,62 @@
+//#import <ComTappSoSdkSpec/ComTappSoSdkSpec.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+#import <Tapp/Tapp-Swift.h>
+#import <Tapp/Tapp-umbrella.h>
+
+#import <TappNetworking/TappNetworking-Swift.h>
+#import <TappNetworking/Tapp-Networking-umbrella.h>
+
+//
+// Legacy definitions for RN versions before the new architecture.
+// These legacy types are only needed when RCT_NEW_ARCH_ENABLED is NOT defined.
+// We also guard the declarations so they’re only declared once.
+//
+#if !defined(RCT_NEW_ARCH_ENABLED)
+#ifndef COMTAPPSOSDK_LEGACY_TYPES
+#define COMTAPPSOSDK_LEGACY_TYPES
+
+#import <functional>
+namespace facebook {
+  namespace react {
+    // Define the callback type that accepts an event name as std::string and a payload.
+    using EventEmitterCallback = std::function<void(const std::string&, NSDictionary*)>;
+  }
+}
+
+// Rename the wrapper class to avoid conflicts:
+@interface CTEventEmitterCallbackWrapper : NSObject
+@property (nonatomic, copy) void (^eventEmitterCallback)(NSString *eventName, NSDictionary *payload);
+@end
+
+// Inline helper function to convert an Objective-C block to a std::function.
+static inline facebook::react::EventEmitterCallback CTConvertBlockToStdFunction(void (^block)(NSString *, NSDictionary *)) {
+  if (!block) return nullptr;
+  // Copy the block so it lives long enough.
+  void (^copiedBlock)(NSString *, NSDictionary *) = [block copy];
+  return [=](const std::string &eventName, NSDictionary *payload) {
+    NSString *nsEventName = [NSString stringWithUTF8String:eventName.c_str()];
+    copiedBlock(nsEventName, payload);
+  };
+}
+
+#endif // COMTAPPSO_LEGACY_TYPES
+#endif // !RCT_NEW_ARCH_ENABLED
+
+//
+// For new architecture builds, import the generated Codegen header:
+#if defined(RCT_NEW_ARCH_ENABLED)
+#import "generated/ComTappSoSdkSpec/ComTappSoSdkSpec.h"
+#endif
+
+//
+// Declare the main interface. For new architecture, adopt <NativeComTappSoSdkSpec, TappDelegate, RCTTurboModule>,
+// and for legacy, adopt <RCTBridgeModule, TappDelegate>.
+#if defined(RCT_NEW_ARCH_ENABLED)
+@interface ComTappSoSdk : RCTEventEmitter <NativeComTappSoSdkSpec, TappDelegate, RCTTurboModule>
+#else
+@interface ComTappSoSdk : RCTEventEmitter <RCTBridgeModule, TappDelegate>
+#endif
+
+@end