react-native-smartlinks 2.0.0

package/android/build.gradle

@@ -0,0 +1,33 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace 'live.smartlinks.reactnative'
+    compileSdk rootProject.ext.compileSdkVersion
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.minSdkVersion
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17'
+        freeCompilerArgs += ['-Xskip-metadata-version-check']
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-native:+'
+    implementation 'live.smartlinks:smartlinks-sdk-core:2.0.1'
+    // SmartLinks SDK is built with Kotlin 2.2 — required at runtime (SpillingKt, etc.)
+    implementation 'org.jetbrains.kotlin:kotlin-stdlib:2.2.20'
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="live.smartlinks.reactnative">
+</manifest>

package/android/src/main/java/live/smartlinks/reactnative/SmartLinksActivityLifecycle.kt

@@ -0,0 +1,34 @@
+package live.smartlinks.reactnative
+
+import android.app.Activity
+import android.app.Application
+import android.content.Intent
+import android.os.Bundle
+import com.facebook.react.bridge.ReactApplicationContext
+
+internal class SmartLinksActivityLifecycle(
+    private val reactContext: ReactApplicationContext,
+    private val module: SmartLinksModule,
+) : Application.ActivityLifecycleCallbacks {
+
+    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+    override fun onActivityStarted(activity: Activity) {}
+    override fun onActivityResumed(activity: Activity) {}
+    override fun onActivityPaused(activity: Activity) {}
+    override fun onActivityStopped(activity: Activity) {}
+    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+
+    override fun onActivityDestroyed(activity: Activity) {}
+
+    override fun onActivityPostCreated(activity: Activity, savedInstanceState: Bundle?) {
+        activity.intent?.let { module.onNewIntent(it) }
+    }
+}
+
+internal fun registerActivityLifecycle(
+    reactContext: ReactApplicationContext,
+    module: SmartLinksModule,
+) {
+    val app = reactContext.applicationContext as Application
+    app.registerActivityLifecycleCallbacks(SmartLinksActivityLifecycle(reactContext, module))
+}

package/android/src/main/java/live/smartlinks/reactnative/SmartLinksBridgeHandler.kt

