push-notifications

name	push-notifications
description	Multi-platform push notification skill for implementing APNs (iOS), FCM (Android), and cross-platform notification systems with rich media, deep linking, and background processing capabilities.
allowed-tools	Read, Grep, Write, Bash, Edit, Glob, WebFetch
graph	{"domains":["domain:mobile"],"specializations":["specialization:mobile-development"],"skillAreas":["skill-area:push-notifications","skill-area:ios-native"],"roles":["role:mobile-engineer"],"workflows":["workflow:feature-development","workflow:release-management"],"topics":["topic:accessibility"]}

Push Notifications Skill

Comprehensive push notification implementation for iOS (APNs) and Android (FCM), including rich notifications, deep linking, and background processing.

Overview

This skill provides capabilities for implementing push notifications across iOS and Android platforms, covering certificate/key configuration, notification payload design, rich media attachments, deep linking, and background notification handling.

Capabilities

APNs Configuration (iOS)

• Configure APNs certificates and keys (.p8, .p12)
• Set up App ID and push entitlements
• Configure development vs production environments
• Implement UNUserNotificationCenter delegate
• Handle notification permission requests

FCM Configuration (Android)

• Set up Firebase project and google-services.json
• Configure notification channels (Android 8.0+)
• Implement FirebaseMessagingService
• Handle FCM token registration
• Configure notification priority and visibility

Rich Notifications

• Design notification payloads with custom data
• Implement image and media attachments
• Configure notification actions and categories
• Create interactive notification buttons
• Handle notification grouping and threading

Deep Linking

• Implement notification-to-screen navigation
• Configure universal links from notifications
• Handle app state (foreground, background, terminated)
• Pass custom data through deep links
• Track notification tap attribution

Background Processing

• Handle silent/background notifications
• Implement content-available processing
• Configure background fetch capabilities
• Manage notification state persistence
• Handle notification delivery reports

Prerequisites

iOS Development

# Ensure push notification entitlement is enabled
# In Xcode: Signing & Capabilities > + Capability > Push Notifications

# APNs Key (.p8) from Apple Developer Portal
# Or APNs Certificate (.p12) - less preferred

Android Development

// build.gradle (project)
classpath 'com.google.gms:google-services:4.4.0'

// build.gradle (app)
plugins {
    id 'com.google.gms.google-services'
}

dependencies {
    implementation platform('com.google.firebase:firebase-bom:32.7.0')
    implementation 'com.google.firebase:firebase-messaging'
}

Server Requirements

# Node.js server for sending notifications
npm install firebase-admin @parse/node-apn

Usage Patterns

iOS Push Registration (SwiftUI)

import SwiftUI
import UserNotifications

@main
struct MyApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

class AppDelegate: NSObject, UIApplicationDelegate, UNUserNotificationCenterDelegate {

    func application(_ application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        UNUserNotificationCenter.current().delegate = self
        registerForPushNotifications()
        return true
    }

    func registerForPushNotifications() {
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
            guard granted else { return }
            DispatchQueue.main.async {
                UIApplication.shared.registerForRemoteNotifications()
            }
        }
    }

     ( : ,
                      : ) {
         token  deviceToken.map { (format: , ) }.joined()
        ()
        
    }

     ( : ,
                      : ) {
        ()
    }

    
     ( : ,
                                 : ,
                                 :  () -> ) {
        completionHandler([.banner, .sound, .badge])
    }

    
     ( : ,
                                 : ,
                                 :  () -> ) {
         userInfo  response.notification.request.content.userInfo
        handleNotificationTap(userInfo: userInfo)
        completionHandler()
    }

     (: [: ]) {
          deepLink  userInfo[]   {
            
            .default.post(name: .handleDeepLink, object: , userInfo: [: deepLink])
        }
    }
}

 . {
      handleDeepLink  .()
}

Android FCM Implementation (Kotlin)

