Flutter

android {
    compileSdkVersion 34

    defaultConfig {
        minSdkVersion 21
    }
}

plugins {  
  id 'com.android.application' 
  id 'kotlin-android' 
}

# Podfile
platform :ios, '13.0'

dependencies:
  userpilot_flutter: <latest_version>

import 'package:userpilot_flutter/userpilot_flutter.dart';

UserpilotOptions options = UserpilotOptions();
options.logging = true;
 
Userpilot.initialize("<APP_TOKEN>", options);

userpilot.identify(
  "<USER_ID>", 
   {
      "name" : "John Doe",
      "email" to "user@example.com", 
      "created_at" to "2019-10-17", 
      "role" to "Admin"
   },   
   {
      "id" to "<COMPANY_ID>",
      "name": "Acme Labs", 
      "created_at": "2019-10-17", 
      "plan" to "Free"
   }
);

userpilot.screen("Profile");

userpilot.track("Added to Cart", {"itemId" : "sku_456", "price" : 29.99})

userpilot.logout()

userpilot.anonymous()

userpilot.triggerExperience("<EXPERIENCE_ID>")

userpilot.endExperience()

StreamSubscription<UserpilotExperience>? experienceSubscription;
StreamSubscription<UserpilotAnalytic>? analyticsSubscription;
StreamSubscription<UserpilotNavigation>? navigationSubscription;

@override
  void initState() {
    super.initState();
    _initializeUserpilot();

    experienceSubscription = Userpilot.onExperienceEvent.listen(
      _handleExperienceEvent,
      onError: _handleError,
    );

    analyticsSubscription = Userpilot.onAnalyticEvent.listen(
      _handleAnalyticsEvent,
      onError: _handleError,
    );

    navigationSubscription = Userpilot.onNavigationEvent.listen(
      _handleNavigationEvent,
      onError: _handleError,
    );
  }

  @override
  void dispose() {
    experienceSubscription?.cancel();
    analyticsSubscription?.cancel();
    navigationSubscription?.cancel();
    super.dispose();
  }

  void _handleExperienceEvent(UserpilotExperience event) {
    print('Experience Event: ${event.state}, ID: ${event.id}');
  }

  void _handleAnalyticsEvent(UserpilotAnalytic event) {
    print('Analytics Event: ${event.analytic}, Value: ${event.value}');
  }

  void _handleNavigationEvent(UserpilotNavigation event) {
    print('Navigation Event URI: ${event.uri}');
  }

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

  void _requestNotificationPermission() {
    if (Platform.isAndroid) {
      DeviceInfoPlugin().androidInfo.then((androidInfo) {
        final sdkInt = androidInfo.version.sdkInt ?? 0;
        if (sdkInt >= 33) {
          Permission.notification.status.then((status) {
            if (status.isDenied || status.isPermanentlyDenied) {
              Permission.notification.request().then((result) {
                print("Notification permission result: $result");
              });
            }
          });
        }
      });
    }
  }

 <service
 android:name="com.userpilot.pushNotifications.UserpilotFirebaseMessagingService"
    android:exported="false">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT" />
    </intent-filter>
</service>

import com.userpilot.pushNotifications.UserpilotFirebaseMessagingService
import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage

class CustomFirebaseMessageService : FirebaseMessagingService() {
    override fun onMessageReceived(message: RemoteMessage) {
        if (UserpilotFirebaseMessagingService.handleMessage(baseContext, message)) {
           // handled as Userpilot message
           return
        }

        // not Userpilot message
        super.onMessageReceived(message)
        }

    override fun onNewToken(token: String) {
       // sets new token from the callback
       UserpilotFirebaseMessagingService.setToken(token)

       super.onNewToken(token)
    }
}

<activity
    android:name=".MainActivity"
    android:exported="true"
    android:launchMode="singleTop"
    android:taskAffinity=""
    android:theme="@style/LaunchTheme"
    android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
    android:hardwareAccelerated="true"
    android:windowSoftInputMode="adjustResize">
    <!-- Specifies an Android theme to apply to this Activity as soon as
         the Android process has started. This theme is visible to the user
         while the Flutter UI initializes. After that, this theme continues
         to determine the Window background behind the Flutter UI. -->
    <meta-data
      android:name="io.flutter.embedding.android.NormalTheme"
      android:resource="@style/NormalTheme"
      />
    <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
        <category android:name="android.intent.category.LAUNCHER"/>
    </intent-filter>
    <intent-filter>
        <data android:scheme="userpilot_push_notification" android:host="sdk"/>
        <action android:name="android.intent.action.VIEW" />

        <category android:name="android.intent.category.DEFAULT" />
        <category android:name="android.intent.category.BROWSABLE" />
    </intent-filter>
