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

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 1SelfWorld Labs
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,211 @@
+# @adchain/expo-sdk
+
+AdChain SDK for React Native with full Expo support.
+
+## 🚨 Important Notices
+
+### Expo Go Not Supported
+This SDK includes native code and **does not work in Expo Go**.
+
+You must use:
+- ✅ Development Build: `npx expo run:android` or `npx expo run:ios`
+- ✅ EAS Build: `eas build --profile development`
+
+### 🔐 Security Notice
+app.json에 저장된 API 키는 앱 번들에 포함됩니다.
+
+**권장사항:**
+- ✅ **개발/테스트:** app.json 사용 OK
+- ⚠️ **프로덕션:** 환경별 키 분리 권장
+  - Android: `buildConfigField` 사용
+  - iOS: `xcconfig` 파일 사용
+- ❌ **절대 금지:** Private API 키, 결제/인증 비밀키 노출
+
+**대안:**
+```typescript
+// 런타임에 서버에서 토큰 발급
+const token = await fetchTokenFromServer();
+await AdchainSDK.initializeWithToken(token);
+```
+
+## Installation
+
+```bash
+npx expo install @adchain/expo-sdk expo-constants
+```
+
+**Note:** `expo-constants` is a peer dependency. Install it separately.
+
+## Configuration
+
+Add to your `app.json`:
+
+```json
+{
+  "expo": {
+    "plugins": [
+      [
+        "@adchain/expo-sdk",
+        {
+          "appKey": "YOUR_APP_KEY",
+          "appSecret": "YOUR_APP_SECRET",
+          "environment": "PRODUCTION"
+        }
+      ]
+    ]
+  }
+}
+```
+
+## Usage
+
+```typescript
+import { useEffect } from 'react';
+import AdchainSDK from '@adchain/expo-sdk';
+
+export default function App() {
+  useEffect(() => {
+    // Auto-initialize using app.json config
+    AdchainSDK.autoInitialize()
+      .then(() => console.log('SDK ready'))
+      .catch(console.error);
+  }, []);
+
+  const handleLogin = async () => {
+    await AdchainSDK.login({ userId: 'user123' });
+  };
+
+  const handleOfferwall = async () => {
+    await AdchainSDK.openOfferwall('placement-id');
+  };
+}
+```
+
+## API Reference
+
+### Core Methods
+- `autoInitialize()` - Auto-initialize using app.json config
+- `initialize(config)` - Manual initialization
+- `login(user)` - User login
+- `logout()` - User logout
+- `isLoggedIn()` - Check login status
+- `getCurrentUser()` - Get current user info
+
+### Offerwall
+- `openOfferwall(placementId?)` - Open offerwall
+- `openAdjoeOfferwall(placementId?)` - Open ADJOE offerwall
+
+### Quiz & Mission
+- `loadQuizList(unitId)` - Load quiz list
+- `clickQuiz(unitId, quizId)` - Click quiz
+- `loadMissionList(unitId)` - Load mission list
+- `clickMission(unitId, missionId)` - Click mission
+- `claimReward(unitId)` - Claim reward
+
+### Debug
+- `getUserId()` - Get current user ID
+- `getIFA()` - Get advertising ID
+- `isInitialized()` - Check SDK initialization
+
+## 🔧 Technical Notes
+
+### Swift 5.5 (Not 5.9)
+This SDK uses **Swift 5.5** due to known issues with optional parameter passing
+in React Native bridges with Swift 5.9.
+
+**Background:** In production, we experienced bugs where optional parameters in
+Swift 5.9 were not properly passed to React Native, causing silent failures.
+
+Tested and stable with:
+- Xcode 14.x - 15.x
+- Swift 5.5
+- iOS 14.0+
+
+### Kotlin Standard Library
+The SDK includes `kotlin-stdlib:1.9.21` as required by the native AdChain SDK.
+If you experience version conflicts, Gradle will automatically resolve to the
+host app's version.
+
+### React Native Dependency
+The SDK uses `compileOnly` for `react-android` to avoid duplicate classes in
+the AAR. The dependency is provided by the host application.
+
+## Build & Run
+
+```bash
+# Prebuild (generate native code)
+npx expo prebuild
+
+# Verify plugin applied
+cat android/settings.gradle | grep jitpack
+cat ios/Podfile | grep AdChainSDK
+
+# Run on Android
+npx expo run:android
+
+# Run on iOS
+npx expo run:ios
+```
+
+## Requirements
+
+- Expo SDK 50+
+- React Native 0.74+
+- iOS 14.0+
+- Android API 24+
+- **Development Build** (Expo Go not supported)
+
+## Troubleshooting
+
+### "SDK not initialized" error
+- Make sure you added the plugin to app.json
+- Check that appKey and appSecret are correct
+- Verify you called `autoInitialize()` before other methods
+
+### "Expo config not found" error
+- You're probably using Expo Go (not supported)
+- Use: `npx expo run:android` or `npx expo run:ios`
+
+### "expo-constants not found"
+- Install peer dependency: `npx expo install expo-constants`
+
+### Prebuild fails
+- Check @expo/config-plugins is in devDependencies
+- Try: `rm -rf node_modules && npm install`
+
+### JitPack not found (Android)
+- Verify settings.gradle has maven { url "https://jitpack.io" }
+- Check internet connection
+- Try: cd android && ./gradlew clean
+
+### Pod install fails (iOS)
+- Check Git URL is correct
+- Verify tag v1.0.42 exists
+- Try: cd ios && rm -rf Pods Podfile.lock && pod install
+
+## Version Compatibility
+
+| Package Version | Android SDK | iOS SDK | Swift | Expo SDK |
+|----------------|-------------|---------|-------|----------|
+| 1.0.0 | v1.0.28 | v1.0.42 | 5.5 | 50-53 |
+
+## Known Limitations
+
+### v1.0.0
+- OTA updates (expo-updates) not yet supported - use Development Build
+- Swift 5.9 optional parameter bug - staying on 5.5
+- CocoaPods Trunk: AdChainSDK uses Git Pod (not on Trunk yet)
+
+### Planned for v1.1.0
+- expo-updates fallback support
+- Conditional iOS plugin (Trunk vs Git)
+- Server-side token initialization
+- Enhanced error messages
+
+## License
+
+Proprietary
+
+## Support
+
+Email: contacts@1self.world

