Flutter SDK

flutter pub add linkrunner

android {
    defaultConfig {
        minSdkVersion 21
        // other config...
    }
}

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

    <!-- Remove AD_ID permission that comes from the SDK -->
    <uses-permission
        android:name="com.google.android.gms.permission.AD_ID"
        tools:node="remove" />

    <!-- Your other permissions -->
</manifest>

platform :ios, '15.0'

<key>NSUserTrackingUsageDescription</key>
<string>This identifier will be used to deliver personalized ads and improve your app experience.</string>

import 'package:linkrunner/linkrunner.dart';

Future<void> initLinkrunner() async {
  try {
    // Initialize with your project token
    await LinkRunner().init(
      'YOUR_PROJECT_TOKEN',
      'YOUR_SECRET_KEY', // Optional: Required for SDK signing
      'YOUR_KEY_ID', // Optional: Required for SDK signing
      false, // Optional: Set to true to disable IDFA collection for iOS devices (defaults to false)
      true // Optional: Enable debug mode for development (defaults to false)
    );
    print('LinkRunner initialized');
  } catch (e) {
    print('Error initializing LinkRunner: $e');
  }
}

// Call this in your app's initialization
@override
void initState() {
  WidgetsFlutterBinding.ensureInitialized(); // Make sure this is added!
  super.initState();
  initLinkrunner();
}

import 'dart:io' show Platform;
import 'package:linkrunner/linkrunner.dart';

Future<void> initLinkrunnerWithSigning() async {
  try {
    // Initialize with your project token and SDK signing parameters
    await LinkRunner().init(
      'YOUR_PROJECT_TOKEN',
      Platform.isIOS ? 'YOUR_IOS_SECRET_KEY' : 'YOUR_ANDROID_SECRET_KEY', // Platform-specific secret key
      Platform.isIOS ? 'YOUR_IOS_KEY_ID' : 'YOUR_ANDROID_KEY_ID', // Platform-specific key ID
      true, // Optional: Enable debug mode for development (defaults to false)
    );
    print('LinkRunner initialized with SDK signing');
  } catch (e) {
    print('Error initializing LinkRunner: $e');
  }
}

try {
  await LinkRunner().setCustomerUserId("f47ac10b-58cc-4372-a567-0e02b2c3d479"); // Your unique customer user ID (e.g. a UUID)
  print('Customer user id set');
} catch (e) {
  print('Error setting customer user id: $e');
}

Future<void> onSignup() async {
  try {
    await LinkRunner().signup(
      userData: LRUserData(
        id: '123', // Required: User ID
        name: 'John Doe', // Optional
        phone: '9876543210', // Optional
        email: 'user@example.com', // Optional
        // These properties are used to track reinstalls
        userCreatedAt: '2024-01-01T00:00:00Z', // Optional
        isFirstTimeUser: true, // Optional
        mixpanelDistinctId: 'mixpanelDistinctId', // Optional - Mixpanel Distinct ID
        amplitudeDeviceId: 'amplitudeDeviceId', // Optional - Amplitude User ID
        posthogDistinctId: 'posthogDistinctId', // Optional - PostHog Distinct ID
      ),
      data: {}, // Optional: Any additional data
    );
    print('Signup successful');
  } catch (e) {
    print('Error during signup: $e');
  }
}

import 'package:flutter/material.dart';
import 'package:app_links/app_links.dart';
import 'package:linkrunner/linkrunner.dart';

class MyApp extends StatefulWidget {
  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {
  final _appLinks = AppLinks();

  @override
  void initState() {
    super.initState();
    _initLinkRunner();
  }

  Future<void> _initLinkRunner() async {
    // Init SDK first
    await LinkRunner().init('your_project_token');

    // Cold start — app was launched by a deeplink
    final initialLink = await _appLinks.getInitialLink();
    if (initialLink != null) {
      LinkRunner().handleDeeplink(initialLink.toString());
    }

    // Warm start — app was in background, deeplink brought it to foreground
    _appLinks.uriLinkStream.listen((Uri uri) {
      LinkRunner().handleDeeplink(uri.toString());
    });
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      // your app content
    );
  }
}

{
    "deeplink": "https://app.yourdomain.com/product/123"
}

Future<void> getAttributionInfo() async {
  try {
    final attributionData = await LinkRunner().getAttributionData();
    print('Attribution data: $attributionData');
  } catch (e) {
    print('Error getting attribution data: $e');
  }
}

