rn-linkrunner 1.1.2 → 2.0.0

package/LinkrunnerSDK.podspec

@@ -0,0 +1,23 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name           = 'LinkrunnerSDK'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.authors        = { "Linkrunner" => "support@linkrunner.io" }
+  s.platforms      = { :ios => "15.0" }
+  s.swift_version  = '5.0'
+  s.source         = { :git => package['repository']['url'].gsub('git+', ''), :tag => "#{s.version}" }
+
+  s.source_files = "ios/*.{h,c,m,swift}"
+  s.requires_arc = true
+
+  s.dependency "React"
+  s.dependency 'LinkrunnerKit', '3.0.1'
+end

package/README.md

@@ -1,303 +1,16 @@
-# rn-linkrunner
+# Linkrunner React Native SDK
 
-React Native Package for [linkrunner.io](https://www.linkrunner.io)
+A native React Native SDK for integrating Linkrunner functionality into your React Native applications.
 
-## Table of Contents
+## Requirements
+- React Native 0.70.0 and above
+- iOS 15.0+ / Android 5.0 (API level 21) and above
 
-- [Installation](#installation)
-  - [Step 1: Prerequisites](#step-1-prerequisites)
-  - [Step 2: Installing rn-linkrunner](#step-2-installing-rn-linkrunner)
-- [Expo](#expo)
-- [Usage](#usage)
-  - [Initialisation](#initialisation)
-  - [Signup](#signup)
-  - [Set User Data](#set-user-data)
-  - [Trigger Deeplink](#trigger-deeplink-for-deferred-deep-linking)
-  - [Track Event](#track-event)
-  - [Process Google Analytics](#process-google-analytics)
-  - [Capture Payment](#capture-payment)
-  - [Remove Payment](#remove-payment)
-- [Support](#facing-issues-during-integration)
-- [License](#license)
-
-## Installation
-
-### Step 1: Prerequisites
-
-rn-linkrunner also uses `react-native-device-info`, `@react-native-community/netinfo`, `@react-native-async-storage/async-storage`, `react-native-play-install-referrer` and `@sparkfabrik/react-native-idfa-aaid`. You can install these packages with the following command:
-
-```sh
-npm install react-native-device-info @react-native-community/netinfo @react-native-async-storage/async-storage react-native-play-install-referrer @sparkfabrik/react-native-idfa-aaid
-```
-
-or
-
-```sh
-yarn add react-native-device-info @react-native-community/netinfo @react-native-async-storage/async-storage react-native-play-install-referrer @sparkfabrik/react-native-idfa-aaid
-```
-
-**IOS Configuration**:
-
-- Run `cd ios && pod install` to install pods for the package.
-- Add the below code in `info.plist`:
-  ```sh
-    <key>NSUserTrackingUsageDescription</key>
-    <string>This identifier will be used to deliver personalized ads and improve your app experience.</string>
-  ```
-
-### Step 2: Installing rn-linkrunner
-
-```sh
-npm install rn-linkrunner
-```
-
-or
-
-```sh
-yarn add rn-linkrunner
-```
-
-## Expo
-
-If you are using Expo, you will need to use development builds since this package relies on native libraries. Follow the [Expo Development Builds Documentation](https://docs.expo.dev/develop/development-builds/introduction/) to get started.
-
-## Usage
-
-### Initialisation
-
-You'll need your [project token](https://www.linkrunner.io/dashboard?m=documentation) to initialise the package. Place this initialization step in your `App.tsx` component, making sure the dependency array is empty for the `useEffect`:
-
-```js
-import linkrunner from 'rn-linkrunner';
-import analytics from '@react-native-firebase/analytics';
-import { Platform } from 'react-native';
-
-// Inside your react component
-useEffect(() => {
-  init();
-}, []);
-
-const init = async () => {
-  const initData = await linkrunner.init('PROJECT_TOKEN');
-
-  // Call processGoogleAnalytics right after init
-  if (Platform.OS === 'android') {
-    await linkrunner.processGoogleAnalytics(analytics);
-  }
-};
-```
-
-#### Response type for `linkrunner.init`
-
-```
-{
-  ip_location_data: {
-    ip: string;
-    city: string;
-    countryLong: string;
-    countryShort: string;
-    latitude: number;
-    longitude: number;
-    region: string;
-    timeZone: string;
-    zipCode: string;
-  };
-  deeplink: string;
-  root_domain: boolean;
-  campaign_data: {
-    id: string;
-    name: string;
-    type: "ORGANIC" | "INORGANIC";
-    ad_network: "META" | "GOOGLE" | null;
-    group_name: string | null;
-    asset_group_name: string | null;
-    asset_name: string | null;
-  };
-}
-```
-
-### Signup
-
-Call this function only once after the user has completed the onboarding process in your app. This should be triggered at the final step of your onboarding flow to register the user with Linkrunner.
-
-```jsx
-import linkrunner from 'rn-linkrunner';
-
-const onSignup = async () => {
-  const signup = await linkrunner.signup({
-    user_data: {
-      id: '1',
-      name: 'John Doe', // optional
-      phone: '9583849238', // optional
-      email: 'support@linkrunner.io', //optional
-    },
-    data: {}, // Any other data you might need
-  });
-};
-```
-
-#### Response type for `linkrunner.signup`
-
-```
-{
-  ip_location_data: {
-    ip: string;
-    city: string;
-    countryLong: string;
-    countryShort: string;
-    latitude: number;
-    longitude: number;
-    region: string;
-    timeZone: string;
-    zipCode: string;
-  };
-  deeplink: string;
-  root_domain: boolean;
-}
-```
-
-### Set User Data
-
-Call this function everytime the app is opened and the user is logged in.
-
-```jsx
-import linkrunner from 'rn-linkrunner';
-
-const setUserData = async () => {
-  await linkrunner.setUserData({
-    user_data: {
-      id: '1',
-      name: 'John Doe', // optional
-      phone: '9583849238', // optional
-      email: 'support@linkrunner.io', //optional
-    },
-  });
-};
-```
-
-### Trigger Deeplink (For Deferred Deep Linking)
-
-This function triggers the original deeplink that led to the app installation. Call it only after your main navigation is initialized and all deeplink-accessible screens are ready to receive navigation events.
-
-Note: For this to work properly make sure you have added verification objects on the [Linkrunner Dashboard](https://www.linkrunner.io/settings?sort_by=activity-1&s=store-verification).
-
-```jsx
-import linkrunner from 'rn-linkrunner';
-
-const onTriggerDeeplink = async () => {
-  await linkrunner.triggerDeeplink();
-};
-```
-
-### Track Event
-
-Use this method to track custom events
-
-```js
-const trackEvent = async () => {
-  await linkrunner.trackEvent(
-    'event_name', // Name of the event
-    { key: 'value' } // Optional: Additional JSON data for the event
-  );
-};
-```
-
-### Process Google Analytics
-
-Use this method to track GCLID from install referrer in Google Analytics. This is especially useful for tracking the effectiveness of Google Ads campaigns. For best results, call this method immediately after initializing linkrunner.
-
-```js
-import analytics from '@react-native-firebase/analytics';
-import linkrunner from 'rn-linkrunner';
-
-// Recommended implementation
-const init = async () => {
-  const initData = await linkrunner.init('PROJECT_TOKEN');
-
-  // Call processGoogleAnalytics right after init
-  linkrunner.processGoogleAnalytics(analytics);
-};
-```
-
-#### Prerequisites for `linkrunner.processGoogleAnalytics`
-
-You must have `@react-native-firebase/analytics` installed in your project and have properly configured Firebase in your app according to the [Firebase for React Native documentation](https://rnfirebase.io/analytics/usage).
-
-### Capture Payment
-
-Use this method to capture payment information:
-
-```js
-const capturePayment = async () => {
-  await linkrunner.capturePayment({
-    amount: 100, // Payment amount
-    userId: 'user123', // User identifier
-    paymentId: 'payment456', // Optional: Unique payment identifier
-    type: 'FIRST_PAYMENT', // Optional: Payment type
-    status: 'PAYMENT_COMPLETED', // Optional: Payment status
-  });
-};
-```
-
-#### Parameters for `linkrunner.capturePayment`
-
-- `amount`: number (required) - The payment amount
-- `userId`: string (required) - Identifier for the user making the payment
-- `paymentId`: string (optional) - Unique identifier for the payment
-- `type`: string (optional) - Type of payment. Available options:
-  - `FIRST_PAYMENT` - First payment made by the user
-  - `WALLET_TOPUP` - Adding funds to a wallet
-  - `FUNDS_WITHDRAWAL` - Withdrawing funds
-  - `SUBSCRIPTION_CREATED` - New subscription created
-  - `SUBSCRIPTION_RENEWED` - Subscription renewal
-  - `ONE_TIME` - One-time payment
-  - `RECURRING` - Recurring payment
-  - `DEFAULT` - Default type (used if not specified)
-- `status`: string (optional) - Status of the payment. Available options:
-  - `PAYMENT_INITIATED` - Payment has been initiated
-  - `PAYMENT_COMPLETED` - Payment completed successfully (default if not specified)
-  - `PAYMENT_FAILED` - Payment attempt failed
-  - `PAYMENT_CANCELLED` - Payment was cancelled
-
-### Remove Payment
-
-Use this method to remove a captured payment:
-
-```js
-const removePayment = async () => {
-  await linkrunner.removePayment({
-    userId: 'user123', // User identifier
-    paymentId: 'payment456', // Optional: Unique payment identifier
-  });
-};
-```
-
-#### Parameters for `linkrunner.removePayment`
-
-- `userId`: string (required) - Identifier for the user whose payment is being removed
-- `paymentId`: string (optional) - Unique identifier for the payment to be removed
-
-Note: Either `paymentId` or `userId` must be provided when calling `removePayment`. If `userId` is provided, all payments for that user will be removed.
-
-### Function Placement Guide
-
-Below is a simple guide on where to place each function in your application:
-
-| Function                                                                    | Where to Place                                                          | When to Call                                             |
-| --------------------------------------------------------------------------- | ----------------------------------------------------------------------- | -------------------------------------------------------- |
-| [`linkrunner.init`](#initialisation)                                        | In your `App.tsx` within a `useEffect` hook with empty dependency array | Once when the app starts                                 |
-| [`linkrunner.processGoogleAnalytics`](#process-google-analytics)            | Just below the `linkrunner.init` function call in your `App.tsx`        | Once after initializing linkrunner                       |
-| [`linkrunner.signup`](#signup)                                              | In your onboarding flow                                                 | Once after user completes the onboarding process         |
-| [`linkrunner.setUserData`](#set-user-data)                                  | In your authentication logic                                            | Every time the app is opened and the user is logged in   |
-| [`linkrunner.triggerDeeplink`](#trigger-deeplink-for-deferred-deep-linking) | After navigation initialization                                         | Once after your navigation is ready to handle deep links |
-| [`linkrunner.trackEvent`](#track-event)                                     | Throughout your app where events need to be tracked                     | When specific user actions or events occur               |
-| [`linkrunner.capturePayment`](#capture-payment)                             | In your payment processing flow                                         | When a user makes a payment                              |
-| [`linkrunner.removePayment`](#remove-payment)                               | In your payment cancellation/refund flow                                | When a payment needs to be removed                       |
-
-### Facing issues during integration?
-
-Mail us on darshil@linkrunner.io
+## Documentation
+For setup instructions, usage examples, and API reference, please visit:
+[Linkrunner React Native SDK Documentation](https://docs.linkrunner.io/sdk/react-native/installation)
 
 ## License
+This project is licensed under the MIT License - see the [LICENSE](./LICENSE) file for details.
 
-MIT
+Copyright (c) 2025 Linkrunner Private Limited 

package/android/build.gradle

@@ -0,0 +1,148 @@
+// based on:
+// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/build.gradle
+// * https://github.com/facebook/react-native/blob/0.60-stable/template/android/app/build.gradle
+
+def DEFAULT_COMPILE_SDK_VERSION = 34
+def DEFAULT_BUILD_TOOLS_VERSION = '34.0.0'
+def DEFAULT_MIN_SDK_VERSION = 24
+def DEFAULT_TARGET_SDK_VERSION = 34
+
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+buildscript {
+    ext {
+        buildToolsVersion = "34.0.0"
+        minSdkVersion = 24
+        compileSdkVersion = 34
+        targetSdkVersion = 34
+        kotlinVersion = "1.9.10"  // Stable version compatible with most RN apps
+    }
+
+    // The Android Gradle plugin is only required when opening the android folder stand-alone.
+    // This avoids unnecessary downloads and potential conflicts when the library is included as a
+    // module dependency in an application project.
+    if (project == rootProject) {
+        repositories {
+            google()
+            mavenCentral()
+        }
+
+        dependencies {
+            classpath 'com.android.tools.build:gradle:8.3.2'  // Stable LTS AGP version
+            classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+        }
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+def getExtOrDefault(name) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNative_' + name]
+}
+
+def getExtOrIntegerDefault(name) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties['ReactNative_' + name]).toInteger()
+}
+
+def supportsNamespace() {
+    def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+    def major = parsed[0].toInteger()
+    def minor = parsed[1].toInteger()
+
+    // Namespace support was added in 7.3.0
+    return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+    if (supportsNamespace()) {
+        namespace "io.linkrunner.rnlinkrunner"
+
+        sourceSets {
+            main {
+                manifest.srcFile "src/main/AndroidManifestNew.xml"
+            }
+        }
+    }
+
+    compileSdkVersion getExtOrIntegerDefault('compileSdkVersion')
+
+    defaultConfig {
+        minSdkVersion getExtOrIntegerDefault('minSdkVersion')
+        targetSdkVersion getExtOrIntegerDefault('targetSdkVersion')
+        versionCode 1
+        versionName "1.0"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    lintOptions {
+        disable 'GradleCompatible'
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_11  // Keep Java 11 for RN compatibility
+        targetCompatibility JavaVersion.VERSION_11
+    }
+
+    kotlinOptions {
+        jvmTarget = '11'  // Match Java version
+    }
+}
+
+repositories {
+    mavenLocal()
+    maven {
+        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
+        url "$rootDir/../node_modules/react-native/android"
+    }
+    maven {
+        // Android JSC is installed from npm
+        url "$rootDir/../node_modules/jsc-android/dist"
+    }
+    google()
+    mavenCentral()
+    jcenter()
+    maven { url 'https://www.jitpack.io' }
+}
+
+dependencies {
+    // React Native - use compileOnly to avoid version conflicts
+    implementation 'com.facebook.react:react-android:0.80.0'
+
+    // Linkrunner SDK 
+    implementation "io.linkrunner:android-sdk:2.1.3"
+
+    // Kotlin standard libraries - use stable versions
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
+
+    // AndroidX dependencies - matching Android SDK exactly
+    implementation 'androidx.core:core-ktx:1.12.0'
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.7.0'
+    implementation 'androidx.lifecycle:lifecycle-process:2.7.0'
+
+    // Network dependencies - matching Android SDK versions
+    implementation 'com.squareup.retrofit2:retrofit:2.11.0'
+    implementation 'com.squareup.retrofit2:converter-gson:2.11.0'
+    implementation 'com.squareup.okhttp3:logging-interceptor:4.12.0'
+
+    // Coroutines - matching Android SDK
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.0'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.8.0'
+
+    // Dependency Injection - matching Android SDK
+    implementation 'io.insert-koin:koin-android:3.5.3'
+
+    // Google Play Services - matching Android SDK exactly
+    implementation 'com.google.android.gms:play-services-ads-identifier:18.0.1'
+    implementation 'com.google.android.gms:play-services-appset:16.0.2'
+    implementation 'com.android.installreferrer:installreferrer:2.2'
+}

package/android/gradle.properties

@@ -0,0 +1,52 @@
+# Project-wide Gradle settings.
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app's APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
+android.useAndroidX=true
+# Automatically convert third-party libraries to use AndroidX
+android.enableJetifier=true
+
+# Gradle configuration settings to avoid deprecation warnings
+org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+org.gradle.parallel=true
+org.gradle.caching=true
+org.gradle.configureondemand=true
+
+# This setting enables the new non-transitive R class generation
+android.nonTransitiveRClass=true
+
+# Kotlin code style for this project: "official" or "obsolete":
+kotlin.code.style=official
+
+# Use this property to specify which architecture you want to build.
+# You can also override it from the CLI using
+# ./gradlew <task> -PreactNativeArchitectures=x86_64
+reactNativeArchitectures=armeabi-v7a,arm64-v8a,x86,x86_64
+
+# Use this property to enable support to the new architecture.
+# This will allow you to use TurboModules and the Fabric render in
+# your application. You should enable this flag either if you want
+# to write custom TurboModules/Fabric components OR use libraries that
+# are providing them.
+newArchEnabled=false
+
+# Use this property to enable or disable the Hermes JS engine.
+# If set to false, you will be using JSC instead.
+hermesEnabled=true
+
+# Enable the same timezone in daemon
+org.gradle.jvmargs=-Duser.timezone=UTC

package/android/settings.gradle

@@ -0,0 +1,6 @@
+rootProject.name = 'rn-linkrunner'
+
+apply from: file("../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); 
+applyNativeModulesSettingsGradle(settings)
+
+include ':app'

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="io.linkrunner.rnlinkrunner">
+</manifest>