A Custom Screen Appears When You Long-Press a Notification in a Rork Max App — Implementing a Notification Content Extension

The Content Extension target and its Info.plist

In the project Rork Max generated, add a Notification Content Extension target in Xcode (File → New → Target → Notification Content Extension). What it creates is a single UIViewController and a dedicated Info.plist.

What matters are the four keys under NSExtensionAttributes in that Info.plist. Misread their meaning and the layout breaks.

What cost me a full day at first was forgetting that last one, UserInteractionEnabled, and landing in the "I placed a button but it does nothing" state. The template does not always include it, so plan to add it by hand.

Drawing the UI on expand

The view controller conforms to the UNNotificationContentExtension protocol and draws by receiving the notification in didReceive(_:). Here it shows the image the Service Extension attached and the title for the day.

import UIKit
import UserNotifications
import UserNotificationsUI
 
final class NotificationViewController: UIViewController, UNNotificationContentExtension {
 
    private let imageView = UIImageView()
    private let titleLabel = UILabel()
    private let statusLabel = UILabel()
 
    override func viewDidLoad() {
        super.viewDidLoad()
 
        imageView.contentMode = .scaleAspectFill
        imageView.clipsToBounds = true
        imageView.layer.cornerRadius = 12
        titleLabel.font = .preferredFont(forTextStyle: .headline)
        statusLabel.font = .preferredFont(forTextStyle: .footnote)
        statusLabel.textColor = .secondaryLabel
 
        let stack = UIStackView(arrangedSubviews: [imageView, titleLabel, statusLabel])
        stack.axis = .vertical
        stack.spacing = 8
        stack.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(stack)
 
        NSLayoutConstraint.activate([
            stack.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
            stack.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),
            stack.topAnchor.constraint(equalTo: view.topAnchor, constant: 16),
            stack.bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: -16),
            imageView.heightAnchor.constraint(equalTo: imageView.widthAnchor, multiplier: 0.66)
        ])
    }
 
    func didReceive(_ notification: UNNotification) {
        let content = notification.request.content
        titleLabel.text = content.title
 
        // Read the image the Service Extension attached
        if let attachment = content.attachments.first,
           attachment.url.startAccessingSecurityScopedResource() {
            defer { attachment.url.stopAccessingSecurityScopedResource() }
            imageView.image = UIImage(contentsOfFile: attachment.url.path)
        }
 
        // Reflect whether this was already saved, via the App Group
        statusLabel.text = SharedStore.isSaved(id: content.threadIdentifier)
            ? "Saved" : "Save it from the notification"
    }
}

If you want to build it in SwiftUI, host a UIHostingController as a child inside this NotificationViewController and the look can lean on SwiftUI. While the layout is simple I leave it in UIKit, and switch to SwiftUI once it grows complex — that is the progression I use.

Tapping a button without dismissing the notification

This is the most interesting part of the Content Extension. When the user taps "Save," I want to change the display to "Saved" right there without closing the notification. What makes that possible is how you return from didReceive(_ response:completionHandler:).

extension NotificationViewController {
    func didReceive(
        _ response: UNNotificationResponse,
        completionHandler completion: @escaping (UNNotificationContentExtensionResponseOption) -> Void
    ) {
        let id = response.notification.request.content.threadIdentifier
 
        switch response.actionIdentifier {
        case "SAVE_PICK":
            SharedStore.markSaved(id: id)        // write to the App Group
            statusLabel.text = "Saved"
            completion(.doNotDismiss)             // ← keep it open, update the UI
 
        case "SHUFFLE_PICK":
            completion(.dismissAndForwardAction)  // hand off to the main app
 
        default:
            completion(.dismiss)
        }
    }
}

Returning completion(.doNotDismiss) keeps the notification open, and the update to statusLabel stays on screen. Leave it at .dismiss and the save still happens, but the notification closes before the display changes — a confusing bug that looks like "it isn't working." I hit it in production.

Sharing "Save" with the main app

A state saved from the notification should also be reflected when the user opens the main app. The Content Extension and the main app are separate processes, so writing to UserDefaults.standard alone is invisible to the other side. This is where an App Group comes in.

In Xcode's Signing & Capabilities, add the same App Group (for example group.net.rorklab.dailypick) to both the main app and the Content Extension, then go through the shared suite.

enum SharedStore {
    private static let suite = UserDefaults(suiteName: "group.net.rorklab.dailypick")!
 
    static func markSaved(id: String) {
        var ids = suite.stringArray(forKey: "savedIDs") ?? []
        if !ids.contains(id) { ids.append(id) }
        suite.set(ids, forKey: "savedIDs")
    }
 
    static func isSaved(id: String) -> Bool {
        (suite.stringArray(forKey: "savedIDs") ?? []).contains(id)
    }
}

If the suiteName string does not match across both targets, only the writer knows the state and the main app never sees it. I once got burned here by forgetting the group. prefix. To share the image itself, drop the file into the shared container you get from FileManager's containerURL(forSecurityApplicationGroupIdentifier:).

Six places to look when nothing shows

When the custom UI does not appear, the cause is almost always in a fixed set of places. I check them in this order every time.

1. Category mismatch — Are the main app's UNNotificationCategory, the payload's category, and the Info.plist's UNNotificationExtensionCategory an exact match? This is the most frequent cause
2. The notification wasn't expanded — A banner stays in the standard layout. Long-press or pull down to expand and check
3. UserInteractionEnabled is false — Buttons that won't respond are nearly always this
4. Memory limit — The Content Extension process is tightly memory-constrained and crashes on oversized images. Prepare a downscaled display image on the Service Extension side to be safe
5. Forgot to return completion — Not calling completion in didReceive(_ response:) freezes the UI
6. App Group suiteName drift — A save not reflected in the main app is this

Why this becomes a reason to choose Rork Max

Drawing your own screen inside a notification and responding to a button there on the spot assumes a "native-side structure": adding a separate extension target and tying it to the main app through an App Group. In the React Native (Expo) approach of building cross-platform quickly, reaching into this layer is hard work.

Put the other way, if your app is fine making the user tap through to open the main app, standard Rork is plenty. Only when you decide there's value in finishing inside the notification, in the expanded experience itself, does moving to Rork Max — which generates native Swift — start to make sense. In my own operation, I measure that line by asking "is there value in completing this inside the notification?"

Try one thing first: line up UNNotificationExtensionCategory with the main app and the payload. The moment the password clicks, your own card slides quietly into the notification.