App Tracking Transparency (ATT)

This guide provides comprehensive instructions for implementing Apple's App Tracking Transparency (ATT) framework with the Trackier Flutter SDK. ATT is required for iOS 14.5+ apps that want to access the Identifier for Advertisers (IDFA) for accurate attribution and tracking.

Overview

App Tracking Transparency (ATT) is Apple's privacy framework that requires apps to request user permission before accessing the IDFA. This is crucial for accurate attribution and tracking on iOS 14.5 and later.

Prerequisites

• iOS 14.5 or later
• Flutter 2.0 or later
• Trackier Flutter SDK installed
• Access to your app's Info.plist file

Implementation

Step 1: Add Permission Description

Add the following key-value pair to your Info.plist to describe why your app needs tracking permission:

ios/Runner/Info.plist

<key>NSUserTrackingUsageDescription</key>
<string>We use tracking to personalize your experience and improve our services.</string>

Step 2: Install ATT Package

Install the app_tracking_transparency package:

flutter pub add app_tracking_transparency

Step 3: Implement ATT in Your App

note

Important: Always include Trackierfluttersdk.waitForATTUserAuthorization(20) before initializing the SDK. This ensures the SDK waits for the user's ATT decision before starting tracking, which is required for accurate attribution on iOS 14.5+. You can adjust the timeout value (20 seconds) according to your use case or logic.

Update your main app file to integrate ATT with the Trackier SDK:

main.dart

import 'dart:io';
import 'package:flutter/material.dart';
import 'package:app_tracking_transparency/app_tracking_transparency.dart';
import 'package:trackier_flutter_sdk/trackier_flutter_sdk.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  runApp(MyApp());
}

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

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

  Future<void> _initializeApp() async {
    await _initializeTrackierSDK();
  }

  /// Request ATT permission (iOS only)
  Future<void> _requestATTPermission() async {
    if (!Platform.isIOS) {
      print('ATT is only required on iOS platform');
      return;
    }

    try {
      print('Requesting App Tracking Transparency permission...');
      
      // Check current status
      final TrackingStatus status = 
        await AppTrackingTransparency.trackingAuthorizationStatus;
      
      print('Current ATT status: $status');

      // Request permission if not determined
      if (status == TrackingStatus.notDetermined) {
        print('Requesting ATT permission from user...');
        final TrackingStatus result = 
          await AppTrackingTransparency.requestTrackingAuthorization();
        
        print('ATT permission result: $result');
        _handleATTPermissionResult(result);
      } else {
        print('ATT permission already determined: $status');
        _handleATTPermissionResult(status);
      }
    } catch (error) {
      print('Error requesting ATT permission: $error');
    }
  }

  /// Handle ATT permission result
  void _handleATTPermissionResult(TrackingStatus status) {
    switch (status) {
      case TrackingStatus.authorized:
        print('App Tracking Permission: Authorized');
        // The Trackier SDK will automatically fetch and send IDFA to the panel
        _getIDFA();
        break;
      case TrackingStatus.denied:
        print('App Tracking Permission: Denied');
        // The SDK will continue tracking without IDFA
        break;
      case TrackingStatus.restricted:
        print('App Tracking Permission: Restricted');
        // Tracking is restricted (e.g., parental controls)
        break;
      case TrackingStatus.notDetermined:
        print('App Tracking Permission: Not Determined');
        // Permission hasn't been requested yet
        break;
    }
  }

  /// Get IDFA if authorized (optional - for logging purposes)
  Future<void> _getIDFA() async {
    try {
      final String? idfa = await AppTrackingTransparency.getAdvertisingIdentifier();
      if (idfa != null) {
        print('IDFA: $idfa');
      } else {
        print('IDFA not available');
      }
    } catch (error) {
      print('Error getting IDFA: $error');
    }
  }

  /// Initialize Trackier SDK with ATT support
  Future<void> _initializeTrackierSDK() async {
    try {
      // Create SDK configuration
      TrackierSDKConfig trackerSDKConfig = TrackierSDKConfig(
        "YOUR_SDK_KEY",
        "production"
      );

      // iOS: Request ATT permission and configure timeout
      if (Platform.isIOS) {
        print('iOS detected, handling ATT...');
        
        // Request ATT permission first
        await _requestATTPermission();
        
        // Wait for ATT user authorization with 20 second timeout
        print('Waiting for ATT user authorization (20 seconds timeout)...');
        Trackierfluttersdk.waitForATTUserAuthorization(20);
        print('ATT wait completed');
      }

      // Initialize SDK
      Trackierfluttersdk.initializeSDK(trackerSDKConfig);
      print('Trackier SDK initialized successfully');
    } catch (error) {
      print('Error initializing Trackier SDK: $error');
    }
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Your App',
      home: Scaffold(
        appBar: AppBar(title: Text('Trackier SDK with ATT')),
        body: Center(child: Text('Trackier SDK Initialized')),
      ),
    );
  }
}

