Android

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

repositories {
    mavenCentral()
}

dependencies {
    implementation 'com.userpilot:userpilot-android:<latest_version>'
}

public interface UserpilotNavigationHandler {
     public fun navigateTo(uri: Uri)
}

public interface UserpilotAnalyticsListener {

    /**
     * Notifies the listener when a Userpilot analytics event is tracked.
     *
     * @param type The type of analytic being tracked. Possible values are:
     * - `Identify`: Represents an identify event.
     * - `Screen`: Represents a screen tracking event.
     * - `Event`: Represents a custom event.
     * @param value The primary value of the analytic being tracked:
     * - For `Identify`: The user ID.
     * - For `Screen`: The screen title.
     * - For `Event`: The event name.
     * @param properties Additional context or metadata associated with the analytic, provided as a `Payload` object.
     */
    public fun didTrack(type: UserpilotAnalytic, value: String, properties: Payload)
}

public enum class UserpilotAnalytic {
    Identify,
    Screen,
    Event
}

public interface UserpilotExperienceListener {

    /**
     * Notifies the listener of changes in the state of a Userpilot experience.
     *
     * @param experienceType The current experience type.
     * @param experienceId A unique identifier for the experience.
     * @param experienceState The current state of the experience.
     */
    public fun onExperienceStateChanged(
        experienceType: UserpilotExperienceType,
        experienceId: Int?,
        experienceState: UserpilotExperienceState
    )

    /**
     * Notifies the listener when the state of a specific step in a Userpilot experience changes.
     *
     * @param experienceType The current experience type.
     * @param experienceId A unique identifier for the experience.
     * @param stepId A unique identifier for the experience step.
     * @param stepState The current step state of the experience.
     * @param step The index of current step in the experience.
     * @param totalSteps The total number of steps in the experience.
     */
    @Suppress("LongParameterList")
    public fun onExperienceStepStateChanged(
        experienceType: UserpilotExperienceType,
        experienceId: Int,
        stepId: Int,
        stepState: UserpilotExperienceState,
        step: Int?,
        totalSteps: Int?
    )
}

/**
 * Enum representing the possible states of a Userpilot experience.
 */
public enum class UserpilotExperienceType {
    Flow,
    Survey,
    NPS
}

/**
 * Enum representing the possible states of a Userpilot experience.
 */
public enum class UserpilotExperienceState {
    /**
     * Indicates that the experience has started.
     */
    Started,

    /**
     * Indicates that the experience has successfully completed.
     */
    Completed,

    /**
     * Indicates that the experience was dismissed before completion.
     */
    Dismissed,

    /**
     * Indicates that the  experience/step was skipped.
     */
    Skipped,

    /**
     * Indicates that the experience/step was Submitted.
     */
    Submitted
}

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

private val requestPermissionLauncher = 
    registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted: Boolean ->
        if (isGranted) {
            // Permission granted: FCM and your app can post notifications.
        } else {
            // Permission denied: Inform the user they won’t receive notifications.
        }
    }

private fun requestNotificationPermission() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
        when {
            ContextCompat.checkSelfPermission(
                this, Manifest.permission.POST_NOTIFICATIONS
            ) == PackageManager.PERMISSION_GRANTED -> {
                // Permission already granted.
            }

            shouldShowRequestPermissionRationale(Manifest.permission.POST_NOTIFICATIONS) -> {
                // Show an educational UI explaining why the permission is needed.
                // Once the user acknowledges, request the permission via `requestPermissionLauncher`.
            }

            else -> {
                // Directly request the permission.
                requestPermissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
            }
        }
    }
}

 <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=".features.main.MainActivity"
    android:exported="true"
    android:launchMode="singleTop">

    <!-- Default launcher intent filter -->
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>

    <!-- Intent filter for push notification deep linking -->
    <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)
  
    handleIntentUserpilotIntent(intent)
}


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

    if (handleIntentUserpilotIntent(intent)) return
}


 /** If not handled by Userpilot, then let app handle it. */
private fun handleIntentUserpilotIntent(intent: Intent): Boolean {
    return userpilot.onNewIntent(intent)
}

<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>