import com.google.firebase.messaging.FirebaseMessagingService
import com.google.firebase.messaging.RemoteMessage
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Intent
import android.os.Build
import androidx.core.app.NotificationCompat

class MyFirebaseMessagingService : FirebaseMessagingService() {

    override fun onNewToken(token: String) {
        super.onNewToken(token)
        // Send token to your server
        sendTokenToServer(token)
    }

    override fun onMessageReceived(remoteMessage: RemoteMessage) {
        super.onMessageReceived(remoteMessage)

        // Handle data payload
        remoteMessage.data.isNotEmpty().let {
            handleDataPayload(remoteMessage.data)
        }

        // Handle notification payload (when app in foreground)
        remoteMessage.notification?.let {
            showNotification(it.title, it.body, remoteMessage.data)
        }
    }

    private fun handleDataPayload(data: Map<String, String>) {
        val deepLink = data["deep_link"]
        val customData = data[]
        
    }

      {
         channelId = 
        createNotificationChannel(channelId)

         intent = Intent(, MainActivity::.java).apply {
            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
            .forEach { (key, value) -> putExtra(key, value) }
        }

         pendingIntent = PendingIntent.getActivity(
            , , intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
        )

         notification = NotificationCompat.Builder(, channelId)
            .setSmallIcon(R.drawable.ic_notification)
            .setContentTitle(title)
            .setContentText(body)
            .setPriority(NotificationCompat.PRIORITY_HIGH)
            .setContentIntent(pendingIntent)
            .setAutoCancel()
            .build()

         notificationManager = getSystemService(NOTIFICATION_SERVICE)  NotificationManager
        notificationManager.notify(System.currentTimeMillis().toInt(), notification)
    }

      {
         (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             channel = NotificationChannel(
                channelId,
                ,
                NotificationManager.IMPORTANCE_HIGH
            ).apply {
                description = 
                enableLights()
                enableVibration()
            }

             notificationManager = getSystemService(NOTIFICATION_SERVICE)  NotificationManager
            notificationManager.createNotificationChannel(channel)
        }
    }

      {
        
    }
}

Rich Notification with Image (iOS)

import UserNotifications

class NotificationService: UNNotificationServiceExtension {

    var contentHandler: ((UNNotificationContent) -> Void)?
    var bestAttemptContent: UNMutableNotificationContent?

    override func didReceive(_ request: UNNotificationRequest,
                            withContentHandler contentHandler: @escaping (UNNotificationContent) -> Void) {
        self.contentHandler = contentHandler
        bestAttemptContent = (request.content.mutableCopy() as? UNMutableNotificationContent)

        if let bestAttemptContent = bestAttemptContent {
            // Handle rich media attachment
            if let imageURLString = request.content.userInfo["image_url"] as? String,
               let imageURL = URL(string: imageURLString) {
                downloadImage(from: imageURL) { attachment in
                    if let attachment = attachment {
                        bestAttemptContent.attachments = [attachment]
                    }
                    contentHandler(bestAttemptContent)
                }
            }  {
                contentHandler(bestAttemptContent)
            }
        }
    }

      ( : , :  (?) -> ) {
         task  .shared.downloadTask(with: url) { localURL, , error 
              localURL  localURL, error    {
                completion()
                
            }

             tmpDirectory  .default.temporaryDirectory
             tmpFile  tmpDirectory.appendingPathComponent(url.lastPathComponent)

             .default.moveItem(at: localURL, to: tmpFile)

              attachment   (identifier: , url: tmpFile, options: ) {
                completion(attachment)
            }  {
                completion()
            }
        }
        task.resume()
    }

      () {
          contentHandler  contentHandler,  bestAttemptContent  bestAttemptContent {
            contentHandler(bestAttemptContent)
        }
    }
}

Server-Side Notification Sending (Node.js)

// Using Firebase Admin SDK for FCM
const admin = require('firebase-admin');

admin.initializeApp({
  credential: admin.credential.cert(serviceAccount)
});

