Lync Attribution SDK for Flutter

Cross-platform attribution tracking for Flutter apps. Track user interactions, app installs, and conversions across mobile platforms with seamless integration.

pub package Platform

Features

✅ Cross-platform attribution - Works on iOS and Android
✅ Device fingerprinting - Consistent user identification across platforms
✅ Real-time tracking - Instant event tracking and attribution
✅ Custom events - Track any custom user interactions
✅ Privacy-focused - GDPR and privacy regulation compliant
✅ Easy integration - Simple API with comprehensive documentation

Installation

Add this to your package's pubspec.yaml file:

dependencies:
  lync: ^1.0.0

Then run:

flutter pub get

Quick Start

1. Initialize Lync

import 'package:lync/lync.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  
  // Initialize with your configuration
  await LyncClient.initialize(
    LyncConfig.production(
      apiKey: 'your-api-key-here',
      globalProperties: {
        'app_version': '1.0.0',
        'environment': 'production',
      },
    ),
  );
  
  runApp(MyApp());
}

2. Track Events

// Track a click event
final attribution = await LyncClient.instance.trackClick(
  linkId: 'campaign-link-123',
  customData: {'source': 'email', 'campaign': 'summer2024'},
);

// Track app install
await LyncClient.instance.trackInstall(
  referrer: 'https://example.com/campaign',
);

// Track conversion
await LyncClient.instance.trackConversion(
  conversionType: 'purchase',
  value: 29.99,
  currency: 'USD',
);

// Track custom events
await LyncClient.instance.trackEvent(
  eventType: 'feature_used',
  eventData: {'feature_name': 'premium_feature'},
);

API Reference

LyncClient

The main client for tracking attribution events.

Initialize

static Future<LyncClient> initialize(LyncConfig config)

Initialize the Lync client with configuration.

Track Methods

// Track click events
Future<LyncAttribution?> trackClick({
  required String linkId,
  Map<String, dynamic>? customData,
})

// Track app installs
Future<LyncAttribution?> trackInstall({
  String? referrer,
  Map<String, dynamic>? customData,
})

// Track conversions
Future<LyncAttribution?> trackConversion({
  required String conversionType,
  required double value,
  String? currency,
  Map<String, dynamic>? customData,
})

// Track custom events
Future<LyncAttribution?> trackEvent({
  required String eventType,
  Map<String, dynamic>? eventData,
  Map<String, dynamic>? customData,
})

Properties

String? get userId           // Current user ID
String? get sessionId        // Current session ID
String? get deviceFingerprint // Device fingerprint for attribution

LyncConfig

Configuration for the Lync client.

Factory Constructors

// Development configuration
LyncConfig.development({
  String? apiKey,
  String apiBaseUrl = 'https://api.lync.so',
  Map<String, dynamic>? globalProperties,
})

// Production configuration
LyncConfig.production({
  required String apiKey,
  String apiBaseUrl = 'https://api.lync.so',
  Map<String, dynamic>? globalProperties,
})

LyncAttribution

Attribution result returned from tracking events.

class LyncAttribution {
  final bool attributed;              // Whether attribution was successful
  final DateTime? clickTime;          // Original click timestamp
  final DateTime? installTime;        // Install timestamp
  final DateTime? conversionTime;     // Conversion timestamp
  final String? source;               // Attribution source
  final String? campaign;             // Campaign name
  final String? medium;               // Traffic medium
  final String? linkId;               // Original link ID
  final double? confidence;           // Attribution confidence (0.0-1.0)
  final String? attributionModel;     // Model used for attribution
}

Examples

Basic Integration

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

class _MyAppState extends State<MyApp> {
  @override
  void initState() {
    super.initState();
    _initializeLync();
  }

  Future<void> _initializeLync() async {
    await LyncClient.initialize(
      LyncConfig.production(apiKey: 'your-api-key'),
    );
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        body: ElevatedButton(
          onPressed: () async {
            await LyncClient.instance.trackClick(
              linkId: 'button-click',
              customData: {'button': 'cta'},
            );
          },
          child: Text('Track Click'),
        ),
      ),
    );
  }
}

E-commerce Integration

class ProductPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: () async {
        // Track purchase conversion
        final attribution = await LyncClient.instance.trackConversion(
          conversionType: 'purchase',
          value: 49.99,
          currency: 'USD',
          customData: {
            'product_id': 'premium-plan',
            'category': 'subscription',
            'payment_method': 'credit_card',
          },
        );

        if (attribution?.attributed == true) {
          print('Purchase attributed to: ${attribution!.source}');
        }
      },
      child: Text('Buy Now'),
    );
  }
}

Session Management

class AppLifecycleHandler extends WidgetsBindingObserver {
  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    if (state == AppLifecycleState.resumed) {
      // Start new session when app becomes active
      LyncClient.instance.startNewSession();
    }
  }
}

Configuration Options

Environment Setup

// Development
final config = LyncConfig.development(
  apiKey: 'dev-key',
  globalProperties: {'debug': true},
);

// Production
final config = LyncConfig.production(
  apiKey: 'prod-key',
  globalProperties: {'version': '1.0.0'},
);

// Custom
final config = LyncConfig(
  apiBaseUrl: 'https://custom-api.example.com',
  apiKey: 'custom-key',
  debug: false,
  timeoutSeconds: 30,
  maxRetryAttempts: 3,
);

Global Properties

Set properties that will be included with every event:

final config = LyncConfig.production(
  apiKey: 'your-key',
  globalProperties: {
    'app_version': '1.2.3',
    'build_number': '456',
    'environment': 'production',
    'user_segment': 'premium',
  },
);

Platform-Specific Features

iOS Integration

  • Apple Search Ads Attribution: Automatic attribution from Apple Search Ads
  • SKAdNetwork Support: Compatible with Apple's privacy-focused attribution
  • Universal Links: Deep link attribution tracking

Android Integration

  • Google Play Install Referrer: Automatic referrer tracking
  • App Links: Deep link attribution tracking
  • Google Play Instant: Attribution for instant app experiences

Privacy & Compliance

  • GDPR Compliant: No PII collection without consent
  • CCPA Compliant: Respects California privacy regulations
  • Configurable Data Collection: Control what data is collected
  • Local Storage: User preferences stored locally

Testing

Run the test suite:

flutter test

Contributing

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Support

Libraries

lync
Cross-platform attribution tracking SDK for Flutter