@tenqube/visual-reward-react-native 1.1.3

package/android/build.gradle

@@ -0,0 +1,47 @@
+buildscript {
+    ext.kotlin_version = ext.has("kotlinVersion") ? ext.kotlinVersion : "1.9.24"
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath "com.android.tools.build:gradle:8.1.1"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+    namespace "com.tenqube.visualreward"
+    compileSdkVersion safeExtGet("compileSdkVersion", 34)
+
+    defaultConfig {
+        minSdkVersion safeExtGet("minSdkVersion", 24)
+        targetSdkVersion safeExtGet("targetSdkVersion", 34)
+        // GMA / AdPopcorn 리플렉션 대상 보존 규칙을 호스트 앱 R8 에 자동 전파.
+        consumerProguardFiles "consumer-rules.pro"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    // React Native (autolink 이 버전 주입)
+    implementation "com.facebook.react:react-native:+"
+    // GMA / AdPopcorn / react-native-webview 는 리플렉션·뷰탐색으로만 접근하므로
+    // 컴파일 의존성 없음(호스트 앱이 각 SDK 를 링크하면 리플렉션이 동작, 없으면 no-op).
+}

package/android/consumer-rules.pro

@@ -0,0 +1,9 @@
+# AdPopcorn SSP 브릿지 (Class.forName 문자열 리플렉션으로 참조 — R8가 못 봄)
+# 호스트 앱에 AdPopcorn SDK가 없으면 이 룰은 무시됨
+-keep class com.igaworks.ssp.part.hybrid.AdPopcornSSPJsBridge { *; }
+
+# AdMob WebView API (Class.forName 문자열 리플렉션으로 참조 — R8가 못 봄)
+# 호스트 앱에 Google Mobile Ads SDK가 없으면 이 룰은 무시됨
+# Next-Gen(libraries.ads.mobile.sdk) 우선, 레거시(gms.ads) 폴백 — 둘 다 keep
+-keep class com.google.android.libraries.ads.mobile.sdk.MobileAds { *; }
+-keep class com.google.android.gms.ads.MobileAds { *; }

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.tenqube.visualreward" />

package/android/src/main/java/com/tenqube/visualreward/VisualRewardModule.kt

@@ -0,0 +1,223 @@
+package com.tenqube.visualreward
+
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebView
+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.UiThreadUtil
+
+/**
+ * Tenqube Visual Reward — React Native 네이티브 모듈 (Android).
+ *
+ * Kotlin/Swift/Flutter SDK 와 1:1 로, 리워드 웹뷰를 GMA(Google Mobile Ads) 에 등록하고
+ * AdPopcorn SSP JS 브릿지를 주입한다. react-native-webview 의 내부 WebView 인스턴스를
+ * 노출하지 않으므로, Flutter 플러그인과 동일하게 뷰 계층에서 WebView 를 탐색한다.
+ *
+ * GMA / AdPopcorn 은 리플렉션으로만 참조한다 — 호스트 앱에 각 SDK 가 링크돼 있으면 동작하고,
+ * 없으면 조용히 no-op 이다.
+ */
+class VisualRewardModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "VisualReward"
+
+    /**
+     * 리워드 웹뷰에 GMA registerWebView 등록 + AdPopcorn 네이티브 브릿지 주입을 수행한다(best-effort).
+     *
+     * JS 는 실제 오퍼월 URL 로드 "전"(about:blank 로드 완료 시점)에 호출하고 완료를 await 한다.
+     * Android 의 addJavascriptInterface 는 "다음 로드"부터 적용되므로, about:blank 에서 주입한 뒤
+     * 실제 URL 을 로드하면 리로드 없이 브릿지가 바인딩된다.
+     */
+    @ReactMethod
+    fun attachAdBridges(promise: Promise) {
+        UiThreadUtil.runOnUiThread {
+            try {
+                val webView = findRewardWebView()
+                if (webView == null) {
+                    Log.w(TAG, "attachAdBridges skipped (WebView 미검출)")
+                    promise.resolve(false)
+                    return@runOnUiThread
+                }
+                registerAdMobWebView(webView)
+                injectAdPopcornBridge(webView)
+                applyLightStatusBar(webView)
+                promise.resolve(true)
+            } catch (e: Exception) {
+                Log.e(TAG, "attachAdBridges failed: ${e.javaClass.simpleName}", e)
+                promise.resolve(false)
+            }
+        }
+    }
+
+    /**
+     * Android intent:// / market:// 스킴을 네이티브에서 처리한다.
+     * Kotlin SDK RewardWebViewActivity.tryHandleSpecialSchemes 와 동일.
+     * 항상 handled 여부(boolean)를 resolve 한다.
+     */
+    @ReactMethod
+    fun handleIntentScheme(url: String, promise: Promise) {
+        try {
+            val uri = Uri.parse(url)
+            when (uri.scheme?.lowercase()) {
+                "intent" -> {
+                    try {
+                        val parsedIntent = Intent.parseUri(url, Intent.URI_INTENT_SCHEME)
+                        val pkg = parsedIntent.`package`
+                        val fallbackUrl = parsedIntent.getStringExtra("browser_fallback_url")
+                        if (!pkg.isNullOrEmpty()) {
+                            try {
+                                startExternal(parsedIntent)
+                            } catch (_: ActivityNotFoundException) {
+                                if (!fallbackUrl.isNullOrEmpty()) openExternally(Uri.parse(fallbackUrl))
+                                else openExternally(Uri.parse("market://details?id=$pkg"))
+                            }
+                        } else if (!fallbackUrl.isNullOrEmpty()) {
+                            openExternally(Uri.parse(fallbackUrl))
+                        }
+                    } catch (_: Exception) {
+                    }
+                    promise.resolve(true)
+                }
+                "market" -> {
+                    openExternally(uri)
+                    promise.resolve(true)
+                }
+                else -> promise.resolve(false)
+            }
+        } catch (_: Exception) {
+            promise.resolve(false)
+        }
+    }
+
+    // MARK: - GMA registerWebView (리플렉션)
+    // Kotlin SDK RewardWebViewActivity.onCreate 의 등록 로직과 동일.
+
+    private fun registerAdMobWebView(webView: WebView) {
+        val mobileAdsClassNames = listOf(
+            "com.google.android.libraries.ads.mobile.sdk.MobileAds", // Next-Gen
+            "com.google.android.gms.ads.MobileAds",                  // 레거시
+        )
+        var adMobRegistered = false
+        var adMobClassFound = false
+        for (className in mobileAdsClassNames) {
+            val clazz = try {
+                Class.forName(className)
+            } catch (e: ClassNotFoundException) {
+                continue
+            }
+            adMobClassFound = true
+            try {
+                clazz.getMethod("registerWebView", WebView::class.java).invoke(null, webView)
+                Log.i(TAG, "AdMob registerWebView registered ($className)")
+                adMobRegistered = true
+                break
+            } catch (e: NoSuchMethodException) {
+                // 시그니처 불일치 — 다음 후보 시도
+            } catch (e: Exception) {
+                Log.e(TAG, "AdMob registerWebView failed ($className): ${e.javaClass.simpleName}", e)
+            }
+        }
+        if (!adMobRegistered) {
+            if (adMobClassFound) {
+                Log.w(TAG, "Google Mobile Ads SDK present but registerWebView failed — AdMob WebView API not registered")
+            } else {
+                Log.w(TAG, "Google Mobile Ads SDK not on classpath — AdMob WebView API not registered")
+            }
+        }
+    }
+
+    // MARK: - AdPopcorn SSP 브릿지 주입 (리플렉션)
+    // MARK: - AdPopcorn SSP 네이티브 브릿지 주입 (리플렉션)
+    // AdPopcorn 의 실제 네이티브 브릿지 AdPopcornSSPJsBridge(Context, WebView) 를 주입한다.
+    // 이 브릿지 생성자가 네이티브 SSP SDK 에 웹뷰를 등록해, 웹 배너 SDK(AdPopcornSSPWebSDK)가
+    // 네이티브 컨텍스트로 광고를 서빙할 수 있게 한다. (JS shim 으로는 이 네이티브 등록을 대체할 수 없음)
+
+    private fun injectAdPopcornBridge(webView: WebView) {
+        try {
+            val bridgeClass = Class.forName("com.igaworks.ssp.part.hybrid.AdPopcornSSPJsBridge")
+            val constructor = bridgeClass.getConstructor(Context::class.java, WebView::class.java)
+            val context: Context = reactApplicationContext.currentActivity ?: reactApplicationContext
+            val bridge = constructor.newInstance(context, webView)
+            webView.addJavascriptInterface(bridge, "AdPopcornSSPJsBridge")
+            Log.i(TAG, "AdPopcornSSPJsBridge registered")
+        } catch (e: ClassNotFoundException) {
+            Log.w(TAG, "AdPopcornSSPJsBridge class not on classpath — bridge not registered")
+        } catch (e: Exception) {
+            Log.e(TAG, "AdPopcornSSPJsBridge registration failed: ${e.javaClass.simpleName}", e)
+        }
+    }
+
+    // MARK: - 상태바 아이콘 색상 (Dialog window)
+    // 리워드는 RN Modal(별도 Dialog window)로 뜬다. RN StatusBar API 는 Activity window 만
+    // 제어하므로 Modal 의 상태바 아이콘 색이 바뀌지 않는다(흰 배경에 흰 아이콘 → 안 보임).
+    // 리워드 WebView 는 Dialog window 에 붙어 있으므로, 그 뷰에서 WindowInsetsController 를 얻어
+    // 해당 Dialog window 의 상태바 아이콘을 dark(검정)로 설정한다. 상단 배경은 흰색(safe-area).
+
+    private fun applyLightStatusBar(webView: WebView) {
+        try {
+            val controller = androidx.core.view.ViewCompat.getWindowInsetsController(webView)
+            if (controller != null) {
+                controller.isAppearanceLightStatusBars = true
+                Log.i(TAG, "status bar set to light appearance (dark icons)")
+            } else {
+                Log.w(TAG, "WindowInsetsController 미검출 — 상태바 아이콘 색 미설정")
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "applyLightStatusBar failed: ${e.javaClass.simpleName}", e)
+        }
+    }
+
+    // MARK: - 뷰 계층에서 리워드 WebView 탐색
+    // 화면에 보이는 가장 큰 WebView 를 리워드 웹뷰로 간주한다.
+    // (react-native-webview 의 RNCWebView 는 android.webkit.WebView 를 상속)
+
+    private fun findRewardWebView(): WebView? {
+        val activity: Activity = reactApplicationContext.currentActivity ?: return null
+        val root = activity.window?.decorView?.rootView ?: return null
+        val webViews = ArrayList<WebView>()
+        collectWebViews(root, webViews)
+        return webViews
+            .filter { it.isShown }
+            .maxByOrNull { it.width.toLong() * it.height.toLong() }
+            ?: webViews.firstOrNull()
+    }
+
+    private fun collectWebViews(view: View, out: MutableList<WebView>) {
+        if (view is WebView) out.add(view)
+        if (view is ViewGroup) {
+            for (i in 0 until view.childCount) collectWebViews(view.getChildAt(i), out)
+        }
+    }
+
+    // MARK: - 외부 실행 헬퍼
+
+    private fun startExternal(intent: Intent) {
+        val activity = reactApplicationContext.currentActivity
+        if (activity != null) {
+            activity.startActivity(intent)
+        } else {
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            reactApplicationContext.applicationContext.startActivity(intent)
+        }
+    }
+
+    private fun openExternally(uri: Uri) {
+        try {
+            startExternal(Intent(Intent.ACTION_VIEW, uri))
+        } catch (_: ActivityNotFoundException) {
+        }
+    }
+
+    companion object {
+        private const val TAG = "VisualReward"
+    }
+}

