Hacking Block Support Into UIMenuItem
tl;dr: UIMenuItem! Blocks! Get the code on GitHub.
While developing a new version of PSPDFKit, I started using UIMenuController more and more. The first thing you’ll notice is that it’s different from your typical target/action pattern, in that the target is missing:
This is actually pretty genius, in part. iOS checks if the @selector can be invoked calling
canPerformAction:withSender:, which is part of UIResponder. If the object returns NO, the system walks up the UIResponder chain until it finds an object that returns YES or
nextResponder returns nil.
A typical responder chain looks like this: UIView -> UIViewController -> UINavigationController -> UIApplication -> AppDelegate.
Now this is great in theory. For example, if you implement
copy: on your viewController, the firstResponder can be any subview and it still works. In practice, however, I found this more limiting and annoying. And I’m not the only one.
Especially if your menus get more complex, your code is littered with selectors. So let’s write a block-based subclass. Enter PSMenuItem:
1 2 3
My naive approach was to just use one common selector internally and execute the block that is saved in the PSMenuItem subclass. The only problem:
(id)sender of the action gets called with the UIMenuController. This is wrong on so many levels, especially since UIMenuController is a singleton anyway. There’s no easy way to know what UIMenuItem has been pressed.
But since I was already committed to writing the subclass, that couldn’t stop me. We just create a unique selector for each UIMenuItem, and catch execution at a lower level.
Enter Cocoa’s Message Forwarding
If the runtime can’t find a selector on the current class, message forwarding is started. (That’s the tech that allows classes like NSUndoManager or NSProxy.)
Lazy method resolution:
resolveInstanceMethod:is called. If this returns YES, message sending is restarted, as the system assumes that the method has been added at runtime. We could theoretically use this and add a method that calls the block at runtime. But this would pollute the object with many new methods – not what we want.
Fast forwarding path:
-(id)forwardingTargetForSelector:(SEL)selhas been added in Leopard as a faster approach to the NSInvocation-based message forwarding. We could use this to react to our custom selector, but we would have to return an object that implements our selector (or does not throw an exception with undefined methods.) Possible candidate, but there’s something better.
Normal forwarding path: This is the “classic” message forwarding that has existed since the old days. And actually, two methods are called here:
methodSignatureForSelector:, followed by
forwardInvocation:. (The method signature is needed to build the NSInvocation.) PSMenuItem hooks into both of those methods. But let’s go step by step through PSMenuItem’s
1 2 3 4 5
Note the @synchronized; swizzling is not threadsafe. Also, we add an @autoreleasepool here, as this could be executed from +load or +initialize at a very early time when there’s no default NSAutoreleasePool in place yet.
class_isMetaClass checks if
object_getClass returns a class or a metaclass. This is needed because “object” can both be an instance of a class or a class object itself, and you can’t just invoke an isKindOfClass on a Class object. If you’re wondering what a metaclass is, it’s basically a class that defines methods available on the class. CocoaWithLove has a great article on that.
1 2 3 4 5 6 7 8 9 10 11 12
Here we test if the class has already been swizzled by us with using
class_getInstanceMethod. Again, because object might be a Class already, we can’t just use
respondsToSelector:. Next, we test if we should add a handler to
canBecomeFirstResponder. This is needed to make the UIMenuController display in the first place.
imp_implementationWithBlock. This is a new method in iOS 4.3 upward, but has a much nicer syntax and is more compact than classic C functions. There’s another small annoyance:
PSPDFBlockImplCast. The syntax of
imp_implementationWithBlock was slightly changed in yet-to-be released versions of Xcode. Older versions still need the
(__bridge void *) cast; newer versions will complain and only work without.
PSPDFReplaceMethod is a helper that first adds the new method via our pspdf_ selector name, then swizzles the original implementation with our custom implementation:
1 2 3 4 5 6
Next up, we swizzle
canPerformAction:withSender:. This is called before the UIMenuController is displayed. If we detect our custom selector (
PSIsMenuItemSelector), we return YES, else we call the original implementation. Note the tricky casting on
objc_msgSend. (We could also build an NSInvocation, but that would be much slower and needs much more code).
PSIsMenuItemSelector is just shorthand for
return [NSStringFromSelector(selector) hasPrefix:kMenuItemTrailer];:
1 2 3 4 5 6 7 8 9 10
Next, we arrive at the method that’s called during message forwarding, when the user selects a UIMenuItem. We again check for the selector and return a faked
NSMethodSignature. If we wouldn’t return a signature here, we’d get a selector not implemented exception.
"v@:@" is the selector encoding for
-(void)action:(id)sender. v is the return type (void), the first @ is self, the : is the selector (_cmd), the @ finally is id sender. You can learn more on Apple Developer about objc type encodings.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
Finally, the last piece. After
methodSignatureForSelector returns a valid NSMethodSignature, the system builds an NSInvocation object that we can handle (or not). Here we load the selector, loop through all menuItems in the UIMenuController, and finally call the block on the PSMenuItem, if found. Note that we could also extract UIMenuController from the NSInvocation itself, but since it’s a singleton, there’s no need for that.
One simple piece remains. We build up the custom selector in our
1 2 3 4 5 6
I’ve even used a UUID to allow menu items with the same title; they otherwise would generate the same selector and would potentially call the wrong block.
Also, thanks to Mike Ash for his great Friday Q&A about Objective-C Message Forwarding.