@@ -0,0 +1,172 @@
+package live.smartlinks.reactnative
+
+import com.alkashier.smartlinks.bridge.SmartLinksBridgeApi
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+
+internal object SmartLinksBridgeHandler {
+
+    fun fetchApps(promise: Promise) {
+        SmartLinksBridgeApi.fetchApps { json ->
+            if (json != null) promise.resolve(json) else promise.reject("API_ERROR", "fetchApps failed")
+        }
+    }
+
+    fun submitFeedback(args: ReadableMap, promise: Promise) {
+        SmartLinksBridgeApi.submitFeedback(
+            content = args.getString("content") ?: "",
+            platform = args.getString("platform") ?: "android",
+            version = args.getString("version") ?: "1.0",
+            name = if (args.hasKey("name")) args.getString("name") else null,
+            email = if (args.hasKey("email")) args.getString("email") else null,
+            isPremium = if (args.hasKey("isPremium")) args.getBoolean("isPremium") else false,
+            attachmentPath = if (args.hasKey("attachmentPath")) args.getString("attachmentPath") else null,
+        ) { json ->
+            if (json != null) promise.resolve(json) else promise.reject("API_ERROR", "submitFeedback failed")
+        }
+    }
+
+    fun fetchAds(type: String?, promise: Promise) {
+        SmartLinksBridgeApi.fetchAds(type) { json ->
+            if (json != null) promise.resolve(json) else promise.reject("API_ERROR", "fetchAds failed")
+        }
+    }
+
+    fun trackAdImpression(adId: Int, promise: Promise) {
+        SmartLinksBridgeApi.trackAdImpression(adId) { json ->
+            promise.resolve(json ?: """{"success":false}""")
+        }
+    }
+
+    fun trackAdClick(adId: Int, promise: Promise) {
+        SmartLinksBridgeApi.trackAdClick(adId) { json ->
+            promise.resolve(json ?: """{"success":false}""")
+        }
+    }
+
+    fun processAi(instructionsJson: String, files: Map<String, String>, promise: Promise) {
+        SmartLinksBridgeApi.processAi(instructionsJson, files) { json ->
+            if (json != null) promise.resolve(json) else promise.reject("API_ERROR", "processAi failed")
+        }
+    }
+
+    fun validatePromoCode(code: String, promise: Promise) {
+        SmartLinksBridgeApi.validatePromoCode(code) { json -> promise.resolve(json) }
+    }
+
+    fun redeemPromoCode(code: String, promise: Promise) {
+        SmartLinksBridgeApi.redeemPromoCode(code) { json -> promise.resolve(json) }
+    }
+
+    fun verifyGooglePurchase(productId: String, token: String, promise: Promise) {
+        SmartLinksBridgeApi.verifyGooglePurchase(productId, token) { json -> promise.resolve(json) }
+    }
+
+    fun verifyApplePurchase(receiptData: String, promise: Promise) {
+        SmartLinksBridgeApi.verifyApplePurchase(receiptData) { json -> promise.resolve(json) }
+    }
+
+    fun getCommunities(promise: Promise) {
+        SmartLinksBridgeApi.getCommunities { json ->
+            if (json != null) promise.resolve(json) else promise.reject("API_ERROR", "getCommunities failed")
+        }
+    }
+
+    fun getPosts(communityId: Int, authToken: String?, promise: Promise) {
+        SmartLinksBridgeApi.getPosts(communityId, authToken) { json ->
+            if (json != null) promise.resolve(json) else promise.reject("API_ERROR", "getPosts failed")
+        }
+    }
+
+    fun socialAuthGoogle(accessToken: String, project: String?, promise: Promise) {
+        SmartLinksBridgeApi.socialAuthGoogle(accessToken, project) { json -> promise.resolve(json) }
+    }
+
+    fun getBlogs(page: Int, search: String?, promise: Promise) {
+        SmartLinksBridgeApi.getBlogs(page, search) { json -> promise.resolve(json) }
+    }
+
+    fun getBlogPost(slug: String, promise: Promise) {
+        SmartLinksBridgeApi.getBlogPost(slug) { json -> promise.resolve(json) }
+    }
+
+    fun getCommunity(promise: Promise) {
+        SmartLinksBridgeApi.getCommunity { json ->
+            if (json != null) promise.resolve(json) else promise.reject("API_ERROR", "getCommunity failed")
+        }
+    }
+
+    fun togglePostLike(postId: Int, authToken: String, promise: Promise) {
+        SmartLinksBridgeApi.togglePostLike(postId, authToken) { json -> promise.resolve(json) }
+    }
+
+    fun createPost(
+        communityId: String,
+        title: String,
+        content: String,
+        authToken: String,
+        promise: Promise,
+    ) {
+        SmartLinksBridgeApi.createPost(communityId, title, content, authToken) { json ->
+            promise.resolve(json)
+        }
+    }
+
+    fun socialAuthApple(accessToken: String, project: String?, promise: Promise) {
+        SmartLinksBridgeApi.socialAuthApple(accessToken, project) { json -> promise.resolve(json) }
+    }
+
+    fun getComments(postId: String, authToken: String?, promise: Promise) {
+        SmartLinksBridgeApi.getComments(postId, authToken) { json -> promise.resolve(json) }
+    }
+
+    fun createComment(
+        postId: String,
+        content: String,
+        authToken: String,
+        parentId: String?,
+        promise: Promise,
+    ) {
+        SmartLinksBridgeApi.createComment(postId, content, authToken, parentId) { json ->
+            promise.resolve(json)
+        }
+    }
+
+    fun toggleCommentLike(commentId: String, authToken: String, promise: Promise) {
+        SmartLinksBridgeApi.toggleCommentLike(commentId, authToken) { json -> promise.resolve(json) }
+    }
+
+    fun fetchActiveNotificationAd(
+        appId: Int?,
+        language: String?,
+        isDebug: Boolean,
+        promise: Promise,
+    ) {
+        SmartLinksBridgeApi.fetchActiveNotificationAd(appId, language, isDebug) { json ->
+            promise.resolve(json)
+        }
+    }
+
+    fun registerDevice(
+        fcmToken: String,
+        platform: String?,
+        deviceType: String?,
+        appVersion: String?,
+        language: String?,
+        promise: Promise,
+    ) {
+        SmartLinksBridgeApi.registerDevice(
+            fcmToken, platform, deviceType, appVersion, language,
+        ) { json ->
+            promise.resolve(json)
+        }
+    }
+
+    fun trackNotificationAdImpression(adId: Int, promise: Promise) {
+        SmartLinksBridgeApi.trackNotificationAdImpression(adId) { json -> promise.resolve(json) }
+    }
+
+    fun trackNotificationAdClick(adId: Int, promise: Promise) {
+        SmartLinksBridgeApi.trackNotificationAdClick(adId) { json -> promise.resolve(json) }
+    }
+}

