@tyrads.com/tyrads-sdk 3.3.4 → 4.0.0

package/android/build.gradle

@@ -112,6 +112,6 @@ dependencies {
   implementation "com.facebook.react:react-native:+"
   implementation 'com.google.code.gson:gson:+'
 
-  implementation 'com.github.tyrads-com:tyrads-sdk-android:100a5c9eb4'
+  implementation 'com.github.tyrads-com:tyrads-sdk-android:22b7882c30'
 }
 

package/android/src/main/java/com/tyradssdk/TyradsSdkModule.kt

@@ -1,42 +1,124 @@
 package com.tyradssdk
 
 import android.util.Log
+import android.content.Intent
 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.modules.core.DeviceEventManagerModule
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.ActivityEventListener
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.ReadableNativeMap
 import com.facebook.react.bridge.Arguments
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import com.google.gson.Gson
 import com.tyrads.sdk.Tyrads
 import com.tyrads.sdk.TyradsUserInfo
 import com.tyrads.sdk.TyradsMediaSourceInfo
-
+import com.tyrads.sdk.acmo.modules.push_notifications.FCMNotifications
+import com.tyrads.sdk.acmo.modules.push_notifications.TyradsNotificationListener
+import com.tyrads.sdk.acmo.modules.input_models.TyradsConfig
+import android.app.Dialog
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import android.view.Window
+import android.view.WindowManager
+import com.facebook.react.ReactRootView
+import com.facebook.react.ReactInstanceManager
+import com.facebook.react.ReactApplication
 
 class TyradsSdkModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