class AttributionData {
  final String? deeplink;            // Optional: The deep link URL that led to app installation
  final CampaignData campaignData;   // Required: Campaign information
}

class CampaignData {
  final String id;                   // Required: Campaign ID
  final String name;                 // Required: Campaign name
  final String? adNetwork;           // Optional: "META" | "GOOGLE" | null
  final String? groupName;           // Optional: Campaign group name
  final String? assetGroupName;      // Optional: Asset group name
  final String? adNetworkCampaignId; // Optional: Ad network campaign ID
  final String? adSetId;             // Optional: Ad set ID
  final String? adSetName;           // Optional: Ad set name
  final String? adCreativeId;        // Optional: Ad creative ID
  final String? adCreativeName;      // Optional: Ad creative name
  final String? assetName;           // Optional: Asset name
  final String type;                 // Required: Campaign type ("ORGANIC" | "INORGANIC")
  final String installedAt;          // Required: Installation timestamp
  final String storeClickAt;         // Required: Store click timestamp
}

// getAttributionData() returns a typed AttributionData object — access fields in camelCase.
{
  "deeplink": "https://app.yourdomain.com/product/123",
  "campaignData": {
    "id": "camp_123",
    "name": "Summer Sale 2024",
    "adNetwork": "META",
    "groupName": "iOS Campaign",
    "assetGroupName": "Product Catalog",
    "assetName": "Banner Ad 1",
    "adNetworkCampaignId": "120214682829390250",
    "adSetId": "120214682829640250",
    "adSetName": "Productivity",
    "adCreativeId": "120214682926100250",
    "adCreativeName": "Static_2",
    "type": "INORGANIC",
    "installedAt": "2024-03-20T10:30:00Z",
    "storeClickAt": "2024-03-20T10:29:45Z"
  }
}

Future<void> setUserData() async {
  try {
    await LinkRunner().setUserData(
      userData: LRUserData(
        id: '123', // Required: User ID
        name: 'John Doe', // Optional
        phone: '9876543210', // Optional
        email: 'user@example.com', // Optional
        mixpanelDistinctId: 'mixpanelDistinctId', // Optional - Mixpanel Distinct ID
        amplitudeDeviceId: 'amplitudeDeviceId', // Optional - Amplitude User ID
        posthogDistinctId: 'posthogDistinctId', // Optional - PostHog Distinct ID
      ),
    );
    print('User data set successfully');
  } catch (e) {
    print('Error setting user data: $e');
  }
}

Future<void> setIntegrationData() async {
  try {
    await LinkRunner().setAdditionalData(
      integrationData: {
        'clevertap_id': 'YOUR_CLEVERTAP_USER_ID', // CleverTap user identifier
      },
    );
    print('CleverTap ID set successfully');
  } catch (e) {
    print('Error setting CleverTap ID: $e');
  }
}

Future<void> capturePayment() async {
  try {
    await LinkRunner().capturePayment(
      capturePayment: LRCapturePayment(
        amount: 99.99, // Required: Payment amount
        userId: 'user123', // Required: User identifier
        paymentId: 'payment456', // Required: Unique payment identifier
        type: PaymentType.FIRST_PAYMENT, // Optional: Payment type
        // type: PaymentType.SECOND_PAYMENT, // Optional: Payment type
        status: PaymentStatus.PAYMENT_COMPLETED, // Optional: Payment status
        eventData: { // Optional: Ecommerce/custom event data
          'content_ids': ['product_123'],
          'content_type': 'product',
          'currency': 'USD',
          'value': 99.99,
          'num_items': 1,
          'order_id': 'order_12345',
          'contents': [
            {
              'id': 'product_123',
              'quantity': 1,
              'item_price': 99.99
            }
          ]
        },
      ),
    );
    print('Payment captured successfully');
  } catch (e) {
    print('Error capturing payment: $e');
  }
}

Future<void> removePayment() async {
  try {
    await LinkRunner().removePayment(
      removePayment: LRRemovePayment(
        userId: 'user123', // Either userId or paymentId must be provided
        paymentId: 'payment456', // Optional: Unique payment identifier
      ),
    );
    print('Payment removed successfully');
  } catch (e) {
    print('Error removing payment: $e');
  }
}