Key Features

• waitForATTUserAuthorization(20): This method waits for the user to respond to the ATT prompt before initializing the SDK. The timeout can be adjusted based on your app's needs.
• Automatic Status Handling: The SDK automatically handles all ATT status responses.
• IDFA Access: Provides easy access to IDFA when permission is granted.
• Platform Check: Seamlessly handles iOS-specific code with Platform.isIOS checks.

warning

Always replace "YOUR_SDK_KEY" with your actual SDK token from the Trackier Panel. Using an incorrect token will cause attribution issues.

Visual Examples

ATT Permission Dialog:

IDFA Console Logs:

IDFA Panel in Trackier Dashboard: When tracking is properly configured with ATT, you can see the IDFA details in the Trackier panel for installs and events:

This panel shows the IDFA information when users grant tracking permission, allowing for accurate attribution and detailed tracking analytics.

ATT Status Values

Status	Description	SDK Behavior
.authorized	User granted permission	Full tracking enabled, IDFA available
.denied	User denied permission	Limited tracking, no IDFA
.restricted	System restricted (parental controls)	Limited tracking, no IDFA
.notDetermined	Permission not requested yet	Wait for user decision

Best Practices

• Timing: Request permission after app launch (1-2 second delay)
• User Experience: Explain why tracking is needed before requesting permission
• Timeout Configuration: Adjust timeout based on your app's flow (default 20 seconds)
• Status Monitoring: Monitor tracking status changes and update UI accordingly
• Check Status First: Always check if permission has already been determined before requesting
• Handle All Cases: Implement proper handling for all ATT status values
• iOS Version Check: Always check platform before using ATT

Troubleshooting

Common Issues

ATT Permission Not Requested

• Ensure NSUserTrackingUsageDescription is added to Info.plist
• Check that the app targets iOS 14.5 or later
• Verify the permission request is called after app launch

IDFA Not Available

• Check if user granted permission (status should be .authorized)
• Ensure the device supports IDFA (not available on simulator)
• Verify the app is not restricted by parental controls

SDK Initialization Issues

• Make sure waitForATTUserAuthorization is called before SDK initialization
• Check that the timeout value is appropriate for your app flow
• Verify the SDK token is correct

Debug Tips

// Check current tracking status
final status = await AppTrackingTransparency.trackingAuthorizationStatus;
print('Current ATT Status: $status');

// Check if IDFA is available
final idfa = await AppTrackingTransparency.getAdvertisingIdentifier();
if (idfa != null) {
  print('IDFA: $idfa');
} else {
  print('IDFA not available');
}

Support

For technical support and questions:

• Support Email: support@trackier.com
• Documentation: Trackier Documentation Portal

---

This guide provides comprehensive implementation of App Tracking Transparency with the Trackier Flutter SDK, ensuring compliance with Apple's privacy requirements while maintaining accurate attribution and tracking capabilities.