MVC and importing UIKit - ios

Question

I know this seems like a simple question but if I #import <UIKit/UIKit.h> into a class file is this breaking the MVC rule?
The reason I ask is I set up a class that has a function to make an API call. Inside of that API function I want to use the dispatch_async method to get the data back to the main thread and want to call [tableView reload] inside of that dispatch_async method.
To do this I need to have access to the UITableView class so when I call my function I can pass in my tableView. Sorry still somewhat new to all of this.
Thanks!

Answer 1

First of all, MVC is a design pattern, and not a set of rules. It is a way of organizing code so that the view (and how to represent it) is totally decoupled from the model/application.
Secondly, you are correct in saying that importing the viewController file in the class that makes the API calls (let's call it API Class) is against the principles of MVC.
But you can make the view update in the viewController class itself! Instead of importing the ViewController class into the API class, you can do the absolute reverse and use the API class from the View Controller class. There are a lot of ways that classes can communicate with each other while conforming to the MVC pattern. Have a look at this article on the website objc.io which talks about the same.
Have a look at AFNetworking, an extremely popular networking library for applications written in Objective-C. It makes excellent use of objective-c blocks, and the same is recommended for your use case as well.
For example, your class for making the API call can look like this:
//APICall.h
#interface APICall : NSObject
-(void)makeAPICallWithHandler:(void(^)(NSError*, id data))handler;
#end
//APICall.m
#import "APICall.h"
#implementation APICall
-(void)makeAPICallWithHandler:(void(^)(NSError*, id data))handler
{
NSError *err;
id data;
//Make your API call and then pass the result in the handler
if (err)
{
handler(err, nil);
return;
}
handler(nil, data);
}
#end
The above method can be implemented by the view controller as follows:
//ViewController.m
#import "ViewController.h"
#import "APIClass.h"
#implementation ViewController
{
APIClass *api;
id displayData;
__weak IBOutlet UITableView *tableView;
}
-(void)viewDidLoad
{
[super viewDidLoad];
api = [APICall new];
[api makeAPICallWithHandler:^(NSError* error, id data) {
if (error)
{
//Show alert or something
return;
}
displayData = data;
[tableView reloadData];
}];
}
#end
The point is that using blocks, you can make the data from the API call available to the viewController which can then update the tableView and maintain it's data source. This conforms to MVC as you will have totally decoupled the view update from the actual API call.