hiqmobiad_sdk 1.0.0

package/README.md

@@ -0,0 +1,139 @@
+# OwnAd SDK
+
+React Native SDK for a rewarded video ad flow. The native Android screen now uses
+your live creative payload and renders a full-screen background video with:
+
+- top-left back affordance
+- mute toggle
+- bottom app card with logo, app name, and install button
+
+## Installation
+
+```bash
+npm install @priyahiq/own-ad-sdk
+cd android && ./gradlew
+```
+
+## Android Autolinking
+
+React Native 0.60+ autolinks the package. If you link manually, add this to
+`MainApplication`:
+
+```kotlin
+import com.ownad.adsdk.AdSdkPackage
+
+override fun getPackages(): List<ReactPackage> =
+    PackageList(this).packages.apply { add(AdSdkPackage()) }
+```
+
+## Using The SDK
+
+### 1. Initialize once at app start
+
+Point the SDK to your API base URL:
+
+```typescript
+import { initialize } from '@priyahiq/own-ad-sdk';
+
+await initialize('YOUR_APP_ID', {
+  baseUrl: 'https://myownadsprodapi.hiqmobi.in/api',
+  debug: __DEV__,
+});
+```
+
+### 2. Load and show a rewarded ad
+
+```typescript
+import { RewardedAd } from '@priyahiq/own-ad-sdk';
+
+const ad = RewardedAd.createForAdRequest('YOUR_AD_UNIT_ID');
+
+ad.addListener({
+  onLoaded: () => ad.show(),
+  onShown: () => console.log('ad shown'),
+  onClicked: () => console.log('install clicked'),
+  onFailedToLoad: (e) => console.warn('load failed', e.code, e.message),
+  onFailedToShow: (e) => console.warn('show failed', e.code, e.message),
+  onCompleted: () => {
+    // The video finished. The ad can now be closed safely.
+    ad.close();
+  },
+  onUserEarnedReward: (reward) => {
+    console.log(`earned ${reward.amount} ${reward.type}`);
+  },
+  onDismissed: () => console.log('ad dismissed'),
+});
+
+ad.load();
+```
+
+## Flow
+
+1. `load()` requests one creative from `GET /v1/ad`
+2. the native activity receives:
+   - `title`
+   - `app_name`
+   - `logo_url`
+   - `background_video_url`
+   - `background_image_url`
+   - `button_text`
+   - `click_url`
+   - `min_watch_seconds`
+3. `show()` opens the full-screen player
+4. the install button opens `click_url`
+5. when playback ends, `onCompleted` fires
+6. `ad.close()` triggers `/complete`
+7. after backend confirmation, `onUserEarnedReward` fires
+
+## Endpoint Contract
+
+The SDK expects this response from `GET {base}/v1/ad`:
+
+```json
+{
+  "id": 2,
+  "title": "ad-Kotak Bank2",
+  "app_name": "SBI Bank",
+  "logo_url": "https://.../kotak.png",
+  "background_video_url": "https://.../kotak.ts",
+  "background_image_url": "https://.../kotak.png",
+  "button_text": "Register Now",
+  "click_url": "https://play.google.com/store/apps/details?id=...",
+  "min_watch_seconds": 5
+}
+```
+
+The SDK also keeps the existing reward verification calls:
+
+```text
+POST {base}/v1/ads/{adId}/impression
+POST {base}/v1/ads/{adId}/complete
+```
+
+## Live Backend
+
+The Android repository defaults to:
+
+```text
+https://myownadsprodapi.hiqmobi.in/api
+```
+
+If you want a local fallback, change `USE_STUB` in
+[android/src/main/java/com/ownad/adsdk/AdRepository.kt](android/src/main/java/com/ownad/adsdk/AdRepository.kt).
+
+## API Surface
+
+- `initialize(appId, config?)`
+- `RewardedAd.createForAdRequest(adUnitId)`
+- `ad.load()`
+- `ad.show()`
+- `ad.close()`
+- `ad.addListener({...})`
+- `ad.destroy()`
+
+## Notes
+
+- The ad remains non-skippable for the reward flow.
+- The bottom install card uses the response fields directly.
+- `min_watch_seconds` is passed through to native so you can extend the close
+  policy later if needed.

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Fri Aug 28 17:37:40 IST 2026
+gradle.version=9.2.0

package/android/build.gradle