+  ReactContextBaseJavaModule(reactContext), ActivityEventListener, LifecycleEventListener {
+
+  private var notificationDialog: Dialog? = null
 
   private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
   private val coroutineScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
   private var languageJob: Job? = null
+  private val gson = Gson()
+
+  private var cachedEvents = mutableListOf<String>()
+  private var isObserving = false
+  private var lastHandledIntent: Intent? = null
 
   override fun getName(): String {
     return NAME
   }
 
+  init {
+    reactContext.addActivityEventListener(this)
+    reactContext.addLifecycleEventListener(this)
+    setupNotificationListener()
+  }
+
+  override fun onHostResume() {
+      val intent = currentActivity?.intent
+      if (intent != null && intent != lastHandledIntent) {
+          FCMNotifications.getInstance().handleNotificationIntent(intent)
+          lastHandledIntent = intent
+      }
+  }
+
+  override fun onHostPause() {}
+  override fun onHostDestroy() {}
+
+
+  override fun onActivityResult(activity: android.app.Activity?, requestCode: Int, resultCode: Int, data: Intent?) {
+    // Not needed
+  }
+
+  override fun onNewIntent(intent: Intent?) {
+    intent?.let {
+      FCMNotifications.getInstance().handleNotificationIntent(it)
+    }
+  }
+
+
+  private fun setupNotificationListener() {
+    FCMNotifications.getInstance().setNotificationListener(object : TyradsNotificationListener {
+      override fun onNotificationReceived(data: Map<String, String>) {
+        val payload = mapOf(
+          "type" to "received",
+          "data" to data
+        )
+        sendEvent("PushNotificationEvent", gson.toJson(payload))
+      }
+
+      override fun onNotificationClicked(data: Map<String, String>) {
+        val payload = mapOf(
+          "type" to "clicked",
+          "data" to data
+        )
+        sendEvent("PushNotificationEvent", gson.toJson(payload))
+      }
+
+      override fun onNotificationDismissed(data: Map<String, String>) {
+        val payload = mapOf(
+          "type" to "dismissed",
+          "data" to data
+        )
+        sendEvent("PushNotificationEvent", gson.toJson(payload))
+      }
+    })
+  }
+
   private fun sendEvent(eventName: String, data: String) {
+    if (!isObserving) {
+        Log.i("TyradsSDK", "JS side not ready. Caching event: $eventName")
+        cachedEvents.add(data)
+        return
+    }
+
     val reactContext = reactApplicationContext
-    if (reactContext.hasActiveCatalystInstance()) {
+    val isActive = reactContext.hasActiveCatalystInstance()
+    Log.i("TyradsSDK", "Emitting event to JS: $eventName (Bridge Active: $isActive)")
+    if (isActive) {
       scope.launch {
         reactContext
           .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
@@ -47,6 +129,15 @@ class TyradsSdkModule(reactContext: ReactApplicationContext) :
 
   @ReactMethod
   fun startObserving() {
+    isObserving = true
+    Log.d("TyradsSdkModule", "startObserving: flushing ${cachedEvents.size} events")
+    
+    val eventsToFlush = ArrayList(cachedEvents)
+    cachedEvents.clear()
+    eventsToFlush.forEach { data ->
+        sendEvent("PushNotificationEvent", data)
+    }
+
     if (languageJob?.isActive == true) return
 
     languageJob = scope.launch {
@@ -56,17 +147,25 @@ class TyradsSdkModule(reactContext: ReactApplicationContext) :
     }
   }
 
+
   @ReactMethod
   fun stopObserving() {
+    isObserving = false
     languageJob?.cancel()
     languageJob = null
   }
 
   @ReactMethod
-  fun init(apiKey: String, apiSecret: String, encKey: String?, engagementId: String?, promise: Promise) {
+  fun init(apiKey: String, apiSecret: String, encKey: String?, engagementId: String?, placementId: String?, config: ReadableMap?, promise: Promise) {
     Tyrads.getInstance().tyradScope.launch {
       try {
-        Tyrads.getInstance().init(reactApplicationContext, apiKey, apiSecret, encKey, engagementId)
+        val configData = if (config != null) {
+                val jsonString = gson.toJson(config.toHashMap())
+                gson.fromJson(jsonString, TyradsConfig::class.java)
+            } else {
+                TyradsConfig() 
+            } 
+        Tyrads.getInstance().init(reactApplicationContext, apiKey, apiSecret, encKey, engagementId, placementId, configData)
 
         val lang = Tyrads.getInstance().currentLanguageCode.value
 
@@ -75,14 +174,13 @@ class TyradsSdkModule(reactContext: ReactApplicationContext) :
           "languageCode" to lang
         )
 
-        promise.resolve(Gson().toJson(result))
+        promise.resolve(gson.toJson(result))
       } catch (e: Exception) {
         promise.reject("INIT_ERROR", e.message)
       }
     }
   }
 
-
   @ReactMethod
   fun loginUser(userId: String, promise: Promise) {
     Tyrads.getInstance().tyradScope.launch {
@@ -90,7 +188,7 @@ class TyradsSdkModule(reactContext: ReactApplicationContext) :
         val apiHeaders = Tyrads.getInstance().loginUser(userId)
         Log.i("bmd", "apiHeaders: $apiHeaders")
         if (apiHeaders != null) {
-          val jsonString = Gson().toJson(apiHeaders)
+          val jsonString = gson.toJson(apiHeaders)
           promise.resolve(jsonString)
         } else {
           promise.resolve(null)
@@ -145,23 +243,22 @@ class TyradsSdkModule(reactContext: ReactApplicationContext) :
   @ReactMethod
   fun setMediaSourceInfo(mediaSourceInfoMap: ReadableMap) {
     try {
-      val jsonString = Gson().toJson(mediaSourceInfoMap.toHashMap())
-      val mediaSourceInfo = Gson().fromJson(jsonString, TyradsMediaSourceInfo::class.java)
-      Tyrads.getInstance().setMediaSourceInfo(mediaSourceInfo)
+      val jsonString = gson.toJson(mediaSourceInfoMap.toHashMap())
+      val mediaSourceInfo = gson.fromJson(jsonString, TyradsMediaSourceInfo::class.java)
       Log.d(NAME, "Received mediaSourceInfo: $jsonString")
       Tyrads.getInstance().setMediaSourceInfo(mediaSourceInfo)
     } catch (e: Exception) {
       Log.e(NAME, "Error setting MediaSourceInfo", e)
     }
   }
+
   @ReactMethod
   fun setUserInfo(userInfoMap: ReadableMap) {
     try {
-      val jsonString = Gson().toJson(userInfoMap.toHashMap())
-      val userInfo = Gson().fromJson(jsonString, TyradsUserInfo::class.java)
-      Tyrads.getInstance().setUserInfo(userInfo)      
+      val jsonString = gson.toJson(userInfoMap.toHashMap())
+      val userInfo = gson.fromJson(jsonString, TyradsUserInfo::class.java)
       Log.d(NAME, "Received userInfo: $jsonString")
-      Tyrads.getInstance().setUserInfo(userInfo)
+      Tyrads.getInstance().setUserInfo(userInfo)      
     } catch (e: Exception) {
       Log.e(NAME, "Error setting UserInfo", e)
     }
@@ -191,7 +288,52 @@ class TyradsSdkModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  @ReactMethod
+  fun showInAppNotification() {
+    coroutineScope.launch {
+      val activity = currentActivity ?: return@launch
+      val dialog = Dialog(activity)
+      notificationDialog = dialog
+      dialog.requestWindowFeature(Window.FEATURE_NO_TITLE)
+      val reactRootView = ReactRootView(activity)
+      val reactInstanceManager: ReactInstanceManager? = try {
+          (activity.application as? ReactApplication)?.reactNativeHost?.reactInstanceManager
+      } catch (e: Exception) {
+          null
+      }
+
+      if (reactInstanceManager == null) {
+          Log.e("TyradsSdk", "Could not get ReactInstanceManager")
+          return@launch
+      }
+
+      reactRootView.startReactApplication(
+        reactInstanceManager,
+        "TyradsInAppNotification",
+        null
+      )
+      dialog.setContentView(reactRootView)
+      dialog.window?.let { window ->
+        window.setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
+        window.setLayout(
+          WindowManager.LayoutParams.MATCH_PARENT,
+          WindowManager.LayoutParams.MATCH_PARENT
+        )
+      }
+      
+      dialog.show()
+    }
+  }
+
+  @ReactMethod
+  fun dismissInAppNotification() {
+    coroutineScope.launch {
+      notificationDialog?.dismiss()
+      notificationDialog = null
+    }
+  }
+
   companion object {
     const val NAME = "TyradsSdk"
   }
-}
+}

package/ios/Tyrads/AcmoConfig.swift

@@ -9,7 +9,7 @@ import Foundation
 import UIKit
 
 struct AcmoConfig {
-    static let API_VERSION = "3.0"
+    static let API_VERSION = "4.0"
     static let BUILD_VERSION = "0"
     static let ACMO_VERSION = "4"
     static var SDK_VERSION = "3.2.1-\(BUILD_VERSION)"

package/ios/Tyrads/InitModel.swift

@@ -8,44 +8,58 @@
 import Foundation
 
 struct AcmoInitModel: Codable {
-    let data: UserData
+    let code: Int
+    let message: String
+    let timestamp: Int64
+    let responseTime: Double
+    let data: InitData
 }
 
-struct UserData: Codable {
+struct InitData: Codable {
     let newRegisteredUser: Bool
-    let user: User
-    let publisherApp: PublisherApp
+    let newRegisteredDevice: Bool
+    let accountInfo: AccountInfo
+    let appInfo: AppInfo
     let token: String
     
     enum CodingKeys: String, CodingKey {
-        case newRegisteredUser = "newRegisteredUser"
-        case user
-        case publisherApp
-      case token
+        case newRegisteredUser
+        case newRegisteredDevice
+        case accountInfo
+        case appInfo
+        case token
     }
     
     init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
         newRegisteredUser = try container.decodeIfPresent(Bool.self, forKey: .newRegisteredUser) ?? false
-        user = try container.decode(User.self, forKey: .user)
-        publisherApp = try container.decode(PublisherApp.self, forKey: .publisherApp)
-      token = try container.decode(String.self, forKey: .token)
+        newRegisteredDevice = try container.decodeIfPresent(Bool.self, forKey: .newRegisteredDevice) ?? false
+        accountInfo = try container.decode(AccountInfo.self, forKey: .accountInfo)
+        appInfo = try container.decode(AppInfo.self, forKey: .appInfo)
+        token = try container.decodeIfPresent(String.self, forKey: .token) ?? ""
     }
 }
 
-struct User: Codable {
+struct AccountInfo: Codable {
+    let id: Int
     let publisherUserId: String
 }
 
-struct PublisherApp: Codable {
+struct AppInfo: Codable {
     let headerColor: String
     let mainColor: String
-  let premiumColor: String
+    let premiumColor: String
+    
+    enum CodingKeys: String, CodingKey {
+        case headerColor
+        case mainColor
+        case premiumColor
+    }
     
     init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
         headerColor = try container.decodeIfPresent(String.self, forKey: .headerColor) ?? ""
         mainColor = try container.decodeIfPresent(String.self, forKey: .mainColor) ?? ""
-      premiumColor = try container.decodeIfPresent(String.self, forKey: .premiumColor) ?? ""
+        premiumColor = try container.decodeIfPresent(String.self, forKey: .premiumColor) ?? ""
     }
 }