package/android/src/main/java/live/smartlinks/reactnative/SmartLinksModule.kt

@@ -0,0 +1,299 @@
+package live.smartlinks.reactnative
+
+import android.app.Activity
+import android.content.Intent
+import android.util.Log
+import com.alkashier.smartlinks.SmartLinksIdentity
+import com.alkashier.smartlinks.SmartLinksSdk
+import com.alkashier.smartlinks.interfaces.OnFailureListener
+import com.alkashier.smartlinks.interfaces.OnSuccessListener
+import com.alkashier.smartlinks.models.PendingLinkData
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+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.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+class SmartLinksModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext),
+    LifecycleEventListener {
+
+    private var linkListenerRegistered = false
+    private var pendingIntent: Intent? = null
+
+    init {
+        reactContext.addLifecycleEventListener(this)
+        registerActivityLifecycle(reactContext, this)
+    }
+
+    override fun getName(): String = "SmartLinks"
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Required for NativeEventEmitter on Android
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Required for NativeEventEmitter on Android
+    }
+
+    @ReactMethod
+    fun initialize(apiKey: String, debugMode: Boolean, promise: Promise) {
+        try {
+            SmartLinksSdk.initialize(apiKey, reactContext.applicationContext, debugMode)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("INIT_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getAppUserId(promise: Promise) {
+        promise.resolve(SmartLinksIdentity.getAppUserId())
+    }
+
+    @ReactMethod
+    fun sendEvent(eventName: String, params: ReadableMap?, promise: Promise) {
+        try {
+            val map = params?.toHashMap()?.mapValues { it.value ?: "" } ?: emptyMap()
+            SmartLinksSdk.sendEvent(eventName, map, emptyMap(), reactContext.applicationContext)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("EVENT_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun generateLink(route: String, params: ReadableMap?, shortLink: Boolean, promise: Promise) {
+        val map = params?.toHashMap()?.mapValues { it.value ?: "" } ?: emptyMap()
+        SmartLinksSdk.generateDynamicLink(route, map, shortLink) { link ->
+            promise.resolve(link)
+        }
+    }
+
+    @ReactMethod
+    fun registerLinkListener(promise: Promise) {
+        linkListenerRegistered = true
+        val activity = currentActivity
+        if (activity != null) {
+            handleIntent(activity.intent)
+        } else {
+            pendingIntent?.let { handleIntent(it) }
+        }
+        promise.resolve(null)
+    }
+
+    @ReactMethod
+    fun fetchApps(promise: Promise) {
+        SmartLinksBridgeHandler.fetchApps(promise)
+    }
+
+    @ReactMethod
+    fun submitFeedback(args: ReadableMap, promise: Promise) {
+        SmartLinksBridgeHandler.submitFeedback(args, promise)
+    }
+
+    @ReactMethod
+    fun fetchAds(type: String?, promise: Promise) {
+        SmartLinksBridgeHandler.fetchAds(type, promise)
+    }
+
+    @ReactMethod
+    fun trackAdImpression(adId: Int, promise: Promise) {
+        SmartLinksBridgeHandler.trackAdImpression(adId, promise)
+    }
+
+    @ReactMethod
+    fun trackAdClick(adId: Int, promise: Promise) {
+        SmartLinksBridgeHandler.trackAdClick(adId, promise)
+    }
+
+    @ReactMethod
+    fun processAi(instructionsJson: String, files: ReadableMap?, promise: Promise) {
+        val fileMap = files?.toHashMap()?.mapNotNull { (key, value) ->
+            value?.toString()?.let { key to it }
+        }?.toMap() ?: emptyMap()
+        SmartLinksBridgeHandler.processAi(instructionsJson, fileMap, promise)
+    }
+
+    @ReactMethod
+    fun validatePromoCode(code: String, promise: Promise) {
+        SmartLinksBridgeHandler.validatePromoCode(code, promise)
+    }
+
+    @ReactMethod
+    fun redeemPromoCode(code: String, promise: Promise) {
+        SmartLinksBridgeHandler.redeemPromoCode(code, promise)
+    }
+
+    @ReactMethod
+    fun verifyGooglePurchase(productId: String, token: String, promise: Promise) {
+        SmartLinksBridgeHandler.verifyGooglePurchase(productId, token, promise)
+    }
+
+    @ReactMethod
+    fun verifyApplePurchase(receiptData: String, promise: Promise) {
+        SmartLinksBridgeHandler.verifyApplePurchase(receiptData, promise)
+    }
+
+    @ReactMethod
+    fun getCommunities(promise: Promise) {
+        SmartLinksBridgeHandler.getCommunities(promise)
+    }
+
+    @ReactMethod
+    fun getPosts(communityId: Int, authToken: String?, promise: Promise) {
+        SmartLinksBridgeHandler.getPosts(communityId, authToken, promise)
+    }
+
+    @ReactMethod
+    fun socialAuthGoogle(accessToken: String, project: String?, promise: Promise) {
+        SmartLinksBridgeHandler.socialAuthGoogle(accessToken, project, promise)
+    }
+
+    @ReactMethod
+    fun getBlogs(page: Int, search: String?, promise: Promise) {
+        SmartLinksBridgeHandler.getBlogs(page, search, promise)
+    }
+
+    @ReactMethod
+    fun getBlogPost(slug: String, promise: Promise) {
+        SmartLinksBridgeHandler.getBlogPost(slug, promise)
+    }
+
+    @ReactMethod
+    fun getCommunity(promise: Promise) {
+        SmartLinksBridgeHandler.getCommunity(promise)
+    }
+
+    @ReactMethod
+    fun togglePostLike(postId: Int, authToken: String, promise: Promise) {
+        SmartLinksBridgeHandler.togglePostLike(postId, authToken, promise)
+    }
+
+    @ReactMethod
+    fun createPost(
+        communityId: String,
+        title: String,
+        content: String,
+        authToken: String,
+        promise: Promise,
+    ) {
+        SmartLinksBridgeHandler.createPost(communityId, title, content, authToken, promise)
+    }
+
+    @ReactMethod
+    fun socialAuthApple(accessToken: String, project: String?, promise: Promise) {
+        SmartLinksBridgeHandler.socialAuthApple(accessToken, project, promise)
+    }
+
+    @ReactMethod
+    fun getComments(postId: String, authToken: String?, promise: Promise) {
+        SmartLinksBridgeHandler.getComments(postId, authToken, promise)
+    }
+
+    @ReactMethod
+    fun createComment(
+        postId: String,
+        content: String,
+        authToken: String,
+        parentId: String?,
+        promise: Promise,
+    ) {
+        SmartLinksBridgeHandler.createComment(postId, content, authToken, parentId, promise)
+    }
+
+    @ReactMethod
+    fun toggleCommentLike(commentId: String, authToken: String, promise: Promise) {
+        SmartLinksBridgeHandler.toggleCommentLike(commentId, authToken, promise)
+    }
+
+    @ReactMethod
+    fun fetchActiveNotificationAd(
+        appId: Int?,
+        language: String?,
+        isDebug: Boolean,
+        promise: Promise,
+    ) {
+        SmartLinksBridgeHandler.fetchActiveNotificationAd(appId, language, isDebug, promise)
+    }
+
+    @ReactMethod
+    fun registerDevice(
+        fcmToken: String,
+        platform: String?,
+        deviceType: String?,
+        appVersion: String?,
+        language: String?,
+        promise: Promise,
+    ) {
+        SmartLinksBridgeHandler.registerDevice(
+            fcmToken, platform, deviceType, appVersion, language, promise,
+        )
+    }
+
+    @ReactMethod
+    fun trackNotificationAdImpression(adId: Int, promise: Promise) {
+        SmartLinksBridgeHandler.trackNotificationAdImpression(adId, promise)
+    }
+
+    @ReactMethod
+    fun trackNotificationAdClick(adId: Int, promise: Promise) {
+        SmartLinksBridgeHandler.trackNotificationAdClick(adId, promise)
+    }
+
+    override fun onHostResume() {
+        currentActivity?.intent?.let { handleIntent(it) }
+    }
+
+    override fun onHostPause() {}
+    override fun onHostDestroy() {}
+
+    fun onNewIntent(intent: Intent?) {
+        if (intent == null) return
+        if (!linkListenerRegistered) {
+            pendingIntent = intent
+            return
+        }
+        handleIntent(intent)
+    }
+
+    private fun handleIntent(intent: Intent?) {
+        SmartLinksSdk.getLink(intent)
+            .addOnSuccessListener(object : OnSuccessListener<PendingLinkData> {
+                override fun onSuccess(result: PendingLinkData?) {
+                    pendingIntent = null
+                    if (result != null) {
+                        emitDeepLink(result)
+                    }
+                }
+            })
+            .addOnFailureListener(object : OnFailureListener {
+                override fun onFailure(exception: Exception) {
+                    Log.e(TAG, "getLink failed", exception)
+                }
+            })
+    }
+
+    private fun emitDeepLink(result: PendingLinkData) {
+        val map: WritableMap = Arguments.createMap()
+        map.putString("route", result.path?.toString() ?: "")
+        map.putString("link", result.link?.toString() ?: "")
+        map.putString("appSlug", result.appSlug ?: "")
+        val params = Arguments.createMap()
+        result.parameters?.forEach { (key, value) -> params.putString(key, value) }
+        map.putMap("params", params)
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("SmartLinksDeepLink", map)
+    }
+
+    companion object {
+        private const val TAG = "SmartLinksRN"
+    }
+}

package/android/src/main/java/live/smartlinks/reactnative/SmartLinksPackage.kt

@@ -0,0 +1,16 @@
+package live.smartlinks.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class SmartLinksPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(SmartLinksModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/ios/Linklytics/DeviceInfo.swift

@@ -0,0 +1,114 @@
+import UIKit
+import Foundation
+import CryptoKit
+import CommonCrypto
+
+struct DeviceInfo {
+    let platform: String
+    let osVersion: String
+    let deviceModel: String
+    let manufacturer: String
+    let brand: String
+    let appVersion: String
+    let appBundleId: String
+    let language: String
+    let timezone: String
+    let screenResolution: String
+    let networkType: String
+    let sdkVersion: String
+    let apiVersion: String
+
+    static func fromCurrentDevice(sdkVersion: String, apiVersion: String, networkType: String = "unknown") -> DeviceInfo {
+        let mainBundle = Bundle.main
+        let screen = UIScreen.main
+        let resolution = "\(Int(screen.nativeBounds.width))x\(Int(screen.nativeBounds.height))"
+
+        return DeviceInfo(
+            platform: "ios",
+            osVersion: UIDevice.current.systemVersion,
+            deviceModel: UIDevice.current.model,
+            manufacturer: "Apple",
+            brand: UIDevice.current.model,
+            appVersion: mainBundle.infoDictionary?["CFBundleShortVersionString"] as? String ?? "unknown",
+            appBundleId: mainBundle.bundleIdentifier ?? "unknown",
+            language: Locale.current.languageCode ?? "en",
+            timezone: TimeZone.current.identifier,
+            screenResolution: resolution,
+            networkType: networkType,
+            sdkVersion: sdkVersion,
+            apiVersion: apiVersion
+        )
+    }
+
+    func toMap() -> [String: String] {
+        return [
+            "platform": platform,
+            "os_version": osVersion,
+            "device_model": deviceModel,
+            "manufacturer": manufacturer,
+            "brand": brand,
+            "app_version": appVersion,
+            "app_bundle_id": appBundleId,
+            "language": language,
+            "timezone": timezone,
+            "screen_resolution": screenResolution,
+            "network_type": networkType,
+            "sdk_version": sdkVersion,
+            "api_version": apiVersion
+        ]
+    }
+
+    
+    private func fetchPublicIP(completion: @escaping (String?) -> Void) {
+        guard let url = URL(string: "https://api.ipify.org?format=text") else {
+            completion(nil)
+            return
+        }
+        
+        let task = URLSession.shared.dataTask(with: url) { data, _, _ in
+            let ip = data.flatMap { String(data: $0, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) }
+            completion(ip)
+        }
+        task.resume()
+    }
+    
+    
+    func generateFingerprint(completion: @escaping (String?) -> Void) {
+        
+        fetchPublicIP { ipAddress in
+            guard let ip = ipAddress else {
+                completion(nil)
+                return
+            }
+            
+            // Safely get bundle identifier (fallback if nil)
+            let appBundleId = Bundle.main.bundleIdentifier ?? "unknown.bundle"
+            
+            
+            // Simplified fingerprinting to match Server Side logic consistently.
+            // Format: IP | BundleID | Platform (normalized to 'ios')
+            let platform = "ios"
+            let fingerprintString = "\(ip)|\(appBundleId)|\(platform)"
+            
+            // Debug logging of fingerprint components
+            print("Linklytics: Fingerprint components:")
+            print("  - Combined string: \(fingerprintString)")
+            
+            // Convert string to Data
+            let data = Data(fingerprintString.utf8)
+            
+            // Allocate buffer for SHA256 digest
+            var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+            data.withUnsafeBytes {
+                _ = CC_SHA256($0.baseAddress, CC_LONG(data.count), &hash)
+            }
+            
+            // Convert hash to hex string
+            let hashString = hash.map { String(format: "%02x", $0) }.joined()
+            
+            // Return first 32 characters
+            completion(String(hashString.prefix(32)))
+        }
+    }
+
+}