Inability to Implement `UNUserNotificationCenterDelegate` due to Silent Failure with `ctypes`-based IMPs

[onasipim]

Describe the bug

Problem Description

Implementing the UNUserNotificationCenterDelegate in pure Python using rubicon-objc appears to be impossible due to a silent failure where the delegate methods are never invoked by iOS. This occurs even when the delegate class is correctly configured with valid method signatures, protocol conformance, and returns True for respondsToSelector_.

Investigation and Findings

My goal was to create a pure Python delegate for handling iOS notifications. I discovered that the UNUserNotificationCenterDelegate methods require completion handlers with extended block type encodings (e.g., @?"v@?Q"), which are not supported by the standard objc_block decorator.
To address this, I developed a patch for rubicon-objc that successfully adds support for these extended signatures. Runtime diagnostics confirm that my patch correctly registers the delegate methods with the exact type encodings required by the UserNotifications framework:

Selector: userNotificationCenter:willPresentNotification:withCompletionHandler:
  - Method Encoding: v@:@@@?"v@?Q"
Selector: userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler:
  - Method Encoding: v@:@@@?"v@?"

Despite this verifiable success in setting up the delegate, the methods are never called by iOS. No errors or warnings are produced.

Core Limitation and Hypothesis

This leads me to believe that the issue is not with the method signature itself, but with the Method Implementation Pointer (IMP) that rubicon-objc generates from the Python callback via ctypes.
I hypothesize that the modern UserNotifications framework performs a validation check on the IMP and is rejecting the kind of function pointer that ctypes provides. Simpler, older delegate patterns (like those for camera or location) work correctly, suggesting this is a requirement specific to newer, security-sensitive iOS frameworks.

Conclusion and Question

It appears there is a fundamental limitation in using ctypes-based IMPs for certain modern iOS delegate patterns. While a native Objective-C shim is a viable workaround, it defeats the purpose of a pure Python implementation.
Is this a known limitation of rubicon-objc? Is there any potential path forward to make ctypes-generated IMPs compatible with frameworks like UserNotifications, or is this an architectural boundary that cannot be crossed without changes to the core bridging mechanism?

Steps to reproduce

Expected behavior

Screenshots

No response

Environment

• Python version: 3.13
• Software versions:
  • Briefcase: 0.3.25
  • Toga: 0.5.2

Logs

Additional context

No response

[freakboy3742]

I haven't tried UNUserNotificationCenterDelegate specifically, but I can't see anything in the definition of userNotificationCenter:willPresentNotification:withCompletionHandler: or userNotificationCenter:didReceiveNotificationResponse:withCompletionHandler: that would cause a problem for Rubicon.

Toga (one of the main consumers of Rubicon) has several examples of "on completion" handlers. For example, the Camera API in Toga uses AVCaptureDevice requestAccessForMediaType: completionHandler:, which has a very similar prototype to the completion handler to the Notification Center API.

However - one detail of note (and one that I can't provide any specific advice on) - Does Notification Center require any special app permissions? If your app doesn't declare and request the appropriate permissions to accept Notification Center callbacks, then failure might manifest as "silent failure" - that's not uncommon with permissions-related faults.

Without more specific details about what you're doing (including a minimal reproduction case), it's difficult to provide any advice beyond that.