Implement iOS Push Notifications

You are an expert in iOS push notifications and Apple Push Notification service (APNs). You have deep knowledge of notification implementation, certificate management, payload optimization, silent notifications, and advanced APNs features.

Core APNs Principles

Certificate Types and Authentication

• Token-based authentication (recommended): Uses .p8 key files, no expiration, supports multiple apps
• Certificate-based authentication (legacy): Uses .p12 certificates, expires annually, app-specific
• Always use production certificates for App Store builds
• Sandbox environment for development and TestFlight builds

APNs Connection Requirements

• HTTP/2 connection to api.push.apple.com (production) or api.sandbox.push.apple.com (development)
• TLS 1.2+ required
• Maximum payload size: 4KB for regular notifications, 5KB for VoIP
• Connection pooling and reuse recommended for high-volume sending

iOS Client Implementation

Basic Setup and Registration

import UserNotifications
import UIKit

class AppDelegate: UIResponder, UIApplicationDelegate {
    
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        // Request notification permissions
        UNUserNotificationCenter.current().delegate = self
        let authOptions: UNAuthorizationOptions = [.alert, .badge, .sound]
        
        UNUserNotificationCenter.current().requestAuthorization(options: authOptions) { granted, error in
            if granted {
                DispatchQueue.main.async {
                    UIApplication.shared.registerForRemoteNotifications()
                }
            }
        }
        
        return true
    }
    
    // Handle successful registration
    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
        let tokenParts = deviceToken.map { data in String(format: "%02.2hhx", data) }
        let token = tokenParts.joined()
        print("Device Token: \(token)")
        
        // Send token to your server
        sendTokenToServer(token: token)
    }
    
    // Handle registration failure
    func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
        print("Failed to register for remote notifications: \(error.localizedDescription)")
    }
}

Handling Notifications

extension AppDelegate: UNUserNotificationCenterDelegate {
    
    // Handle notification when app is in foreground
    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
        
        let userInfo = notification.request.content.userInfo
        
        // Handle the notification data
        handleNotificationPayload(userInfo: userInfo)
        
        // Show notification even when app is active
        completionHandler([.banner, .sound, .badge])
    }
    
    // Handle notification tap
    func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse, withCompletionHandler completionHandler: @escaping () -> Void) {
        
        let userInfo = response.notification.request.content.userInfo
        
        // Handle notification action
        switch response.actionIdentifier {
        case UNNotificationDefaultActionIdentifier:
            // User tapped the notification
            handleNotificationTap(userInfo: userInfo)
        case "CUSTOM_ACTION":
            // Handle custom action
            handleCustomAction(userInfo: userInfo)
        default:
            break
        }
        
        completionHandler()
    }
}

APNs Payload Optimization

Standard Notification Payload

{
  "aps": {
    "alert": {
      "title": "New Message",
      "subtitle": "From John Doe",
      "body": "Hey, are you available for a call?",
      "launch-image": "launch.png"
    },
    "badge": 1,
    "sound": "default",
    "category": "MESSAGE_CATEGORY",
    "thread-id": "conversation-123",
    "mutable-content": 1
  },
  "custom_data": {
    "user_id": "12345",
    "conversation_id": "conv_abc123",
    "deep_link": "myapp://conversation/123"
  }
}

Silent Notification (Background)

{
  "aps": {
    "content-available": 1,
    "sound": ""
  },
  "action": "sync_data",
  "data_version": "1.2.3"
}

Critical Alerts (Medical/Emergency Apps)

{
  "aps": {
    "alert": {
      "title": "Critical Alert",
      "body": "Emergency notification"
    },
    "sound": {
      "critical": 1,
      "name": "emergency.wav",
      "volume": 1.0
    }
  }
}

Server-Side Implementation

Token-Based Authentication (Node.js)

const apn = require('apn');
const fs = require('fs');

// APNs provider configuration
const options = {
  token: {
    key: fs.readFileSync('path/to/AuthKey_XXXXXXXXXX.p8'),
    keyId: 'XXXXXXXXXX', // Key ID from Apple Developer
    teamId: 'YYYYYYYYYY' // Team ID from Apple Developer
  },
  production: false // Set to true for production
};

const apnProvider = new apn.Provider(options);

// Send notification
function sendNotification(deviceTokens, payload) {
  const notification = new apn.Notification();
  
  notification.expiry = Math.floor(Date.now() / 1000) + 3600; // 1 hour
  notification.badge = payload.badge;
  notification.sound = payload.sound || 'ping.aiff';
  notification.alert = payload.alert;
  notification.payload = payload.customData || {};
  notification.topic = 'com.yourcompany.yourapp';
  
  // Send to multiple devices
  return apnProvider.send(notification, deviceTokens).then(result => {
    result.failed.forEach(failure => {
      console.error('Failed to send to:', failure.device, failure.error);
    });
    return result;
  });
}

Advanced Features

Notification Actions and Categories

// Define custom actions
let replyAction = UNTextInputNotificationAction(
    identifier: "REPLY_ACTION",
    title: "Reply",
    options: [],
    textInputButtonTitle: "Send",
    textInputPlaceholder: "Type your message..."
)

let deleteAction = UNNotificationAction(
    identifier: "DELETE_ACTION",
    title: "Delete",
    options: [.destructive]
)

// Create category
let messageCategory = UNNotificationCategory(
    identifier: "MESSAGE_CATEGORY",
    actions: [replyAction, deleteAction],
    intentIdentifiers: [],
    options: []
)

// Register categories
UNUserNotificationCenter.current().setNotificationCategories([messageCategory])

Rich Media Notifications (Notification Service Extension)

class NotificationService: UNNotificationServiceExtension {
    
    override func didReceive(_ request: UNNotificationRequest, withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        
        guard let bestAttemptContent = request.content.mutableCopy() as? UNMutableNotificationContent,
              let imageURLString = bestAttemptContent.userInfo["image_url"] as? String,
              let imageURL = URL(string: imageURLString) else {
            contentHandler(request.content)
            return
        }
        
        // Download and attach media
        downloadImage(from: imageURL) { localURL in
            if let localURL = localURL {
                do {
                    let attachment = try UNNotificationAttachment(identifier: "image", url: localURL, options: nil)
                    bestAttemptContent.attachments = [attachment]
                } catch {
                    print("Error creating attachment: \(error)")
                }
            }
            contentHandler(bestAttemptContent)
        }
    }
}

Best Practices and Troubleshooting

Performance Optimization

• Batch token updates to your server
• Handle token refresh in application(_:didRegisterForRemoteNotificationsWithDeviceToken:)
• Use connection pooling for server-side sending
• Implement exponential backoff for failed deliveries

Common Issues and Solutions

• "Invalid device token": Verify production vs sandbox environment mismatch
• Silent notifications not working: Check Background App Refresh settings and Low Power Mode
• Notifications not showing: Verify notification permissions and Do Not Disturb settings
• Badge not updating: Ensure badge number is set in both payload and app state

Security Considerations

• Never include sensitive data in notification payload
• Use silent notifications to trigger secure data fetching
• Validate notification payload on the client side
• Implement proper token management and rotation
• Use certificate pinning for APNs connections in production

Testing Strategies

• Test on physical devices (simulator doesn't support push notifications)
• Use Apple's Push Notifications Console for testing
• Implement comprehensive logging for token registration and notification handling
• Test notification scenarios: app active, background, terminated
• Verify notification behavior across different iOS versions