CODEWITHSUNDEEP
iosobjective-ccoding-style
Ignazio
Ignazio

Reputation: 4904

Which pattern to update interface using background thread?

I'm looking for a common and elegant way to manage interfaces update. I know that user interface code must be run in main thread, so when i need some computation o network task i use GDC with this pattern:

dispatch_queue_t aQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_async(aQueue, ^() {

//Backgroud code

    dispatch_sync(dispatch_get_main_queue(), ^{
    //Update the UI
    }
}

The problem with this code is that i need always check if user has changed view during my computation, so the code is like:

dispatch_sync(dispatch_get_main_queue(), ^{
    if (mylabel != nil)  && ([mylabel superview] != nil) {
        mylabel.text = _result_from_computation_;
    }
}

There is some best ways?

Thanks.

Upvotes: 2

Views: 379

Answers (2)

Alex Smith
Alex Smith

Reputation: 468

You pretty well have it. However, in case you want to do more reading or want a more thorough explanation of what's going on...

You should read the Apple Docs Grand Central Dispatch (GCD) Reference and watch the WWDC 2012 video, Session 712 - Asynchronous Design Patters with Blocks, GCD and XPC.

If you're working with iOS, you can disregard XPC (interprocess communication) as it's not supported by the current OS version (6.1 at the time of this writing).

Example: Load a large image in the background and set the image when completed.

@interface MyClass ()
@property (strong) dispatch_block_t task;
@end

@implementation MyClass
- (void)viewDidLoad {
    self.task = ^{
        // Background Thread, i.e., your task
        NSImage *image = [[NSImage alloc] initWithData:data];
        dispatch_async(dispatch_get_main_queue(), ^{
            // Main Thread, setting the loaded image
            [view setImage:image];
        });
    });
}

- (IBAction)cancelTaskButtonClick:(id)sender {  // This can be -viewWillDisappear
    self.task = nil;  // Cancels this enqueued item in default global queue
}

- (IBAction)runTaskButtonClick:(id)sender {
    // Main Thread
    dispatch_queue_t queue;
    queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(queue, self.task);
}

In order to cancel and reload the interface later, all you have to do is set the dispatch_block_t variable to nil.

Perhaps more specifically to your problem, this example piece of code deals with Reading Data from a Descriptor, i.e., either the disk or network.

Typically, you would use the Call-Callback pattern which essentially gets a background thread, executes a task, and when completed calls another block to get the main thread to update the UI.

Hope this helps!

Upvotes: 1

Yariv Nissim
Yariv Nissim

Reputation: 13343

You can check the view window property:

if (myLabel.window) {
  // update label
}

this is redundant if (label != nil) since if label is nil, then all label properties will also be nil (or zero) and setting them will not raise an exception.

Upvotes: 0

Related Questions