async function sendPushNotification(token, title, body, data) {
  const message = {
    notification: {
      title,
      body
    },
    data: {
      deep_link: data.deepLink || '',
      custom_data: JSON.stringify(data.custom || {})
    },
    android: {
      priority: 'high',
      notification: {
        channelId: 'default_channel',
        imageUrl: data.imageUrl
      }
    },
    apns: {
      payload: {
        aps: {
          'mutable-content': 1,
          sound: 'default'
        }
      },
      fcmOptions: {
        imageUrl: data.imageUrl
      }
    },
    token
  };

  try {
    const response = await admin.messaging().send(message);
    console.log('Successfully sent message:', response);
     response;
  }  (error) {
    .(, error);
     error;
  }
}


 apn = ();

 apnProvider =  apn.({
  : {
    : ,
    : ,
    : 
  },
  :  
});

  () {
   notification =  apn.();

  notification. = .(.() / ) + ;
  notification. = ;
  notification. = ;
  notification. = { title, body };
  notification. = { : data., ...data. };
  notification. = ;
  notification. = ;

   (data.) {
    notification.. = data.;
  }

   {
     result =  apnProvider.(notification, deviceToken);
    .(, result);
     result;
  }  (error) {
    .(, error);
     error;
  }
}

Integration with Babysitter SDK

Task Definition Example

const pushNotificationTask = defineTask({
  name: 'push-notification-setup',
  description: 'Configure push notifications for mobile app',

  inputs: {
    platform: { type: 'string', required: true, enum: ['ios', 'android', 'both'] },
    projectPath: { type: 'string', required: true },
    features: {
      type: 'array',
      items: { type: 'string', enum: ['rich_media', 'deep_linking', 'silent_push', 'notification_actions'] }
    }
  },

  outputs: {
    configuredPlatforms: { type: 'array' },
    tokenRegistrationCode: { type: 'string' },
    serverIntegrationGuide: { type: 'string' }
  },

  async run(inputs, taskCtx) {
    return {
      kind: 'skill',
      title: `Configure push notifications for ${inputs.platform}`,
      skill: {
        : ,
        : {
          : ,
          : inputs.,
          : inputs.,
          : inputs.
        }
      },
      : {
        : ,
        : 
      }
    };
  }
});

Notification Payload Reference

APNs Payload Structure

{
  "aps": {
    "alert": {
      "title": "New Message",
      "subtitle": "From John",
      "body": "Hey, how are you?"
    },
    "badge": 1,
    "sound": "default",
    "mutable-content": 1,
    "category": "MESSAGE_CATEGORY",
    "thread-id": "conversation-123"
  },
  "deep_link": "myapp://messages/123",
  "image_url": "https://example.com/image.jpg",
  "custom_data": {
    "message_id": "msg-456",
    "sender_id" 
  

FCM Payload Structure

{
  "message": {
    "token": "device_fcm_token",
    "notification": {
      "title": "New Message",
      "body": "Hey, how are you?",
      "image": "https://example.com/image.jpg"
    },
    "data": {
      "deep_link": "myapp://messages/123",
      "message_id": "msg-456",
      "sender_id": "user-789"
    },
    "android": {
      "priority": "high",
      "notification": {
        "channel_id": "messages",
        "tag": "message-123"
         
      
    
     
       
         
           
           
        
      
    
  

Best Practices

1. Request Permission Appropriately: Ask for notification permission at the right moment
2. Use Notification Channels: Create meaningful channels for Android 8.0+
3. Handle All App States: Test notifications in foreground, background, and terminated states
4. Implement Token Refresh: Handle FCM token refresh and APNs token changes
5. Design Clear Deep Links: Create consistent deep linking scheme
6. Test Rich Media: Verify image downloads and display
7. Monitor Delivery: Track notification delivery and tap rates

References

• Apple Push Notification Service
• Firebase Cloud Messaging
• APNs Provider API
• FCM HTTP v1 API