Push Notifications

Server             Airship            Mobile Device
  |                   |                      |
  |-- Send Push ----->|                      |
  |   (reportID,      |                      |
  |    message,       |                      |
  |    onyxData)      |                      |
  |                   |                      |
  |                   |-- APNs/FCM --------->|
  |                   |   (encrypted)        |
  |                   |                      |
  |                   |                      |-- Display ---->
  |                   |                      |   Notification
  |                   |                      |
  |                   |                      |<-- User Tap ---
  |                   |                      |
  |                   |                      |-- Open App --->
  |                   |                      |   Navigate to
  |                   |                      |   Report

func parsePayload(notificationContent: UNMutableNotificationContent) throws -> NotificationData {
    guard let rawPayload = notificationContent.userInfo["payload"] else {
        throw ExpError.runtimeError("payload missing")
    }
  
    let payload = try processPayload(rawPayload: rawPayload)
    
    guard let reportID = payload["reportID"] as? Int64,
          let reportActionID = payload["reportActionID"] as? String,
          let onyxData = payload["onyxData"] as? NSArray else {
        throw ExpError.runtimeError("Required fields missing")
    }
    
    // Extract report action data from onyxData[1]
    guard let reportActionOnyxUpdate = onyxData[1] as? NSDictionary,
          let reportActionCollection = reportActionOnyxUpdate["value"] as? NSDictionary,
          let reportAction = reportActionCollection[reportActionID] as? NSDictionary else {
        throw ExpError.runtimeError("Report action data missing")
    }
    
    guard let avatarURL = reportAction["avatar"] as? String,
          let accountID = reportAction["actorAccountID"] as? Int,
          let person = reportAction["person"] as? NSArray,
          let personObject = person[0] as? NSDictionary,
          let userName = personObject["text"] as? String else {
        throw ExpError.runtimeError("Actor data missing")
    }
    
    return NotificationData(
        reportID: reportID,
        reportActionID: reportActionID,
        avatarURL: avatarURL,
        accountID: accountID,
        userName: userName,
        title: notificationContent.title,
        messageText: notificationContent.body,
        subtitle: payload["subtitle"] as? String
    )
}

<key>inProduction</key>
<true/>

inProduction = true

cp android/app/src/main/assets/airshipconfig.properties \
   android/app/src/development/assets/airshipconfig.properties

const register: Register = (notificationID) => {
    Airship.contact.getNamedUserId().then((userID) => {
        // Skip if already registered
        if (!CONFIG.IS_HYBRID_APP && userID === notificationID.toString()) {
            return;
        }

        // Request permissions (iOS prompts user)
        Airship.push.getNotificationStatus().then(({notificationPermissionStatus}) => {
            if (notificationPermissionStatus !== PermissionStatus.NotDetermined) {
                return;
            }

            Airship.push.enableUserNotifications().then((isEnabled) => {
                if (!isEnabled) {
                    Log.info('[PushNotification] User disabled notifications');
                }
            });
        });

        // Register device with Airship
        Log.info(`[PushNotification] Subscribing to notifications`);
        Airship.contact.identify(notificationID.toString());
    });
};

const deregister: Deregister = () => {
    Log.info('[PushNotification] Unsubscribing from notifications');
    Airship.contact.reset();
    Airship.removeAllListeners(EventType.PushReceived);
    Airship.removeAllListeners(EventType.NotificationResponse);
    ForegroundNotifications.disableForegroundNotifications();
    ShortcutManager.removeAllDynamicShortcuts();
};

import NotificationType from './NotificationType';
import parsePushNotificationPayload from './parsePushNotificationPayload';

type NotificationEventHandler<T> = (data: NotificationDataMap[T]) => Promise<void>;

const notificationEventActionMap: NotificationEventActionMap = {};

function pushNotificationEventCallback(eventType: EventType, notification: PushPayload) {
    const actionMap = notificationEventActionMap[eventType] ?? {};
    const data = parsePushNotificationPayload(notification.extras.payload);

    if (!data || !data.type) {
        Log.warn('[PushNotification] Invalid notification payload');
        return;
    }

    const action = actionMap[data.type];
    if (!action) {
        Log.warn('[PushNotification] No callback for notification type:', data.type);
        return;
    }

    // Execute callback (must return promise for Android background)
    return action(data);
}

