React Native

android {
    compileSdkVersion 34

    defaultConfig {
        minSdkVersion 21
    }
}

# Podfile
platform :ios, '13.0'

npm install @userpilot/react-native

pod install

import * as Userpilot from '@userpilot/react-native'

await Userpilot.setup('<APP_TOKEN>', { logging: true })

// API
identify(userID: string, properties?: Object, company?: Object): void;

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

// API
screen(title: string): void;

// Example
userpilot.screen('Profile');

// API
track(name: string, properties?: Object): void;

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

userpilot.logout()

userpilot.anonymous()

// API
triggerExperience(experienceID: string): void;

// Example
userpilot.triggerExperience('<EXPERIENCE_ID>')

userpilot.endExperience()

useEffect(() => {
  const eventEmitter = new NativeEventEmitter(
    NativeModules.UserpilotReactNative
  )
  const listeners = [
    eventEmitter.addListener('UserpilotAnalyticsEvent', (event) =>
      console.log('Analytics Event:', JSON.stringify(event, null, 2))
    ),
    eventEmitter.addListener('UserpilotExperienceEvent', (event) =>
      console.log('Experience Event:', JSON.stringify(event, null, 2))
    ),
    eventEmitter.addListener('UserpilotNavigationEvent', (event) => {
      console.log('Navigation Event', JSON.stringify(event, null, 2))
      if (event?.url) handleDeepLink(event.url)
    }),
  ]
  return () => listeners.forEach((listener) => listener.remove())
}, [])

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

  const requestNotificationPermission = async () => {
    if (Platform.OS === 'android' && Platform.Version >= 33) {
      try {
        const alreadyGranted = await PermissionsAndroid.check(
          PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS
        )

        if (alreadyGranted) {
          console.log('Notification permission already granted')
          return
        }

        const granted = await PermissionsAndroid.request(
          PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS,
          {
            title: 'Notification Permission',
            message: 'This app would like to send you notifications',
            buttonPositive: 'Allow',
            buttonNegative: 'Deny',
          }
        )

        if (granted === PermissionsAndroid.RESULTS.GRANTED) {
          console.log('Notification permission granted')
        } else {
          console.log('Notification permission denied')
        }
      } catch (err) {
        console.warn('Permission request error:', err)
      }
    }
  }

<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:label="@string/app_name"
  android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode"
  android:launchMode="singleTask"
  android:windowSoftInputMode="adjustResize"
  android:exported="true">
  <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)
}

/** If not handled by Userpilot, then let app handle it. */
private fun handleIntent(intent: Intent) {
   if (UserpilotReactNativeModule.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.
}

// AppDelegate+PushNotification.swift

import Foundation
import UserNotifications
import UserpilotReactNative

typealias UserpilotImplementation = Implementation

extension AppDelegate: UNUserNotificationCenterDelegate {
    /// 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 React Native 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) {
      UserpilotImplementation.setPushToken(deviceToken)
    }

    // 3: Pass the user's response to a delivered notification to Userpilot
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse,
        withCompletionHandler completionHandler: @escaping () -> Void
    ) {
        if UserpilotImplementation.didReceiveNotification(response: response, completionHandler: completionHandler) {
            return
        }

        completionHandler()
    }

    // 4: Configure handling for notifications that arrive while the app is in the foreground
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        willPresent notification: UNNotification,
        withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
    ) {
        if #available(iOS 14.0, *) {
            completionHandler([.banner, .list])
        } else {
            completionHandler(.alert)
        }
    }
}