</activity>

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    handleIntent(intent)
}

override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)
    handleIntent(intent)
}

private fun handleIntent(intent: Intent) {
    if (UserpilotFlutterPlugin.handleIntent(intent)) return
}

<resources>
    <!-- Small icon displayed in the notification bar -->
    <drawable name="userpilot_notification_small_icon">@drawable/ic_notification</drawable>

    <!-- Accent color applied to notification UI elements -->
    <color name="userpilot_notification_color">#6765E8</color>

    <!-- Determines if notifications are visible on the lock screen (true = visible) -->
    <bool name="userpilot_notification_channel_lock_screen_visibility">true</bool>

    <!-- Enables notification lights for the channel -->
    <bool name="userpilot_notification_channel_enable_light">true</bool>

    <!-- Enables vibration for the notifications -->
    <bool name="userpilot_notification_channel_enable_vibration">true</bool>

    <!-- Unique ID for the notification channel -->
    <string name="userpilot_notification_channel_id">com.userpilot.general.channel</string>

    <!-- Human-readable name for the notification channel -->
    <string name="userpilot_notification_channel_name">General</string>

    <!-- Description shown to the user about this notification channel -->
    <string name="userpilot_notification_channel_description">Default channel used for app messages</string>

    <!-- Importance level of the notification channel (0 = NONE, 5 = MAX) -->
    <integer name="userpilot_notification_channel_importance">3</integer>

    <!-- Key used to identify Userpilot push notifications -->
    <string name="userpilot_push_notification">userpilot_push_notification</string>
</resources>

func application(
_ application: UIApplication, didFinishLaunchingWithOptions
launchOptions: [UIApplication.LaunchOptionsKey: Any]?
) -> Bool {
   // Automatically configure for push notifications
   Userpilot.enableAutomaticPushConfig()

   // Override point for customization after application launch.
   return true
}

// AppDelegate+PushNotification.swift

import Foundation
import UserNotifications
import userpilot_flutter

extension AppDelegate {
    /// Call from `UIApplicationDelegate.application(_:didFinishLaunchingWithOptions:)`
    func setupPush(application: UIApplication) {
        requestPushNotificationPermission()

        // 1: Register to get a device token
        application.registerForRemoteNotifications()
        
        UNUserNotificationCenter.current().delegate = self
    }
    
    // MARK: - Push Notification Permission Request, In case you didn't request it from your Flutter app.
    private func requestPushNotificationPermission() {
        let options: UNAuthorizationOptions = [.alert, .sound, .badge]

        // Check if the app has already been authorized
        UNUserNotificationCenter.current().getNotificationSettings { (settings) in
            if settings.authorizationStatus == .authorized {
                // App is already authorized for push notifications
                // Register for remote notifications again to get the device token
                DispatchQueue.main.async {
                    UIApplication.shared.registerForRemoteNotifications()
                }
            } else {
                // If not authorized, request permission
                UNUserNotificationCenter.current().requestAuthorization(options: options) { (granted, error) in
                    if granted {
                        DispatchQueue.main.async {
                            UIApplication.shared.registerForRemoteNotifications()
                        }
                    } else {
                        if let errorDescription = error?.localizedDescription {
                            print("Permission denied or failed to request: \(errorDescription)")
                        } else {
                            print("Permission denied or failed to request: Unknown error")
                        }
                    }
                }
            }
        }
    }

    // 2: Pass device token to Userpilot
    override func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        SwiftUserpilotFlutterPlugin.setPushToken(deviceToken)
    }
    
    // 3: Pass the user's response to a delivered notification to Userpilot
    override func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse,
        withCompletionHandler completionHandler: @escaping () -> Void
    ) {
        if SwiftUserpilotFlutterPlugin.didReceiveNotification(response: response, completionHandler: completionHandler) {
            return
        }
        
        super.userNotificationCenter(center, didReceive: response, withCompletionHandler: completionHandler)
    }
    
    // 4: Configure handling for notifications that arrive while the app is in the foreground
    override func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        willPresent notification: UNNotification,
        withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
    ) {
        if #available(iOS 14.0, *) {
            completionHandler([.banner, .list])
        } else {
            completionHandler(.alert)
        }
    }
}