@@ -0,0 +1,58 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    compileSdkVersion 37
+    
+    defaultConfig {
+        minSdkVersion 24
+        targetSdkVersion 36
+        versionCode 1
+        versionName "1.0.0"
+        
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    
+    buildFeatures {
+        buildConfig true
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+        debug {
+            minifyEnabled false
+        }
+    }
+    
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+        freeCompilerArgs += [
+            '-opt-in=androidx.media3.common.util.UnstableApi'
+        ]
+    }
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-android:0.73.0'
+    implementation 'com.squareup.okhttp3:okhttp:4.11.0'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
+
+    // Full-screen video ad player
+    implementation 'androidx.activity:activity-ktx:1.8.2'
+    implementation 'androidx.media3:media3-exoplayer:1.2.1'
+    implementation 'androidx.media3:media3-ui:1.2.1'
+    
+    // Testing
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
+}

package/android/proguard-rules.pro

@@ -0,0 +1,20 @@
+# Keep the SDK classes public
+-keep class com.rozcash.sdk.** { *; }
+
+# Keep React Native
+-keep class com.facebook.react.** { *; }
+
+# Obfuscate internal implementations
+-renameclasses com.rozcash.sdk.**
+
+# Remove logging in release builds
+-assumenosideeffects class android.util.Log {
+    public static *** d(...);
+    public static *** v(...);
+    public static *** i(...);
+}
+
+# Keep native methods
+-keepclasseswithmembernames class * {
+    native <methods>;
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.ownad.adsdk">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+
+    <application>
+        <activity
+            android:name="com.ownad.adsdk.VideoAdActivity"
+            android:configChanges="orientation|screenSize|keyboardHidden|smallestScreenSize|screenLayout|uiMode"
+            android:exported="false"
+            android:hardwareAccelerated="true"
+            android:screenOrientation="portrait"
+            android:theme="@android:style/Theme.Black.NoTitleBar.Fullscreen" />
+    </application>
+
+</manifest>

package/android/src/main/java/com/ownad/adsdk/AdRepository.kt

@@ -0,0 +1,201 @@
+package com.ownad.adsdk
+
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.json.JSONObject
+import java.util.concurrent.TimeUnit
+
+/** Ad preview returned by GET /v1/ad. Used only to show the user something is coming. */
+data class AdPreview(
+    val id: String,
+    val title: String,
+    val appName: String,
+    val logoUrl: String?,
+    val backgroundVideoUrl: String,
+    val backgroundImageUrl: String?,
+    val buttonText: String,
+    val clickUrl: String?,
+    val minWatchSeconds: Int,
+)
+
+/** Authoritative ad + transaction, returned by POST /transactions/. This is what actually plays. */
+data class AdTransaction(
+    val txId: String,
+    val nonce: String,
+    val expiresAt: String?,
+    val serverSignature: String?,
+    val ad: AdPreview,
+)
+
+/**
+ * Talks to the OwnAd ad server. All calls are blocking and MUST be run off the main thread.
+ *
+ * Endpoints:
+ *   GET  {base}/v1/ad/                                     -> ad preview, or { status: "no_fill" }
+ *   POST {base}/v1/transactions/            (X-App-Id/X-App-Secret)
+ *        body: { user_id, purpose? }
+ *        -> { tx_id, nonce, expires_at, server_signature, ad } or { status: "no_fill" }
+ *   POST {base}/v1/ads/{tx_id}/impression/                 -> { ok: true }
+ *   POST {base}/v1/ads/{tx_id}/progress/    body: { watch_ms }   -> { ok: true }
+ *   POST {base}/v1/ads/{tx_id}/click/                      -> { click_url }
+ *   POST {base}/v1/transactions/{tx_id}/complete/  (X-App-Id/X-App-Secret)
+ *        body: { nonce }  -> { status: "verified" | "rejected" }
+ */
+internal class AdRepository(
+    baseUrlOverride: String? = null,
+) {
+    companion object {
+        private const val AD_BASE_URL = "https://myownadsprodapi.hiqmobi.in/api"
+        private val JSON = "application/json; charset=utf-8".toMediaType()
+    }
+
+    private val baseUrl = (baseUrlOverride ?: AD_BASE_URL).trimEnd('/')
+
+    private val http = OkHttpClient.Builder()
+        .connectTimeout(10, TimeUnit.SECONDS)
+        .readTimeout(15, TimeUnit.SECONDS)
+        .writeTimeout(10, TimeUnit.SECONDS)
+        .build()
+
+    /** GET /v1/ad/ — ad preview (details only). @return null on "no_fill". */
+    fun fetchAdPreview(): AdPreview? {
+        val url = baseUrl.toHttpUrl().newBuilder()
+            .addEncodedPathSegments("v1/ad/")
+            .build()
+
+        val request = Request.Builder()
+            .url(url)
+            .get()
+            .addHeader("Accept", "application/json")
+            .addHeader("User-Agent", "OwnAdSDK/1.0")
+            .build()
+
+        val json = execute(request)
+        if (json.optString("status") == "no_fill") return null
+        return json.toPreview()
+    }
+
+    /**
+     * POST /v1/transactions/ — reserves an ad for this user.
+     * @return null on "no_fill".
+     */
+    fun startTransaction(
+        appId: String,
+        appSecret: String,
+        userId: String,
+        purpose: String?,
+    ): AdTransaction? {
+        val body = JSONObject().put("user_id", userId)
+        if (!purpose.isNullOrBlank()) body.put("purpose", purpose)
+
+        val request = Request.Builder()
+            .url(baseUrl + "/v1/transactions/")
+            .post(body.toString().toRequestBody(JSON))
+            .addHeader("Accept", "application/json")
+            .addHeader("User-Agent", "OwnAdSDK/1.0")
+            .addHeader("X-App-Id", appId)
+            .addHeader("X-App-Secret", appSecret)
+            .build()
+
+        val json = execute(request)
+        if (json.optString("status") == "no_fill") return null
+        return json.toTransaction()
+    }
+
+    /** POST /v1/ads/{tx_id}/impression/ — fire-and-forget, always 200. */
+    fun trackImpression(txId: String) {
+        runCatching { execute(postRequest("/v1/ads/$txId/impression/", JSONObject())) }
+    }
+
+    /** POST /v1/ads/{tx_id}/progress/ — server keeps the max watch_ms ever reported. */
+    fun trackProgress(txId: String, watchMs: Long) {
+        runCatching {
+            execute(postRequest("/v1/ads/$txId/progress/", JSONObject().put("watch_ms", watchMs)))
+        }
+    }
+
+    /** POST /v1/ads/{tx_id}/click/ — @return click_url from the server, or null if tx unknown. */
+    fun trackClick(txId: String): String? {
+        val json = execute(postRequest("/v1/ads/$txId/click/", JSONObject()))
+        return json.nullableString("click_url")
+    }
+
+    /**
+     * POST /v1/transactions/{tx_id}/complete/ — verifies the nonce and grants the
+     * server-side reward (SSV). @return true only when status == "verified".
+     */
+    fun completeTransaction(appId: String, appSecret: String, txId: String, nonce: String): Boolean {
+        val request = Request.Builder()
+            .url(baseUrl + "/v1/transactions/$txId/complete/")
+            .post(JSONObject().put("nonce", nonce).toString().toRequestBody(JSON))
+            .addHeader("Accept", "application/json")
+            .addHeader("User-Agent", "OwnAdSDK/1.0")
+            .addHeader("X-App-Id", appId)
+            .addHeader("X-App-Secret", appSecret)
+            .build()
+
+        val json = execute(request)
+        return json.optString("status") == "verified"
+    }
+
+    // ---- internals --------------------------------------------------------
+
+    private fun postRequest(path: String, body: JSONObject): Request =
+        Request.Builder()
+            .url(baseUrl + path)
+            .post(body.toString().toRequestBody(JSON))
+            .addHeader("Accept", "application/json")
+            .addHeader("User-Agent", "OwnAdSDK/1.0")
+            .build()
+
+    private fun execute(request: Request): JSONObject {
+        http.newCall(request).execute().use { response ->
+            val text = response.body?.string().orEmpty()
+            if (!response.isSuccessful) {
+                throw AdException("HTTP_${response.code}", "Ad server error ${response.code}: $text")
+            }
+            return if (text.isBlank()) JSONObject() else JSONObject(text)
+        }
+    }
+
+    private fun JSONObject.toPreview(): AdPreview {
+        return AdPreview(
+            id = stringOr("id", ""),
+            title = stringOr("title", ""),
+            appName = stringOr("app_name", ""),
+            logoUrl = nullableString("logo_url"),
+            backgroundVideoUrl = stringOr("background_video_url", ""),
+            backgroundImageUrl = nullableString("background_image_url"),
+            buttonText = stringOr("button_text", "Install"),
+            clickUrl = nullableString("click_url"),
+            minWatchSeconds = optInt("min_watch_seconds", 0),
+        )
+    }
+
+    private fun JSONObject.toTransaction(): AdTransaction {
+        val adJson = optJSONObject("ad") ?: JSONObject()
+        return AdTransaction(
+            txId = stringOr("tx_id", ""),
+            nonce = stringOr("nonce", ""),
+            expiresAt = nullableString("expires_at"),
+            serverSignature = nullableString("server_signature"),
+            ad = adJson.toPreview(),
+        )
+    }
+
+    private fun JSONObject.stringOr(key: String, fallback: String): String {
+        val value = optString(key)
+        return if (value.isNullOrBlank() || value == "null") fallback else value
+    }
+
+    private fun JSONObject.nullableString(key: String): String? {
+        if (!has(key) || isNull(key)) return null
+        val value = optString(key)
+        return value.takeUnless { it.isBlank() || it == "null" }
+    }
+}
+
+internal class AdException(val code: String, message: String) : Exception(message)