Let delegates run in other than main thread - swift

Question

I am generally wondering how to let swift delegates run in a dedicated thread other than the main thread.
More specifically, I am currently using the HueSDK4EDK to establish a connection of my app to a Hue bridge. Part of the process is to define state observers and connection observers (as delegates) to handle incoming events.
private func buildBridge(withBridge bridge : BridgeInfoModel) -> PHSBridge {
return PHSBridge.init(block: { (builder) in
...
builder?.bridgeConnectionObserver = self
builder?.add(self)
}, withAppName: AppBundleName, withDeviceName: DeviceName)
}
The delegates are implemented in extensions, such as the connection observer:
extension HueApiManager : PHSBridgeConnectionObserver {
func bridgeConnection(_ bridgeConnection: PHSBridgeConnection!, handle connectionEvent: PHSBridgeConnectionEvent) {
...
}
}
Since some code within the connection observer may be time intensive, I am wondering if there is a more elegant way than this:
func bridgeConnection(_ bridgeConnection: PHSBridgeConnection!, handle connectionEvent: PHSBridgeConnectionEvent) {
let apiThread = DispatchQueue.global(qos: .utility)
apiThread.async {
...
}
}
Thanks a lot!

Answer 1

Yes:
let apiThread = DispatchQueue.global(qos: .utility)
func bridgeConnection(_ bridgeConnection: PHSBridgeConnection!, handle connectionEvent: PHSBridgeConnectionEvent) {
apiQueue.async {
...
}
}
There's no reason to fetch the queue every time; you can just store it as a property.
I know this isn't what you're thinking of, but it is the best approach. Just perform the dispatch when you need it.
It is possible to build something like what you're actually thinking of in ObjC using forwardInvocation:, but it doesn't translate well into Swift (the underlying machinery can't be implemented in Swift), and I don't recommend it. A trampoline is an object (sometimes an NSProxy object) that can accept any message, do something with it (like move it to another queue), and then redispatch it to another object. The problem is that it's hard to tell the complier "trust me, this will implement every method you need at runtime" (because you can't actually promise that, so it might crash). Even in ObjC, these often wound up being more trouble than they were worth, and the only reason they were worth the trouble in the first place is ObjC didn't always have GCD or blocks, and when blocks were added, the syntax was a headache. In Swift, it's much simpler. Just add the .async call.
Just to show what a trampoline looks like, though, here's what one would look like that uses an operation queue (very similar to a dispatch queue). This is written in pre-ARC ObjC and shouldn't be read as an example of modern ObjC.
#import <Foundation/Foundation.h>
#interface OperationQueueInvocationTrampoline : NSObject
{
#private
NSOperationQueue *myQueue;
id myTarget;
}
- (id)initWithQueue:(NSOperationQueue *)queue;
#end
#import "OperationQueueInvocationTrampoline.h"
#interface OperationQueueInvocationTrampoline ()
#property (nonatomic, readwrite, retain) NSOperationQueue *queue;
#property (nonatomic, readwrite, assign) id target;
#end
#implementation OperationQueueInvocationTrampoline
#synthesize queue = myQueue;
#synthesize target = myTarget;
- (id)initWithQueue:(NSOperationQueue *)queue
{
self = [super init];
if (self != nil)
{
self.queue = queue;
}
return self;
}
- (void)dealloc
{
[myQueue release];
myQueue = nil;
myTarget = nil;
[super dealloc];
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector
{
return [self.target methodSignatureForSelector:selector];
}
- (void)forwardInvocation:(NSInvocation *)invocation
{
[invocation setTarget:self.target];
self.target = nil;
NSOperation *operation = [[[NSInvocationOperation alloc] initWithInvocation:invocation] autorelease];
[self.queue addOperation:operation];
}
- (id)prepareWithInvocationTarget:(id)target
{
self.target = target;
return self;
}
#end
You'd use it like this:
id delegate = [[OperationQueueInvocationTrampoline alloc] initWithTarget:self];
[otherThing setDelegate:delegate];
This worked pretty well back when most protocols were informal (so there was no type-checking here, and you could just pass id), but it's gotten messier and messier to make this compile without warnings, and it would definitely be a headache in Swift today. It's have to save a lot of trouble, and it doesn't.
(Side note: queues are not the same thing as threads. The issue at hand is what queue things are dispatched to, not what thread they run on.)

Answer 2

I don't think this is possible unless that library specifically supports it.
One thing you could do is create a "proxy" delegate class that forwards all delegate method calls on a specific DispatchQueue.
It's not a perfect solution, but at least you can keep your HueApiManager a bit cleaner because you do not need apiThread.async everywhere.
class DelegateProxy: PHSBridgeConnectionObserver {
weak var delegate: PHSBridgeConnectionObserver?
var queue = DispatchQueue.global(qos: .utility)
func bridgeConnection(_ bridgeConnection: PHSBridgeConnection!, handle connectionEvent: PHSBridgeConnectionEvent) {
queue.async {
delegate?.bridgeConnection(bridgeConnection, handle: connectionEvent)
}
}
// Other delegate methods...
}