package/android/src/main/java/com/tenqube/visualreward/VisualRewardPackage.kt

@@ -0,0 +1,14 @@
+package com.tenqube.visualreward
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class VisualRewardPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(VisualRewardModule(reactContext))
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
+}

package/index.ts

@@ -0,0 +1,8 @@
+export { VisualReward } from "./src/VisualReward";
+export { default as VisualRewardContainer } from "./src/VisualRewardContainer";
+export { VisualRewardError } from "./src/types";
+export type {
+  VisualRewardErrorCode,
+  VisualRewardInitializeOptions,
+  VisualRewardOpenOptions,
+} from "./src/types";

package/ios/VisualReward.m

@@ -0,0 +1,12 @@
+#import <React/RCTBridgeModule.h>
+
+// Swift 클래스 VisualReward 를 React Native 브릿지에 노출한다.
+@interface RCT_EXTERN_MODULE(VisualReward, NSObject)
+
+RCT_EXTERN_METHOD(attachAdBridges:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(hasTrackingDescription:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/VisualReward.swift

@@ -0,0 +1,135 @@
+import Foundation
+import React
+import UIKit
+import WebKit
+
+// Tenqube Visual Reward — React Native 네이티브 모듈 (iOS).
+//
+// Swift/Kotlin/Flutter SDK 와 1:1 로, 리워드 웹뷰를 GMA(Google Mobile Ads) 에 등록하고
+// AdPopcorn SSP JS 브릿지를 주입한다. react-native-webview 는 내부 WKWebView 인스턴스를
+// 노출하지 않으므로, Flutter 플러그인과 동일하게 뷰 계층에서 WKWebView 를 탐색한다.
+//
+// GMA / AdPopcorn 은 리플렉션으로만 참조한다 — 호스트 앱에 각 SDK 가 링크돼 있으면 동작하고,
+// 없으면 조용히 no-op 이다.
+@objc(VisualReward)
+class VisualReward: NSObject {
+
+  @objc static func requiresMainQueueSetup() -> Bool {
+    return false
+  }
+
+  // MARK: - JS 에 노출되는 메서드
+
+  /// 리워드 웹뷰에 GMA registerWebView 등록 + AdPopcorn 네이티브 브릿지 주입을 수행한다(best-effort).
+  /// JS 는 실제 오퍼월 URL 로드 전(about:blank 로드 완료 시점)에 호출하고 완료를 await 한다.
+  @objc(attachAdBridges:rejecter:)
+  func attachAdBridges(_ resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+    DispatchQueue.main.async {
+      guard let webView = VisualReward.findRewardWebView() else {
+        NSLog("VisualReward: attachAdBridges skipped (WKWebView 미검출)")
+        resolve(false)
+        return
+      }
+      VisualReward.registerAdMobWebView(webView)
+      VisualReward.injectAdPopcornBridge(webView)
+      resolve(true)
+    }
+  }
+
+  /// Info.plist 에 NSUserTrackingUsageDescription 키가 있는지 반환한다.
+  /// (Swift SDK 의 ATT 요청 게이팅과 동일)
+  @objc(hasTrackingDescription:rejecter:)
+  func hasTrackingDescription(_ resolve: @escaping RCTPromiseResolveBlock,
+                              rejecter reject: @escaping RCTPromiseRejectBlock) {
+    let has = Bundle.main.object(forInfoDictionaryKey: "NSUserTrackingUsageDescription") != nil
+    resolve(has)
+  }
+
+  // MARK: - GMA registerWebView (리플렉션)
+  // Swift SDK RewardWebViewController.setupLayout 의 GADMobileAds.registerWebView 와 동일.
+
+  private static func registerAdMobWebView(_ webView: WKWebView) {
+    guard let gadClass = NSClassFromString("GADMobileAds") else {
+      NSLog("VisualReward: Google Mobile Ads SDK not linked — AdMob WebView API not registered")
+      return
+    }
+    let sharedSel = NSSelectorFromString("sharedInstance")
+    let registerSel = NSSelectorFromString("registerWebView:")
+    if (gadClass as AnyObject).responds(to: sharedSel),
+       let shared = (gadClass as AnyObject).perform(sharedSel)?.takeUnretainedValue() as? NSObject,
+       shared.responds(to: registerSel) {
+      shared.perform(registerSel, with: webView)
+      NSLog("VisualReward: AdMob registerWebView registered")
+    } else {
+      NSLog("VisualReward: GADMobileAds present but registerWebView unavailable")
+    }
+  }
+
+  // MARK: - AdPopcorn SSP 네이티브 브릿지 주입 (리플렉션)
+  // Swift SDK 의 AdPopcornSSPWKScriptMessageHandler 를 리플렉션 생성해 대상 WKWebView 의
+  // userContentController 에 "AdPopcornSSPJsBridge" 이름으로 추가한다. 이 네이티브 핸들러가
+  // 네이티브 SSP 컨텍스트를 제공해, 웹 배너 SDK(AdPopcornSSPWebSDK)가 광고를 서빙할 수 있게 한다.
+
+  private static func injectAdPopcornBridge(_ webView: WKWebView) {
+    let ucc = webView.configuration.userContentController
+    ucc.removeScriptMessageHandler(forName: "AdPopcornSSPJsBridge")
+
+    guard let handlerClass = NSClassFromString("AdPopcornSSPWKScriptMessageHandler") as? NSObject.Type,
+          let handler = handlerClass.init() as? (WKScriptMessageHandler & NSObject) else {
+      NSLog("VisualReward: AdPopcornSSPWKScriptMessageHandler not linked — bridge not registered")
+      return
+    }
+    if let vc = webView.rewardOwningViewController() {
+      handler.setValue(vc, forKey: "viewController")
+    }
+    handler.setValue(webView, forKey: "webView")
+    ucc.add(handler, name: "AdPopcornSSPJsBridge")
+    objc_setAssociatedObject(webView, &VisualReward.adPopcornHandlerKey, handler, .OBJC_ASSOCIATION_RETAIN)
+    NSLog("VisualReward: AdPopcornSSPJsBridge registered")
+  }
+
+  private static var adPopcornHandlerKey: UInt8 = 0
+
+  // MARK: - 뷰 계층에서 리워드 WKWebView 탐색
+  // Flutter 플러그인과 동일: key window 하위의 WKWebView 중 화면에 보이는 가장 큰 것을
+  // 리워드 웹뷰로 간주한다. (react-native-webview 의 RNCWebView 는 WKWebView 를 subview 로 가짐)
+
+  private static func findRewardWebView() -> WKWebView? {
+    guard let window = keyWindow() else { return nil }
+    var webViews: [WKWebView] = []
+    collectWebViews(window, into: &webViews)
+    return webViews
+      .filter { $0.window != nil }
+      .max(by: { $0.bounds.width * $0.bounds.height < $1.bounds.width * $1.bounds.height })
+      ?? webViews.first
+  }
+
+  private static func keyWindow() -> UIWindow? {
+    let sceneWindow = UIApplication.shared.connectedScenes
+      .compactMap { $0 as? UIWindowScene }
+      .flatMap { $0.windows }
+      .first { $0.isKeyWindow }
+    if let sceneWindow = sceneWindow { return sceneWindow }
+    return UIApplication.shared.windows.first { $0.isKeyWindow }
+  }
+
+  private static func collectWebViews(_ view: UIView, into out: inout [WKWebView]) {
+    if let webView = view as? WKWebView { out.append(webView) }
+    for subview in view.subviews {
+      collectWebViews(subview, into: &out)
+    }
+  }
+}
+
+private extension UIView {
+  /// 이 뷰를 소유한 UIViewController 를 responder chain 에서 찾는다. (AdPopcorn 핸들러 viewController KVC 용)
+  func rewardOwningViewController() -> UIViewController? {
+    var responder: UIResponder? = self
+    while let r = responder {
+      if let vc = r as? UIViewController { return vc }
+      responder = r.next
+    }
+    return nil
+  }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@tenqube/visual-reward-react-native",
+  "version": "1.1.3",
+  "description": "Tenqube Visual Reward SDK for React Native",
+  "main": "index.ts",
+  "types": "index.ts",
+  "react-native": "index.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tenqube/visual-reward-sdk.git",
+    "directory": "react-native"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "android",
+    "ios",
+    "visual-reward-react-native.podspec",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@react-native-community/netinfo": "^11.0.0",
+    "react-native-idfa-aaid": "^0.1.1",
+    "react-native-device-info": "^10.0.0",
+    "react-native-orientation-locker": "^1.7.0",
+    "react-native-permissions": "^4.0.0",
+    "react-native-webview": "^13.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0",
+    "react-native-safe-area-context": ">=4.0.0",
+    "react-native-google-mobile-ads": "*",
+    "react-native-adpopcorn-ssp": "*"
+  },
+  "peerDependenciesMeta": {
+    "react-native-google-mobile-ads": {
+      "optional": true
+    },
+    "react-native-adpopcorn-ssp": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "typescript": "5"
+  }
+}

package/src/ConfigCache.ts

@@ -0,0 +1,45 @@
+import type { RemoteConfig } from './types';
+
+const TTL_MS = 3600 * 1000;
+const KEY_PREFIX = 'visual_reward_config_';
+
+interface CacheEntry {
+  config: RemoteConfig;
+  expiresAt: number;
+}
+
+let _storage: AsyncStorageLike | null = null;
+
+export interface AsyncStorageLike {
+  getItem(key: string): Promise<string | null>;
+  setItem(key: string, value: string): Promise<void>;
+  removeItem(key: string): Promise<void>;
+}
+
+export function setStorage(storage: AsyncStorageLike): void {
+  _storage = storage;
+}
+
+export async function readCache(appKey: string): Promise<RemoteConfig | null> {
+  if (!_storage) return null;
+  try {
+    const raw = await _storage.getItem(KEY_PREFIX + appKey);
+    if (!raw) return null;
+    const entry: CacheEntry = JSON.parse(raw);
+    if (Date.now() > entry.expiresAt) {
+      await _storage.removeItem(KEY_PREFIX + appKey);
+      return null;
+    }
+    return entry.config;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeCache(appKey: string, config: RemoteConfig): Promise<void> {
+  if (!_storage) return;
+  try {
+    const entry: CacheEntry = { config, expiresAt: Date.now() + TTL_MS };
+    await _storage.setItem(KEY_PREFIX + appKey, JSON.stringify(entry));
+  } catch {}
+}

package/src/NativeVisualReward.ts

@@ -0,0 +1,52 @@
+import { NativeModules, Platform } from "react-native";
+
+/**
+ * 네이티브 모듈(iOS Swift / Android Kotlin) 브릿지.
+ *
+ * - `attachAdBridges`: 리워드 웹뷰에 GMA registerWebView 등록 + AdPopcorn SSP 브릿지 주입(best-effort).
+ * - `hasTrackingDescription`(iOS): Info.plist 의 NSUserTrackingUsageDescription 존재 여부.
+ * - `handleIntentScheme`(Android): intent:// / market:// 스킴 네이티브 처리.
+ *
+ * 네이티브 모듈이 링크되지 않은 환경(예: 자동링크 누락)에서도 앱이 죽지 않도록 모든 호출을 방어한다.
+ */
+interface VisualRewardNativeModule {
+  attachAdBridges(): Promise<boolean>;
+  hasTrackingDescription(): Promise<boolean>;
+  handleIntentScheme(url: string): Promise<boolean>;
+}
+
+const NativeModule: Partial<VisualRewardNativeModule> | undefined =
+  NativeModules.VisualReward;
+
+/**
+ * 리워드 웹뷰에 GMA registerWebView + AdPopcorn 네이티브 브릿지를 연결한다.
+ * 실제 오퍼월 URL 로드 "전"(about:blank 로드 완료 시점)에 호출하고 완료를 await 한다.
+ * (Android addJavascriptInterface 는 다음 로드부터 적용되므로 순서가 중요)
+ */
+export async function attachAdBridges(): Promise<boolean> {
+  try {
+    return (await NativeModule?.attachAdBridges?.()) ?? false;
+  } catch (_) {
+    return false;
+  }
+}
+
+/** iOS: Info.plist 에 NSUserTrackingUsageDescription 키가 있는지. (Android/미링크 → false) */
+export async function hasTrackingDescription(): Promise<boolean> {
+  if (Platform.OS !== "ios") return false;
+  try {
+    return (await NativeModule?.hasTrackingDescription?.()) ?? false;
+  } catch (_) {
+    return false;
+  }
+}
+
+/** Android: intent:// / market:// 를 네이티브에서 처리. 처리 여부(handled)를 반환. (iOS/미링크 → false) */
+export async function handleIntentScheme(url: string): Promise<boolean> {
+  if (Platform.OS !== "android") return false;
+  try {
+    return (await NativeModule?.handleIntentScheme?.(url)) ?? false;
+  } catch (_) {
+    return false;
+  }
+}