React Native Push Notifications

// willPresent
AppDNA.pushModule.handleMessageData(notification.request.content.userInfo)
// didReceive
AppDNA.pushModule.handleNotificationTap(response.notification.request.content.userInfo,
                                        actionIdentifier: response.actionIdentifier)

AppDNA.installNotificationProxy()

// android/app/src/main/java/.../MainActivity.kt
override fun onNewIntent(intent: Intent) {
  super.onNewIntent(intent)
  setIntent(intent)
}

<service android:name="ai.appdna.sdk.integrations.AppDNAMessagingService" tools:node="remove"/>

<bool name="appdna_messaging_service_enabled">false</bool>

import { Platform } from 'react-native';
import messaging from '@react-native-firebase/messaging';

async function registerPushToken() {
  if (Platform.OS === 'ios') {
    // iOS: the APNs token — never getToken() (the FCM token) on iOS.
    const t = await messaging().getAPNSToken(); // null until iOS has registered with APNs
    if (t) { await AppDNA.setPushToken(t); }
  } else {
    // Android: the FCM token.
    const t = await messaging().getToken();
    if (t) { await AppDNA.setPushToken(t); }
  }
}

// After configure, again after requestPermission() resolves, and on every app start.
await registerPushToken();
// onTokenRefresh reports FCM tokens only — use it on Android; iOS re-reads getAPNSToken() at start.
messaging().onTokenRefresh(async (token: string) => {
  if (Platform.OS === 'android') await AppDNA.setPushToken(token);
});

import messaging from '@react-native-firebase/messaging';

messaging().onMessage(async (message: { data?: Record<string, string> }) => {
  const data = message.data ?? {};
  if (await AppDNA.push.isAppDNAMessage(data)) {
    await AppDNA.push.handleMessage(data); // tracks delivered, fires onPushReceived; never displays
  }
  // ...your own handling of your own messages
});

import messaging from '@react-native-firebase/messaging';

messaging().onNotificationOpenedApp(async (message: { data?: Record<string, string> }) => {
  await AppDNA.push.handleTap(message.data ?? {});
});
const initial = await messaging().getInitialNotification();
if (initial) await AppDNA.push.handleTap(initial.data ?? {});

await AppDNA.setPushToken("device-token-string");

await AppDNA.setPushPermission(true);

await AppDNA.trackPushDelivered("push-123");

await AppDNA.trackPushTapped("push-123", "open_workout");

const push = AppDNA.push;

const granted = await AppDNA.push.requestPermission();

if (granted) {
  console.log("Push permission granted");
} else {
  console.log("Push permission denied");
}

const token = await AppDNA.push.getToken();
if (token) {
  console.log("Current token:", token);
}

interface AppDNAPushDelegate {
  onPushTokenRegistered(token: string): void;
  onPushReceived(notification: Record<string, unknown>, inForeground: boolean): void;
  /** `actionId` is `undefined` when the user tapped the body rather than an action button. */
  onPushTapped(notification: Record<string, unknown>, actionId: string | undefined): void;
}

declare function showBanner(title: unknown, body: unknown): void;
declare function handleAction(actionId: string): void;

AppDNA.push.setDelegate({
  onPushTokenRegistered(token: string) {
    console.log('Token registered:', token);
  },

  onPushReceived(notification: Record<string, unknown>, inForeground: boolean) {
    if (inForeground) {
      // The notification map uses the snake_case keys native sends.
      showBanner(notification.title, notification.body);
    }
  },

  onPushTapped(notification: Record<string, unknown>, actionId: string | undefined) {
    if (actionId) {
      // Handle custom action
      handleAction(actionId);
    }
  },
});

import { AppDNAPush } from '@appdna-ai/react-native-sdk';

import { AppDNAPush } from '@appdna-ai/react-native-sdk';

declare function navigateTo(target: string): void;

// Request permission
const granted = await AppDNAPush.requestPermission();

// Listen for received push notifications
const unsubReceived = AppDNAPush.onPushReceived((payload, inForeground) => {
  console.log('Push received:', payload.title, inForeground);
});

// Listen for push notification taps. The payload keys are snake_case.
const unsubTapped = AppDNAPush.onPushTapped((payload, actionId) => {
  console.log('Push tapped:', payload.push_id, actionId);
  if (payload.action_value) {
    navigateTo(payload.action_value);
  }
});

// Clean up listeners when component unmounts
unsubReceived();
unsubTapped();

import React, { useEffect } from 'react';
import { AppDNA, AppDNAPush } from '@appdna-ai/react-native-sdk';

declare function showInAppBanner(notification: Record<string, unknown>): void;
declare function handleDeepLink(
  notification: Record<string, unknown>,
  actionId: string | undefined,
): void;
declare function MainNavigator(): React.ReactElement;

function App() {
  useEffect(() => {
    async function setupPush() {
      // Set the delegate first, so a tap that launched the app reaches onPushTapped
      AppDNA.push.setDelegate({
        onPushTokenRegistered(token) {
          console.log("Token:", token);
        },
        onPushReceived(notification, inForeground) {
          if (inForeground) {
            showInAppBanner(notification);
          }
        },
        onPushTapped(notification, actionId) {
          handleDeepLink(notification, actionId);
        },
      });

      // Configure the SDK
      await AppDNA.configure('adn_live_xxx', 'production');

      // Request permission
      const granted = await AppDNA.push.requestPermission();
      console.log("Push permission:", granted);
    }

    void setupPush();
  }, []);

  // Listener-based approach for component-scoped handling
  useEffect(() => {
    const unsubReceived = AppDNAPush.onPushReceived((payload) => {
      console.log('Received:', payload.title);
    });

    const unsubTapped = AppDNAPush.onPushTapped((payload) => {
      console.log('Tapped:', payload.push_id);
    });

    return () => {
      unsubReceived();
      unsubTapped();
    };
  }, []);

  return <MainNavigator />;
}

await AppDNA.identify('user-123', { timezone: 'Europe/Berlin' }); // the zone the user chose in your app