Advanced Push Notifications: A/B Testing and Personalization

// Example: Creating a segment for cart abandoners
class SegmentBuilder {
    static func cartAbandoners(delay: TimeInterval = 3600) -> Segment {
        Segment(
            name: "Cart Abandoners",
            conditions: [
                Condition(event: "added_to_cart", within: .last24Hours),
                Condition.not(Condition(event: "completed_purchase", within: .last24Hours))
            ],
            delay: delay
        )
    }
    
    static func dormantUsers(days: Int = 30) -> Segment {
        Segment(
            name: "Dormant Users",
            conditions: [
                Condition.not(Condition(event: "app_opened", within: .last(days))),
                Condition(property: "push_enabled", equals: true)
            ]
        )
    }
---

// Firebase Cloud Messaging topic subscription
FirebaseMessaging.getInstance().subscribeToTopic("premium_users")
FirebaseMessaging.getInstance().subscribeToTopic("ios_users")

{
  "title": "{{first_name}}, your playlist is ready",
  "body": "We found {{count}} new tracks matching your taste",
  "data": {
    "playlist_id": "{{playlist_id}}",
    "personalized": true
  }
---

class OptimalTimeService {
    func bestTimeToSend(userId: String) async -> DateComponents {
        let history = await engagementHistory(for: userId)
        // Find the hour with highest open rate for this user
        let bestHour = history.groupedByHour().max(by: \.value.openRate)
        return DateComponents(hour: bestHour, minute: 0)
    }
---

// Trigger when user enters a geofence
func onEnterGeofence(region: CGRange) {
    if region.type == .store {
        pushService.send(
            title: "Welcome to our {{city}} store!",
            body: "Show this for 10% off your purchase",
            trigger: .location(region)
        )
    }
---

struct ABTest {
    let id: String
    let variants: [Variant]
    let metrics: [Metric]
    
    struct Variant {
        let name: String
        let title: String
        let body: String
        let image: String?
        let weight: Int  // percentage
    }
    
    enum Metric {
        case openRate
        case conversionRate
        case revenuePerUser
        case optOutRate
    }
---

class NotificationABTestService {
    func assignVariant(userId: String, test: ABTest) -> ABTest.Variant {
        // Deterministic assignment for consistent user experience
        let hash = abs(userId.hash) % 100
        var cumulative = 0
        for variant in test.variants {
            cumulative += variant.weight
            if hash < cumulative {
                return variant
            }
        }
        return test.variants.last!
    }
---

struct ABTestResult {
    let variantA: VariantResult
    let variantB: VariantResult
    let minimumSampleSize: Int = 1000  // per variant
    
    func isSignificant(confidence: Double = 0.95) -> Bool {
        // Chi-squared or Bayesian test
        return bayesianProbability(alpha: variantA, beta: variantB) > confidence
    }
---

// iOS Notification Service Extension
class NotificationService: UNNotificationServiceExtension {
    override func didReceive(_ request: UNNotificationRequest,
                            withContentHandler handler: @escaping (UNNotificationContent) -> Void) {
        let content = request.content.mutableCopy() as! UNMutableNotificationContent
        
        // Download and attach image
        if let imageURL = content.userInfo["image_url"] as? String {
            downloadAndAttach(url: imageURL) { attachment in
                content.attachments = [attachment].compactMap { $0 }
                handler(content)
            }
        } else {
            handler(content)
        }
    }
---

// Android — BigPictureStyle notification
val style = NotificationCompat.BigPictureStyle()
    .bigPicture(bitmap)
    .setSummaryText("Check out this photo")

NotificationCompat.Builder(this, CHANNEL_ID)
    .setStyle(style)
    .setLargeIcon(bitmap)
    .build()

// iOS — action buttons
let acceptAction = UNNotificationAction(identifier: "ACCEPT",
                                        title: "Accept",
                                        options: .foreground)
let declineAction = UNNotificationAction(identifier: "DECLINE",
                                         title: "Decline",
                                         options: .destructive)
let category = UNNotificationCategory(identifier: "FRIEND_REQUEST",
                                      actions: [acceptAction, declineAction],
                                      intentIdentifiers: [])
UNUserNotificationCenter.current().setNotificationCategories([category])

// Android — direct reply and actions
val replyAction = NotificationCompat.Action.Builder(
    R.drawable.ic_reply, "Reply", replyPendingIntent
).build()

val markAsReadAction = NotificationCompat.Action.Builder(
    R.drawable.ic_read, "Mark as read", readPendingIntent
).build()

class FrequencyCapService {
    let maxDaily = 3
    let maxWeekly = 10
    
    func canSend(userId: String) async -> Bool {
        let sent = await notificationLog.count(for: userId, period: .last24h)
        return sent < maxDaily
    }
---

// Send based on user timezone
func scheduleNotification(notification: PushNotification, userTimezone: TimeZone) {
    var dateComponents = DateComponents()
    dateComponents.hour = 10  // 10 AM local time
    let trigger = UNCalendarNotificationTrigger(dateMatching: dateComponents, repeats: false)
    // ...
---

struct NotificationAnalytics {
    let delivered: Int
    let opened: Int
    let converted: Int
    let optedOut: Int
    
    var openRate: Double { Double(opened) / Double(delivered) }
    var conversionRate: Double { Double(converted) / Double(opened) }
    var optOutRate: Double { Double(optedOut) / Double(delivered) }
    
    func report() {
        print("Open rate: \(openRate * 100)%")
        print("Conversion rate: \(conversionRate * 100)%")
    }
---