// Bind callback for when notification is received
PushNotification.onReceived(NotificationType.REPORT_COMMENT, async (data) => {
    // Update badge count, show local notification, etc.
    Log.info('[PushNotification] Report comment received:', data.reportID);
    
    // Update Onyx with new data
    applyOnyxUpdatesFromNotification(data.onyxData);
});

// Bind callback for when notification is tapped
PushNotification.onSelected(NotificationType.REPORT_COMMENT, async (data) => {
    // Navigate to the report
    Log.info('[PushNotification] Opening report:', data.reportID);
    Navigation.navigate(ROUTES.REPORT_WITH_ID.getRoute(data.reportID));
});

interface NotificationPayload {
  type: keyof typeof NotificationType;
  reportID: string;
  reportActionID?: string;
  
  // Onyx updates to apply
  onyxData?: OnyxUpdate[];
  
  // Display text
  title: string;
  message: string;
  subtitle?: string;
  
  // User info
  actorAccountID?: number;
  avatar?: string;
}

import Airship from '@ua/react-native-airship';

// Set badge count
function setBadgeCount(count: number) {
  Airship.push.iOS.setBadgeNumber(count);
}

// Clear badge
function clearBadge() {
  Airship.push.iOS.setBadgeNumber(0);
}

// Reset on app open
function resetBadgeOnOpen() {
  if (Platform.OS === 'ios') {
    Airship.push.iOS.setBadgeNumber(0);
  }
}

import Airship, {PermissionStatus} from '@ua/react-native-airship';

async function checkNotificationPermissions() {
  const status = await Airship.push.getNotificationStatus();
  
  switch (status.notificationPermissionStatus) {
    case PermissionStatus.Granted:
      return 'granted';
    case PermissionStatus.Denied:
      return 'denied';
    case PermissionStatus.NotDetermined:
      return 'not_determined';
    default:
      return 'unknown';
  }
}

async function requestNotificationPermissions() {
  const isEnabled = await Airship.push.enableUserNotifications();
  
  if (isEnabled) {
    Log.info('[PushNotification] User granted notification permissions');
  } else {
    Log.info('[PushNotification] User denied notification permissions');
    
    // Guide user to settings
    Alert.alert(
      'Enable Notifications',
      'To receive updates, enable notifications in Settings',
      [
        {text: 'Cancel', style: 'cancel'},
        {text: 'Settings', onPress: () => Linking.openSettings()},
      ]
    );
  }
  
  return isEnabled;
}

// Silent push - no notification shown, just data sync
PushNotification.onReceived(NotificationType.SILENT_SYNC, async (data) => {
    Log.info('[PushNotification] Silent push received, syncing data');
    
    // Apply Onyx updates in background
    if (data.onyxData) {
        await applyOnyxUpdates(data.onyxData);
    }
    
    // No notification displayed to user
});

// Define notification categories with actions
let replyAction = UNNotificationAction(
    identifier: "REPLY_ACTION",
    title: "Reply",
    options: [.foreground]
)

let markReadAction = UNNotificationAction(
    identifier: "MARK_READ_ACTION",
    title: "Mark as Read",
    options: []
)

let category = UNNotificationCategory(
    identifier: "MESSAGE_CATEGORY",
    actions: [replyAction, markReadAction],
    intentIdentifiers: [],
    options: []
)

UNUserNotificationCenter.current().setNotificationCategories([category])

Airship.addListener(EventType.NotificationResponse, (event) => {
    const actionID = event.actionId;
    
    switch (actionID) {
        case 'REPLY_ACTION':
            // Open report for reply
            Navigation.navigate(ROUTES.REPORT_WITH_ID.getRoute(event.reportID));
            break;
        case 'MARK_READ_ACTION':
            // Mark as read without opening
            markReportAsRead(event.reportID);
            break;
    }
});