package/adchain-sdk-react-native.podspec

@@ -0,0 +1,25 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "adchain-sdk-react-native"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "14.0" }
+  s.source       = { :git => "https://github.com/1selfworld-labs/adchain-sdk-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  # Swift 5.5 maintained (avoiding 5.9 optional parameter bugs)
+  # In production, we experienced bugs where optional parameters in Swift 5.9
+  # were not properly passed to React Native bridges, causing silent failures.
+  s.swift_version = '5.5'
+
+  s.dependency "React-Core"
+  s.dependency "AdChainSDK"
+end

package/android/build.gradle

@@ -0,0 +1,38 @@
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
+
+android {
+  namespace "com.adchain.exposdk"
+
+  compileSdk safeExtGet('compileSdkVersion', 34)
+
+  defaultConfig {
+    minSdkVersion safeExtGet('minSdkVersion', 24)
+    targetSdkVersion safeExtGet('targetSdkVersion', 34)
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = '17'
+  }
+
+  lintOptions {
+    abortOnError false
+  }
+}
+
+// Repositories are managed by the host app's settings.gradle
+
+dependencies {
+  implementation 'com.facebook.react:react-native:+'
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.21"
+  implementation 'com.github.1selfworld-labs:adchain-sdk-android:v1.0.28'
+}

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

@@ -0,0 +1,288 @@
+package com.adchain.exposdk
+
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.adchain.sdk.core.AdchainSdk
+import com.adchain.sdk.offerwall.AdchainOfferwallView
+import com.adchain.sdk.offerwall.OfferwallCallback
+import com.adchain.sdk.offerwall.OfferwallEventCallback
+
+class AdchainOfferwallViewManager : SimpleViewManager<AdchainOfferwallView>() {
+
+    companion object {
+        private const val TAG = "OfferwallViewManager"
+        private const val REACT_CLASS = "AdchainOfferwallView"
+        private const val COMMAND_LOAD_OFFERWALL = 1
+        private const val COMMAND_HANDLE_BACK_PRESS = 2
+        private const val COMMAND_SEND_DATA_RESPONSE = 3  // NEW
+    }
+
+    override fun getName() = REACT_CLASS
+
+    override fun createViewInstance(reactContext: ThemedReactContext): AdchainOfferwallView {
+        Log.d(TAG, "createViewInstance called")
+        return AdchainOfferwallView(reactContext)
+    }
+
+    override fun getCommandsMap(): Map<String, Int> {
+        Log.d(TAG, "getCommandsMap called")
+        return mapOf(
+            "loadOfferwall" to COMMAND_LOAD_OFFERWALL,
+            "handleBackPress" to COMMAND_HANDLE_BACK_PRESS,
+            "sendDataResponse" to COMMAND_SEND_DATA_RESPONSE  // NEW
+        )
+    }
+
+    // Store pending data request responses
+    private val pendingDataResponses = mutableMapOf<String, Map<String, Any?>>()
+
+    override fun receiveCommand(
+        root: AdchainOfferwallView,
+        commandId: String?,
+        args: ReadableArray?
+    ) {
+        Log.d(TAG, "receiveCommand called - commandId: $commandId, args: $args")
+        when (commandId) {
+            "loadOfferwall" -> {
+                val placementId = args?.getString(0) ?: ""
+                Log.d(TAG, "loadOfferwall command - placementId: $placementId")
+                loadOfferwall(root, placementId)
+            }
+            "handleBackPress" -> {
+                Log.d(TAG, "handleBackPress command")
+                val handled = root.handleBackPress()
+                Log.d(TAG, "handleBackPress result: $handled")
+            }
+            "sendDataResponse" -> {  // NEW
+                val requestId = args?.getString(0) ?: ""
+                val responseData = args?.getMap(1)?.toHashMap()
+                Log.d(TAG, "sendDataResponse command - requestId: $requestId, data: $responseData")
+                if (responseData != null) {
+                    pendingDataResponses[requestId] = responseData
+                }
+            }
+            else -> {
+                Log.w(TAG, "Unknown command: $commandId")
+            }
+        }
+    }
+
+    private fun loadOfferwall(view: AdchainOfferwallView, placementId: String) {
+        Log.d(TAG, "loadOfferwall method called - placementId: $placementId")
+
+        if (placementId.isEmpty()) {
+            Log.w(TAG, "placementId is empty, returning")
+            return
+        }
+
+        try {
+            // Get SDK config, user, and offerwall URL
+            val config = AdchainSdk.getConfig()
+            val user = AdchainSdk.getCurrentUser()
+            val offerwallUrl = AdchainSdk.getOfferwallUrl()
+
+            Log.d(TAG, "SDK state - config: ${config != null}, user: ${user != null}, url: $offerwallUrl")
+
+            if (config == null) {
+                Log.e(TAG, "SDK not initialized")
+                sendErrorEvent(view, "SDK not initialized")
+                return
+            }
+
+            if (user == null) {
+                Log.e(TAG, "User not logged in")
+                sendErrorEvent(view, "User not logged in")
+                return
+            }
+
+            if (offerwallUrl.isNullOrEmpty()) {
+                Log.e(TAG, "Offerwall URL not available")
+                sendErrorEvent(view, "Offerwall URL not available")
+                return
+            }
+
+            Log.d(TAG, "About to call view.loadOfferwall()")
+            Log.d(TAG, "Parameters - baseUrl: $offerwallUrl, userId: ${user.userId}, appKey: ${config.appKey}, placementId: $placementId")
+
+            // Set callback for offerwall events
+            Log.d(TAG, "Setting callback...")
+            view.setCallback(object : OfferwallCallback {
+                override fun onOpened() {
+                    sendEvent(view, "onOfferwallOpened", Arguments.createMap())
+                }
+
+                override fun onClosed() {
+                    sendEvent(view, "onOfferwallClosed", Arguments.createMap())
+                }
+
+                override fun onError(message: String) {
+                    val map = Arguments.createMap().apply {
+                        putString("error", message)
+                    }
+                    sendEvent(view, "onOfferwallError", map)
+                }
+
+                override fun onRewardEarned(amount: Int) {
+                    val map = Arguments.createMap().apply {
+                        putInt("amount", amount)
+                    }
+                    sendEvent(view, "onRewardEarned", map)
+                }
+
+                override fun onHeightChanged(height: Int) {
+                    Log.d(TAG, "onHeightChanged callback received - height: $height")
+                    val map = Arguments.createMap().apply {
+                        putInt("height", height)
+                    }
+                    sendEvent(view, "onHeightChange", map)
+                }
+            })
+
+            // NEW: Set event callback for custom events
+            Log.d(TAG, "Setting event callback...")
+            view.setEventCallback(object : OfferwallEventCallback {
+                override fun onCustomEvent(eventType: String, payload: Map<String, Any?>) {
+                    Log.d(TAG, "onCustomEvent received - type: $eventType, payload: $payload")
+                    // Sample 앱에서 처리하도록 이벤트만 전달 (Toast 표시 안 함)
+
+                    val map = Arguments.createMap().apply {
+                        putString("eventType", eventType)
+                        putMap("payload", convertMapToWritableMap(payload))
+                    }
+                    sendEvent(view, "onCustomEvent", map)
+                }
+
+                override fun onDataRequest(
+                    requestId: String,
+                    requestType: String,
+                    params: Map<String, Any?>
+                ): Map<String, Any?>? {
+                    Log.d(TAG, "onDataRequest received - id: $requestId, type: $requestType, params: $params")
+
+                    // Send event to React Native
+                    val map = Arguments.createMap().apply {
+                        putString("requestId", requestId)
+                        putString("requestType", requestType)
+                        putMap("params", convertMapToWritableMap(params))
+                    }
+                    sendEvent(view, "onDataRequest", map)
+
+                    // Wait for response from React Native (with timeout)
+                    val startTime = System.currentTimeMillis()
+                    val timeout = 5000L // 5 seconds
+
+                    while (System.currentTimeMillis() - startTime < timeout) {
+                        val response = pendingDataResponses.remove(requestId)
+                        if (response != null) {
+                            Log.d(TAG, "Data response received for request: $requestId")
+                            return response
+                        }
+                        Thread.sleep(10)
+                    }
+
+                    Log.w(TAG, "Data request timeout: $requestId")
+                    return null
+                }
+            })
+
+            // Load offerwall
+            Log.d(TAG, "Calling view.loadOfferwall()...")
+            view.loadOfferwall(
+                baseUrl = offerwallUrl,
+                userId = user.userId,
+                appKey = config.appKey,
+                placementId = placementId
+            )
+            Log.d(TAG, "view.loadOfferwall() call completed")
+
+        } catch (e: Exception) {
+            Log.e(TAG, "Exception in loadOfferwall", e)
+            e.printStackTrace()
+            sendErrorEvent(view, "Failed to load offerwall: ${e.message}")
+        }
+    }
+
+    private fun sendEvent(view: AdchainOfferwallView, eventName: String, params: WritableMap) {
+        Log.d(TAG, "sendEvent called - eventName: $eventName, params: $params")
+        val reactContext = view.context as ReactContext
+        try {
+            reactContext
+                .getJSModule(com.facebook.react.uimanager.events.RCTEventEmitter::class.java)
+                .receiveEvent(view.id, eventName, params)
+            Log.d(TAG, "sendEvent completed successfully")
+        } catch (e: Exception) {
+            Log.e(TAG, "sendEvent failed", e)
+            e.printStackTrace()
+        }
+    }
+
+    private fun sendErrorEvent(view: AdchainOfferwallView, error: String) {
+        val map = Arguments.createMap().apply {
+            putString("error", error)
+        }
+        sendEvent(view, "onOfferwallError", map)
+    }
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> {
+        return mapOf(
+            "onOfferwallOpened" to mapOf("registrationName" to "onOfferwallOpened"),
+            "onOfferwallClosed" to mapOf("registrationName" to "onOfferwallClosed"),
+            "onOfferwallError" to mapOf("registrationName" to "onOfferwallError"),
+            "onRewardEarned" to mapOf("registrationName" to "onRewardEarned"),
+            "onHeightChange" to mapOf("registrationName" to "onHeightChange"),
+            "onCustomEvent" to mapOf("registrationName" to "onCustomEvent"),  // NEW
+            "onDataRequest" to mapOf("registrationName" to "onDataRequest")   // NEW
+        )
+    }
+
+    // Helper function to convert Map to WritableMap
+    private fun convertMapToWritableMap(map: Map<String, Any?>): WritableMap {
+        val writableMap = Arguments.createMap()
+        map.forEach { (key, value) ->
+            when (value) {
+                null -> writableMap.putNull(key)
+                is String -> writableMap.putString(key, value)
+                is Int -> writableMap.putInt(key, value)
+                is Double -> writableMap.putDouble(key, value)
+                is Boolean -> writableMap.putBoolean(key, value)
+                is Map<*, *> -> {
+                    @Suppress("UNCHECKED_CAST")
+                    writableMap.putMap(key, convertMapToWritableMap(value as Map<String, Any?>))
+                }
+                is List<*> -> {
+                    writableMap.putArray(key, convertListToWritableArray(value))
+                }
+                else -> Log.w(TAG, "Unsupported value type for key: $key")
+            }
+        }
+        return writableMap
+    }
+
+    private fun convertListToWritableArray(list: List<*>): com.facebook.react.bridge.WritableArray {
+        val writableArray = Arguments.createArray()
+        list.forEach { item ->
+            when (item) {
+                null -> writableArray.pushNull()
+                is String -> writableArray.pushString(item)
+                is Int -> writableArray.pushInt(item)
+                is Double -> writableArray.pushDouble(item)
+                is Boolean -> writableArray.pushBoolean(item)
+                is Map<*, *> -> {
+                    @Suppress("UNCHECKED_CAST")
+                    writableArray.pushMap(convertMapToWritableMap(item as Map<String, Any?>))
+                }
+                is List<*> -> {
+                    writableArray.pushArray(convertListToWritableArray(item))
+                }
+                else -> Log.w(TAG, "Unsupported item type in list")
+            }
+        }
+        return writableArray
+    }
+}