@1selfworld/adchain-sdk-react-native 1.0.1

package/android/src/main/java/com/adchain/exposdk/AdchainSdkModule.kt

@@ -0,0 +1,742 @@
+package com.adchain.exposdk
+
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.adchain.sdk.core.*
+import com.adchain.sdk.quiz.*
+import com.adchain.sdk.quiz.models.QuizEvent
+import com.adchain.sdk.mission.*
+import com.adchain.sdk.offerwall.*
+import android.app.Activity
+import android.os.Handler
+import android.os.Looper
+
+@ReactModule(name = AdchainSdkModule.NAME)
+class AdchainSdkModule(private val reactContext: ReactApplicationContext)
+  : ReactContextBaseJavaModule(reactContext) {
+
+  companion object { 
+    const val NAME = "AdchainSdk"
+  }
+  
+  override fun getName() = NAME
+  
+  // 내부 인스턴스 관리 (자동 생성/캐싱)
+  private val quizInstances = mutableMapOf<String, AdchainQuiz>()
+  private val missionInstances = mutableMapOf<String, AdchainMission>()
+
+  // ===== 1. SDK 초기화 =====
+  
+  @ReactMethod
+  fun initialize(appKey: String, appSecret: String, options: ReadableMap?, promise: Promise) {
+    try {
+      // options에서 environment와 timeout 추출
+      val environment = options?.getString("environment")
+      val timeout = if (options?.hasKey("timeout") == true && !options.isNull("timeout")) {
+        options.getDouble("timeout")
+      } else null
+
+      val env = when(environment?.uppercase()) {
+        "STAGING" -> AdchainSdkConfig.Environment.STAGING
+        "DEVELOPMENT" -> AdchainSdkConfig.Environment.DEVELOPMENT
+        else -> AdchainSdkConfig.Environment.PRODUCTION
+      }
+
+      val configBuilder = AdchainSdkConfig.Builder(appKey, appSecret)
+        .setEnvironment(env)
+
+      timeout?.let {
+        configBuilder.setTimeout(it.toLong())
+      }
+
+      val config = configBuilder.build()
+
+      // Activity가 null인 경우 최대 1초간 대기
+      if (reactContext.currentActivity == null) {
+        val handler = Handler(Looper.getMainLooper())
+        var attempts = 0
+        val maxAttempts = 10 // 최대 10회 시도 (1초)
+
+        val runnable = object : Runnable {
+          override fun run() {
+            attempts++
+            val activity = reactContext.currentActivity
+
+            if (activity != null) {
+              // Activity가 준비됨, SDK 초기화 진행
+              AdchainSdk.initialize(activity.application, config)
+              promise.resolve(createResponse(true, "SDK initialized successfully"))
+            } else if (attempts < maxAttempts) {
+              // 100ms 후 재시도
+              handler.postDelayed(this, 100)
+            } else {
+              // 최대 시도 횟수 초과
+              promise.reject("INIT_ERROR", "Current activity is null after waiting 1 second")
+            }
+          }
+        }
+
+        // 첫 시도는 100ms 후에
+        handler.postDelayed(runnable, 100)
+      } else {
+        // Activity가 이미 준비되어 있음
+        AdchainSdk.initialize(reactContext.currentActivity!!.application, config)
+        promise.resolve(createResponse(true, "SDK initialized successfully"))
+      }
+
+    } catch (t: Throwable) {
+      promise.reject("INIT_ERROR", t.message, t)
+    }
+  }
+
+  // ===== 2. 인증 관련 (4개) =====
+  
+  @ReactMethod
+  fun login(userId: String, userInfo: ReadableMap?, promise: Promise) {
+    try {
+      val userBuilder = AdchainSdkUser.Builder(userId)
+      
+      // userInfo에서 각 필드 추출
+      val gender = userInfo?.getString("gender")
+      val birthYear = if (userInfo?.hasKey("birthYear") == true && !userInfo.isNull("birthYear")) {
+        userInfo.getDouble("birthYear").toInt()
+      } else null
+      
+      gender?.let {
+        val genderEnum = when(it.uppercase()) {
+          "MALE", "M" -> AdchainSdkUser.Gender.MALE
+          "FEMALE", "F" -> AdchainSdkUser.Gender.FEMALE
+          else -> null // Android SDK에 OTHER가 없음
+        }
+        genderEnum?.let { g ->
+          userBuilder.setGender(g)
+        }
+      }
+      
+      birthYear?.let {
+        userBuilder.setBirthYear(it)
+      }
+      
+      // customProperties 처리
+      val customProperties = userInfo?.getMap("customProperties")
+      customProperties?.let { props ->
+        val iterator = props.keySetIterator()
+        while (iterator.hasNextKey()) {
+          val key = iterator.nextKey()
+          val value = props.getString(key)
+          if (value != null) {
+            userBuilder.setCustomProperty(key, value)
+          }
+        }
+      }
+      
+      val user = userBuilder.build()
+      
+      AdchainSdk.login(user, object : AdchainSdkLoginListener {
+        override fun onSuccess() {
+          promise.resolve(createResponse(true, "Login successful"))
+        }
+        
+        override fun onFailure(errorType: AdchainSdkLoginListener.ErrorType) {
+          val errorMessage = when (errorType) {
+            AdchainSdkLoginListener.ErrorType.NOT_INITIALIZED -> "SDK not initialized"
+            AdchainSdkLoginListener.ErrorType.INVALID_USER_ID -> "Invalid user ID"
+            AdchainSdkLoginListener.ErrorType.AUTHENTICATION_FAILED -> "Authentication failed"
+            AdchainSdkLoginListener.ErrorType.NETWORK_ERROR -> "Network error"
+            AdchainSdkLoginListener.ErrorType.UNKNOWN -> "Unknown error"
+          }
+          promise.reject("LOGIN_ERROR", errorMessage)
+        }
+      })
+    } catch (t: Throwable) {
+      promise.reject("LOGIN_ERROR", t.message, t)
+    }
+  }
+  
+  @ReactMethod
+  fun logout(promise: Promise) {
+    try {
+      AdchainSdk.logout()
+      promise.resolve(createResponse(true, "Logout successful"))
+    } catch (t: Throwable) {
+      promise.reject("LOGOUT_ERROR", t.message, t)
+    }
+  }
+  
+  @ReactMethod
+  fun isLoggedIn(promise: Promise) {
+    try {
+      promise.resolve(AdchainSdk.isLoggedIn)
+    } catch (t: Throwable) {
+      promise.reject("ERROR", t.message, t)
+    }
+  }
+  
+  @ReactMethod
+  fun getCurrentUser(promise: Promise) {
+    try {
+      val user = AdchainSdk.getCurrentUser()
+      if (user != null) {
+        val map = Arguments.createMap().apply {
+          putString("userId", user.userId)
+          user.gender?.let { putString("gender", it.name) }
+          user.birthYear?.let { putInt("birthYear", it) }
+        }
+        promise.resolve(map)
+      } else {
+        promise.resolve(null)
+      }
+    } catch (t: Throwable) {
+      promise.reject("ERROR", t.message, t)
+    }
+  }
+
+  // ===== 3. Quiz 관련 (2개) =====
+  
+  @ReactMethod
+  fun loadQuizList(unitId: String, promise: Promise) {
+    try {
+      // 인스턴스 자동 생성/재사용
+      val quiz = quizInstances.getOrPut(unitId) {
+        AdchainQuiz()
+      }
+      
+      quiz.getQuizList(
+        onSuccess = { quizResponse ->
+          val responseMap = Arguments.createMap().apply {
+            putBoolean("success", quizResponse.success ?: true)
+            putString("titleText", quizResponse.titleText)
+            putString("completedImageUrl", quizResponse.completedImageUrl)
+            quizResponse.completedImageWidth?.let { putInt("completedImageWidth", it) }
+            quizResponse.completedImageHeight?.let { putInt("completedImageHeight", it) }
+            putString("message", quizResponse.message)
+
+            // events 배열 처리
+            val eventsArray = Arguments.createArray()
+            quizResponse.events.forEach { quizEvent ->
+              val eventMap = Arguments.createMap().apply {
+                putString("id", quizEvent.id)
+                putString("title", quizEvent.title)
+                putString("description", quizEvent.description ?: "")
+                putString("imageUrl", quizEvent.imageUrl)
+                putString("point", quizEvent.point)
+                putBoolean("isCompleted", quizEvent.completed ?: false)
+              }
+              eventsArray.pushMap(eventMap)
+            }
+            putArray("events", eventsArray)
+          }
+          promise.resolve(responseMap)
+        },
+        onFailure = { error ->
+          promise.reject("QUIZ_LOAD_ERROR", error.toString())
+        },
+        shouldStoreCallbacks = true // 콜백 저장하여 자동 refresh 가능하게 함
+      )
+    } catch (t: Throwable) {
+      promise.reject("QUIZ_ERROR", t.message, t)
+    }
+  }
+  
+  @ReactMethod
+  fun clickQuiz(unitId: String, quizId: String, promise: Promise) {
+    try {
+      val quiz = quizInstances.getOrPut(unitId) {
+        AdchainQuiz()
+      }
+      
+      // iOS와 동일한 방식: 리스너 설정
+      quiz.setQuizEventsListener(object : AdchainQuizEventsListener {
+        override fun onImpressed(quizEvent: QuizEvent) {
+          // 필요시 처리
+        }
+        
+        override fun onClicked(quizEvent: QuizEvent) {
+          // 필요시 처리
+        }
+        
+        override fun onQuizCompleted(quizEvent: QuizEvent, score: Int) {
+          // React Native로 이벤트 전송
+          reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("onQuizCompleted", Arguments.createMap().apply {
+              putString("unitId", unitId)
+              putString("quizId", quizId)
+              putDouble("timestamp", System.currentTimeMillis().toDouble())
+            })
+        }
+      })
+      
+      quiz.clickQuiz(quizId)
+      promise.resolve(createResponse(true, "Quiz clicked"))
+    } catch (t: Throwable) {
+      promise.reject("QUIZ_ERROR", t.message, t)
+    }
+  }
+
+  // ===== 4. Mission 관련 (3개) =====
+  
+  @ReactMethod
+  fun loadMissionList(unitId: String, promise: Promise) {
+    try {
+      // 인스턴스 자동 생성/재사용
+      val mission = missionInstances.getOrPut(unitId) {
+        AdchainMission()
+      }
+
+      // iOS와 동일하게 loadMissionList에서도 리스너 설정
+      // missionRefreshed 이벤트를 받기 위해 필수
+      val localUnitId = unitId
+      mission.setEventsListener(object : AdchainMissionEventsListener {
+        override fun onImpressed(mission: Mission) {
+          // 필요시 처리
+        }
+
+        override fun onClicked(mission: Mission) {
+          // 필요시 처리
+        }
+
+        override fun onCompleted(mission: Mission) {
+          // React Native로 이벤트 전송
+          reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("onMissionCompleted", Arguments.createMap().apply {
+              putString("unitId", localUnitId)
+              putString("missionId", mission.id)
+              putDouble("timestamp", System.currentTimeMillis().toDouble())
+            })
+        }
+
+        override fun onProgressed(mission: Mission) {
+          // React Native로 이벤트 전송
+          reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("onMissionProgressed", Arguments.createMap().apply {
+              putString("unitId", localUnitId)
+              putString("missionId", mission.id)
+              putDouble("timestamp", System.currentTimeMillis().toDouble())
+            })
+        }
+
+        override fun onRefreshed(refreshedUnitId: String?) {
+          // React Native로 이벤트 전송
+          reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("onMissionRefreshed", Arguments.createMap().apply {
+              putString("unitId", refreshedUnitId ?: localUnitId)
+              putDouble("timestamp", System.currentTimeMillis().toDouble())
+            })
+        }
+      })
+
+      mission.getMissionList(
+        onSuccess = { missionList ->
+          // getMissionStatus를 호출하여 정확한 진행 상태 가져오기
+          mission.getMissionStatus(
+            onSuccess = { status ->
+              val array = Arguments.createArray()
+              
+              // 미션 목록
+              missionList.forEach { m ->
+                val map = Arguments.createMap().apply {
+                  putString("id", m.id)
+                  putString("title", m.title)
+                  putString("description", m.description)
+                  putString("imageUrl", m.imageUrl)
+                  putString("point", m.point) // 원본 문자열 그대로 전달
+                  putBoolean("isCompleted", m.status == "completed")
+                  putString("type", m.type?.value ?: "normal")
+                  putString("actionUrl", m.landingUrl)
+                }
+                array.pushMap(map)
+              }
+              
+              val result = Arguments.createMap().apply {
+                putArray("missions", array)
+                putInt("completedCount", status.current) // getMissionStatus에서 가져온 값
+                putInt("totalCount", status.total) // getMissionStatus에서 가져온 값
+                putBoolean("canClaimReward", status.isCompleted && status.total > 0)
+
+                // 신규 필드 추가 (missionResponse에서 가져오기)
+                val missionInstance = missionInstances[unitId]
+                missionInstance?.let { m ->
+                  val response = m.getMissionResponse()
+                  putString("titleText", response?.titleText ?: "무료 포인트 모으기!")
+                  putString("descriptionText", response?.descriptionText ?: "간단 광고 참여하고 100 포인트 받기")
+                  putString("bottomText", response?.bottomText ?: "800만 포인트 받으러 가기")
+                  putString("rewardIconUrl", response?.rewardIconUrl ?: "https://adchain-assets.1self.world/img_reward_coin.png")
+                  putString("bottomIconUrl", response?.bottomIconUrl ?: "https://adchain-assets.1self.world/img_offerwall_coin.png")
+                } ?: run {
+                  // 기본값 설정
+                  putString("titleText", "무료 포인트 모으기!")
+                  putString("descriptionText", "간단 광고 참여하고 100 포인트 받기")
+                  putString("bottomText", "800만 포인트 받으러 가기")
+                  putString("rewardIconUrl", "https://adchain-assets.1self.world/img_reward_coin.png")
+                  putString("bottomIconUrl", "https://adchain-assets.1self.world/img_offerwall_coin.png")
+                }
+              }
+              
+              promise.resolve(result)
+            },
+            onFailure = { error ->
+              // getMissionStatus 실패 시 기본값 사용
+              val array = Arguments.createArray()
+              missionList.forEach { m ->
+                val map = Arguments.createMap().apply {
+                  putString("id", m.id)
+                  putString("title", m.title)
+                  putString("description", m.description)
+                  putString("imageUrl", m.imageUrl)
+                  putString("point", m.point)
+                  putBoolean("isCompleted", m.status == "completed")
+                  putString("type", m.type?.value ?: "normal")
+                  putString("actionUrl", m.landingUrl)
+                }
+                array.pushMap(map)
+              }
+              
+              val completedCount = missionList.count { it.status == "completed" }
+              val totalCount = missionList.size
+              
+              val result = Arguments.createMap().apply {
+                putArray("missions", array)
+                putInt("completedCount", completedCount)
+                putInt("totalCount", totalCount)
+                putBoolean("canClaimReward", completedCount == totalCount && totalCount > 0)
+              }
+              
+              promise.resolve(result)
+            }
+          )
+        },
+        onFailure = { error ->
+          promise.reject("MISSION_LOAD_ERROR", error.toString())
+        }
+      )
+    } catch (t: Throwable) {
+      promise.reject("MISSION_ERROR", t.message, t)
+    }
+  }
+  
+  @ReactMethod
+  fun clickMission(unitId: String, missionId: String, promise: Promise) {
+    try {
+      val mission = missionInstances.getOrPut(unitId) {
+        AdchainMission()
+      }
+
+      // 외부 변수를 로컬 변수로 캡처
+      val localUnitId = unitId
+      val localMissionId = missionId
+
+      // iOS와 동일한 방식: 리스너 설정
+      mission.setEventsListener(object : AdchainMissionEventsListener {
+        override fun onImpressed(mission: Mission) {
+          // 필요시 처리
+        }
+
+        override fun onClicked(mission: Mission) {
+          // 필요시 처리
+        }
+
+        override fun onCompleted(mission: Mission) {
+          // React Native로 이벤트 전송
+          reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("onMissionCompleted", Arguments.createMap().apply {
+              putString("unitId", localUnitId)
+              putString("missionId", localMissionId)
+              putDouble("timestamp", System.currentTimeMillis().toDouble())
+            })
+        }
+
+        override fun onProgressed(mission: Mission) {
+          // React Native로 이벤트 전송 (missionCompleted와 동일한 구조)
+          reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("onMissionProgressed", Arguments.createMap().apply {
+              putString("unitId", localUnitId)
+              putString("missionId", localMissionId)
+              putDouble("timestamp", System.currentTimeMillis().toDouble())
+            })
+        }
+
+        override fun onRefreshed(refreshedUnitId: String?) {
+          // React Native로 이벤트 전송
+          reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("onMissionRefreshed", Arguments.createMap().apply {
+              putString("unitId", refreshedUnitId ?: localUnitId)
+              putDouble("timestamp", System.currentTimeMillis().toDouble())
+            })
+        }
+      })
+
+      mission.clickMission(missionId)
+      promise.resolve(createResponse(true, "Mission clicked"))
+    } catch (t: Throwable) {
+      promise.reject("MISSION_ERROR", t.message, t)
+    }
+  }
+  
+  @ReactMethod
+  fun claimReward(unitId: String, promise: Promise) {
+    try {
+      val mission = missionInstances.getOrPut(unitId) {
+        AdchainMission()
+      }
+      
+      mission.clickGetReward()
+      promise.resolve(createResponse(true, "Reward claimed"))
+    } catch (t: Throwable) {
+      promise.reject("MISSION_ERROR", t.message, t)
+    }
+  }
+
+  // ===== 5. Debug/Utility Methods (3개) =====
+
+  @ReactMethod
+  fun isInitialized(promise: Promise) {
+    try {
+      promise.resolve(AdchainSdk.isInitialized())
+    } catch (t: Throwable) {
+      promise.reject("ERROR", t.message, t)
+    }
+  }
+
+  @ReactMethod
+  fun getUserId(promise: Promise) {
+    try {
+      val userId = AdchainSdk.getCurrentUser()?.userId ?: ""
+      promise.resolve(userId)
+    } catch (t: Throwable) {
+      promise.reject("ERROR", t.message, t)
+    }
+  }
+
+  @ReactMethod
+  fun getIFA(promise: Promise) {
+    try {
+      val context = reactContext.applicationContext
+      // SDK의 public 메서드를 사용하여 IFA 가져오기
+      // SDK가 캐싱, 권한 처리, 에러 처리 등을 모두 관리함
+      val ifa = AdchainSdk.getAdvertisingId(context) ?: ""
+      promise.resolve(ifa)
+    } catch (t: Throwable) {
+      promise.reject("ERROR", t.message, t)
+    }
+  }
+
+  // ===== 6. Banner (1개) =====
+
+  @ReactMethod
+  fun getBannerInfo(placementId: String, promise: Promise) {
+    try {
+      AdchainSdk.getBannerInfo(placementId) { result ->
+        if (result.isSuccess) {
+          val response = result.getOrNull()
+          val map = Arguments.createMap().apply {
+            putBoolean("success", response?.success ?: false)
+            putString("imageUrl", response?.imageUrl)
+            response?.imageWidth?.let { putInt("imageWidth", it) }
+            response?.imageHeight?.let { putInt("imageHeight", it) }
+            putString("titleText", response?.titleText)
+            putString("linkType", response?.linkType)
+            putString("internalLinkUrl", response?.internalLinkUrl)
+            putString("externalLinkUrl", response?.externalLinkUrl)
+          }
+          promise.resolve(map)
+        } else {
+          promise.reject("BANNER_ERROR", result.exceptionOrNull()?.message)
+        }
+      }
+    } catch (t: Throwable) {
+      promise.reject("BANNER_ERROR", t.message, t)
+    }
+  }
+
+  // ===== 7. Offerwall (3개) =====
+
+  @ReactMethod
+  fun openOfferwall(placementId: String?, promise: Promise) {
+    try {
+      reactContext.currentActivity?.let { activity ->
+        val callback = object : OfferwallCallback {
+          override fun onOpened() {
+            promise.resolve(createResponse(true, "Offerwall opened"))
+          }
+
+          override fun onClosed() {
+            // 이미 resolve 되었으므로 무시
+          }
+
+          override fun onError(message: String) {
+            // 이미 resolve 되었으므로 무시
+          }
+
+          override fun onRewardEarned(amount: Int) {
+            // 이미 resolve 되었으므로 무시
+          }
+        }
+
+        // Event callback for custom events
+        val eventCallback = object : OfferwallEventCallback {
+          override fun onCustomEvent(eventType: String, payload: Map<String, Any?>) {
+            android.util.Log.d("AdchainSdk", "[WebView → App] Custom Event: type=$eventType, payload=$payload")
+            // Sample 앱에서 처리하도록 이벤트만 전달 (Toast/Alert 표시 안 함)
+          }
+
+          override fun onDataRequest(requestId: String, requestType: String, params: Map<String, Any?>): Map<String, Any?>? {
+            android.util.Log.d("AdchainSdk", "[WebView → App] Data Request: type=$requestType, params=$params")
+
+            // Return mock data based on request type
+            val response = when (requestType) {
+              "user_points" -> mapOf("points" to 12345, "currency" to "KRW")
+              "user_profile" -> mapOf("userId" to "test_123", "nickname" to "TestPlayer", "level" to 42)
+              "app_version" -> mapOf("version" to "1.0.0", "buildNumber" to 100)
+              else -> null
+            }
+
+            android.util.Log.d("AdchainSdk", "[App → WebView] Data Response: $response")
+            return response
+          }
+        }
+
+        val finalPlacementId = placementId ?: ""
+        AdchainSdk.openOfferwall(activity, finalPlacementId, callback, eventCallback)
+      } ?: promise.reject("OFFERWALL_ERROR", "Current activity is null")
+    } catch (t: Throwable) {
+      promise.reject("OFFERWALL_ERROR", t.message, t)
+    }
+  }
+
+  @ReactMethod
+  fun openOfferwallWithUrl(url: String, placementId: String?, promise: Promise) {
+    try {
+      reactContext.currentActivity?.let { activity ->
+        val callback = object : OfferwallCallback {
+          override fun onOpened() {
+            promise.resolve(createResponse(true, "Offerwall opened with URL"))
+          }
+
+          override fun onClosed() {
+            // 이미 resolve 되었으므로 무시
+          }
+
+          override fun onError(message: String) {
+            // 이미 resolve 되었으므로 무시
+          }
+
+          override fun onRewardEarned(amount: Int) {
+            // 이미 resolve 되었으므로 무시
+          }
+        }
+
+        // Event callback for custom events
+        val eventCallback = object : OfferwallEventCallback {
+          override fun onCustomEvent(eventType: String, payload: Map<String, Any?>) {
+            android.util.Log.d("AdchainSdk", "[WebView → App] Custom Event: type=$eventType, payload=$payload")
+            // Sample 앱에서 처리하도록 이벤트만 전달 (Toast/Alert 표시 안 함)
+          }
+
+          override fun onDataRequest(requestId: String, requestType: String, params: Map<String, Any?>): Map<String, Any?>? {
+            android.util.Log.d("AdchainSdk", "[WebView → App] Data Request: type=$requestType, params=$params")
+
+            // Return mock data based on request type
+            val response = when (requestType) {
+              "user_points" -> mapOf("points" to 12345, "currency" to "KRW")
+              "user_profile" -> mapOf("userId" to "test_123", "nickname" to "TestPlayer", "level" to 42)
+              "app_version" -> mapOf("version" to "1.0.0", "buildNumber" to 100)
+              else -> null
+            }
+
+            android.util.Log.d("AdchainSdk", "[App → WebView] Data Response: $response")
+            return response
+          }
+        }
+
+        val finalPlacementId = placementId ?: ""
+        AdchainSdk.openOfferwallWithUrl(url, activity, finalPlacementId, callback, eventCallback)
+      } ?: promise.reject("OFFERWALL_ERROR", "Current activity is null")
+    } catch (t: Throwable) {
+      promise.reject("OFFERWALL_ERROR", t.message, t)
+    }
+  }
+
+  @ReactMethod
+  fun openExternalBrowser(url: String, placementId: String?, promise: Promise) {
+    try {
+      reactContext.currentActivity?.let { activity ->
+        val finalPlacementId = placementId ?: ""
+        val success = AdchainSdk.openExternalBrowser(url, activity, finalPlacementId)
+
+        if (success) {
+          promise.resolve(createResponse(true, "External browser opened"))
+        } else {
+          promise.reject("BROWSER_ERROR", "Failed to open external browser")
+        }
+      } ?: promise.reject("BROWSER_ERROR", "Current activity is null")
+    } catch (t: Throwable) {
+      promise.reject("BROWSER_ERROR", t.message, t)
+    }
+  }
+
+  @ReactMethod
+  fun openAdjoeOfferwall(placementId: String?, promise: Promise) {
+    try {
+      reactContext.currentActivity?.let { activity ->
+        val callback = object : OfferwallCallback {
+          override fun onOpened() {
+            promise.resolve(createResponse(true, "Adjoe Offerwall opened"))
+          }
+
+          override fun onClosed() {
+            // 이미 resolve 되었으므로 무시
+          }
+
+          override fun onError(message: String) {
+            // 이미 resolve 되었으므로 무시
+          }
+
+          override fun onRewardEarned(amount: Int) {
+            // 이미 resolve 되었으므로 무시
+          }
+        }
+
+        val finalPlacementId = placementId ?: ""
+        AdchainSdk.openAdjoeOfferwall(activity, finalPlacementId, callback)
+      } ?: promise.reject("ADJOE_ERROR", "Current activity is null")
+    } catch (t: Throwable) {
+      promise.reject("ADJOE_ERROR", t.message, t)
+    }
+  }
+
+  // ===== Event Emitter Methods =====
+  
+  @ReactMethod
+  fun addListener(eventName: String) {
+    // iOS와의 호환성을 위해 필요하지만 Android에서는 구현 불필요
+  }
+  
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    // iOS와의 호환성을 위해 필요하지만 Android에서는 구현 불필요
+  }
+  
+  // ===== Helper Methods =====
+  
+  private fun createResponse(success: Boolean, message: String): WritableMap {
+    return Arguments.createMap().apply {
+      putBoolean("success", success)
+      putString("message", message)
+    }
+  }
+  
+  @Deprecated("Deprecated in Java")
+  override fun onCatalystInstanceDestroy() {
+    super.onCatalystInstanceDestroy()
+    quizInstances.clear()
+    missionInstances.clear()
+  }
+}