Future<void> trackAddToCart() async {
  try {
    await LinkRunner().trackEvent(
      eventName: 'add_to_cart', // Map this custom event to "AddToCart" in the Linkrunner Dashboard
      eventData: {
        'content_ids': ['product_123'],
        'contents': [
          {
            'id': 'product_123', // Matches content_ids
            'quantity': 1,
            'item_price': 49.99
          }
        ],
        'content_type': 'product',
        'currency': 'USD',
        'value': 49.99,
        'num_items': 1
      },
    );
    print('Add To Cart event tracked successfully');
  } catch (e) {
    print('Error tracking Add To Cart event: $e');
  }
}

Future<void> trackViewContent() async {
  try {
    await LinkRunner().trackEvent(
      eventName: 'view_item', // Map this custom event to "ViewContent" in the Linkrunner Dashboard
      eventData: {
        'content_ids': ['product_123'],
        'contents': [
          {
            'id': 'product_123', // Matches content_ids
            'quantity': 1,
            'item_price': 49.99
          }
        ],
        'content_type': 'product',
        'currency': 'USD',
        'value': 49.99,
        'num_items': 1
      },
    );
    print('View Content event tracked successfully');
  } catch (e) {
    print('Error tracking View Content event: $e');
  }
}

Future<void> capturePurchase() async {
  try {
    await LinkRunner().capturePayment(
      capturePayment: LRCapturePayment(
        amount: 49.99,
        userId: 'user123',
        paymentId: 'payment_456',
        type: PaymentType.FIRST_PAYMENT, // Map this payment type to "Purchase" in the Linkrunner Dashboard
        status: PaymentStatus.PAYMENT_COMPLETED,
        eventData: {
          'content_ids': ['product_123'],
          'contents': [
            {
              'id': 'product_123', // Matches content_ids
              'quantity': 1,
              'item_price': 49.99
            }
          ],
          'content_type': 'product',
          'currency': 'USD',
          'value': 49.99,
          'num_items': 1,
          'order_id': 'order_abc123' // Required for Purchase events
        },
      ),
    );
    print('Purchase captured successfully');
  } catch (e) {
    print('Error capturing purchase: $e');
  }
}

Future<void> trackEvent() async {
  try {
    await LinkRunner().trackEvent(
      eventName: 'purchase_initiated', // Event name
      eventData: { // Optional: Event data
        'product_id': '12345',
        'category': 'electronics',
        'amount': 99.99, // Include amount as a number for revenue sharing with ad networks like Google and Meta
      },
      eventId: 'order_12345', // Optional: Your own unique event identifier (String or num)
    );
    print('Event tracked successfully');
  } catch (e) {
    print('Error tracking event: $e');
  }
}

Future<void> trackPurchaseEvent() async {
  try {
    await LinkRunner().trackEvent(
      eventName: 'purchase_completed',
      eventData: {
        'product_id': '12345',
        'category': 'electronics',
        'amount': 149.99, // Revenue amount as a number
      },
    );
    print('Purchase event with revenue tracked successfully');
  } catch (e) {
    print('Error tracking purchase event: $e');
  }
}

// Enable PII (Personally Identifiable Information) hashing
LinkRunner().enablePIIHashing(true);

// Disable AAID collection
LinkRunner().setDisableAaidCollection(true);

// Check if AAID collection is disabled
bool isDisabled = LinkRunner().isAaidCollectionDisabled();

import 'package:flutter/material.dart';
import 'package:linkrunner/linkrunner.dart';

final linkrunner = LinkRunner();

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Linkrunner Demo',
      home: HomeScreen(),
    );
  }
}

class HomeScreen extends StatefulWidget {
  @override
  _HomeScreenState createState() => _HomeScreenState();
}

class _HomeScreenState extends State<HomeScreen> {
  bool _initialized = false;

  @override
  void initState() {
    super.initState();
    _initializeLinkrunner();
  }

  Future<void> _initializeLinkrunner() async {
    try {
      await LinkRunner().init('YOUR_PROJECT_TOKEN');
      setState(() {
        _initialized = true;
      });
    } catch (e) {
      print('Error initializing LinkRunner: $e');
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Linkrunner Demo')),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('LinkRunner ${_initialized ? 'Initialized' : 'Initializing...'}'),
            SizedBox(height: 20),
            ElevatedButton(
              onPressed: () async {
                await LinkRunner().trackEvent(eventName: 'button_clicked');
              },
              child: Text('Track Custom Event'),
            ),
          ],
        ),
      ),
    );
  }
}