Renu Punjabi's Blog @renupunjabi - Tumblr Blog

Debugging in Xcode (continue)

My first post will walk you through Debugging in LLDB

******Debugging for UI issues related to Localization******

It is almost certain that the strings lengths will vary in every language. So it’s very important to make sure that your app looks right for every language.

A very handy way to doing so is -

Click on your project name -> “Edit Scheme” This will open up the scheme’s page

Select “Run” Debug configuration -> “Options” -> “Application Language” -> Pick the language of choice -> “Close”

Congrats! By doing the above steps, you just successfully converted you simulator to run in chosen language.

Now let’s take 1 step further in improving our lives. Xcode enables us to create duplicate schemes and we’ll make use of this ability to simplify our debugging efforts for localization further.

This time click on project name -> “Manage Schemes”. This will bring up the list of schemes we might have for our app.

Select the original scheme -> click on settings button at the bottom -> select “Duplicate”. This will duplicate the scheme for you - meaning, it’ll bring up the edit scheme window.

In the Edit scheme window, you can rename the scheme name to “ProjectName LanguageOfChoice” for “Run Debug” config. Change the “Application Language to the language of your choice and hit close. This will create another scheme with the appropriate name.

You can reset the original scheme to reflect system language and save.

Now when you click on project name, it’ll give you choice of running the app in original scheme or in the language of your choice (hmmmmm...... how convenient and handy it is). We just made our debugging life a bit simpler :)

In addition to above, if you edit your scheme, you’ll have several language options but keep scrolling down to explore further

Some of the options like - “Double-Length Pseudolanguage” will double your strings and you could see long text in your language to see if it broke the UI. You can also choose “Right-to-Left Pseudolanguage” which will basically reverse the language running from right to left (for certain languages like Arabic). In those cases, you can adjust your views constraints to make sure the views still look right. This is AWESOME!!!

******Main Thread Checker******

Sometimes, by mistake we may update UI on background thread. The way we can make sure to catch it is very SIMPLE :)

Click on project name -> “Edit scheme” -> “Run Debug” -> “Diagnostics” -> make sure to click “Pause on issues”. “Main Thread Checker” by default should be ON. If not turn it ON. and then close it

This will pause on the line which may be updating the UI on background thread. This way Xcode makes it very convenient for developers to catch such mistakes.

******Malloc Stack Logging******

Mallock stack logging is a very useful tool to track if we are leaking memory. Only enable this setting when you are debugging the memory leaks issues for suspicious leaking objects. The way we can turn this ON is going to “Edit schemes -> “Run Debug” -> “Diagnostics” -> “Logging” -> “Malloc Stack” -> “All allocation and Free History”.

By turning this setting ON and debugging potential memory issues on ViewController (for eg.)

Build and run fresh after making the setting.

Tap on “Debug memory Graph” button just next to “Debug View Hierarchy” button to start debugging for memory leaks.

The Left pane will look like below. Look for the number of instances of your view controller shown in brackets on side of their names.

As you can see in the above picture, for me “RestaurantsTableViewController” has 2 instances.

Click on the RestaurantsTableViewController and select the instances one by one. You should be able to see on the right pane (make sure to select the “Debug Memory Graph” tool) the stack trace of what lead to creation of double instances of RestaurantsTableVC. As you can see, you can click to the little arrow on the side of the method which will directly take you to the exact spot of the code where the memory allocation for this VC is happening.

This is how you can discover if you are creating retain cycles or initializing the VC multiple times and so on...

******Use unsafeBitCast to view properties of objects in the debug memory graph******

Sometimes, when we are debugging issues with memory leaks, we have a need to check for properties of the object to come to understand what is making things go south? Follow the below steps:

First set a break point of where you possibly will have the object under investigation is well initialized and will have all the states fully defined. Run your app and interact with the app to trigger the break point.

In my case, I wanted to debug a cell’s properties like its imageView and cuisine title label. So I put a breakpoint in didSelectCellForRowAtIndexPath(). I triggered my breakpoint by selecting a cell. So remember, it is important to have a debug session going before we can do anything.

Now click on “Debug Memory Graph” button

Click on any cell of your interest and copy the memory address like so

And type in debug console

p let $cell = unsafeBitCast(0x7fd65e0fec00, to: RestaurantCell.self)

hit enter

then on the left pane in the variables window, right click and choose “Add Expressoin”

Enter the property that you are looking to debug.

In my case, I’m looking for cuisineTypeLabel property and coverImageView property. So I added both of them.

In the Expression textfield - $cell.coverImageView.image

and similarly add another expression - $cell.cuisineTypeLabel.text

Once you’ve added the properties you are watching for you can select them and click on the eye symbol at the bottom of the left pane to view its value in a popup like so

Isn’t Xcode Awesome!!! Love it..

Debugging in LLDB (Xcode)

Note: Please note that this article is inspired by Ray Wenderlich’s podcast.

******Inspecting Variables******

“po variableName” will give you debugDescription of the variable

“p variableName” will give you the built in formatted description, same info as you would otherwise find when you dig in on the left side of the console. You can also do “”p.methodName()” to call a method on p and it will execute it. Just as you were running the method in run mode.

“c” stands for continue. If we run it, then it’ll continue the executing code in the debugger

“fr v self.modelObject.method()” - It displays an error saying it is not a member of the modelObject and so it cannot access method().

So “p” and “po” are abbreviations for an expression, which means they run code in the scope created by the debugger. They get all the advantages of the code including inferencing of self when accessing properties and things like that. But “fr v” is only inspecting properties so it is safer but more limited.

******Creating Variables******

Sometimes you want to inspect the variable and end up changing the code to see its value. You no longer have to do so.

p let label = cell.titleLabel; print(label.text!)

Also, change the setting from “debugging output” to “all output” to see the result.

You put the semi-colon to put the two swift statements in one line. If you were to put these two statements in 2 lines :

p let label = cell.titleLabel - This execution succeeds

p print(label.text!) - This fails

This is because label variable is captured in first line but it goes out of scope in second line.

Here is how to solve the above issue

p let $label = cell.titleLabel

p print(label.text!) - Label is in scope and this line succeeds

By putting a “$” sign in front of label, the debugger creates a global scope for that variable for that debug session

******Using LLDB variables between multiple break points to make them more powerful******

Problem: In a tableview, the 3rd cell is not displaying the correct data. How to pause only for the 3rd cell to investigate further.

Solution:

Declare the debug variable once in viewDidLoad method:

p var $row = 0

let it dynamically set values for the variable in cellForRowAtIndexPath():

p $row = indexPath.row

and set the condition to stop at only 3rd row by editing the break point in updateCell() or where ever you are configuring your cell:

$row == 2

******Reflect changes in UI while in debug mode without making changes in code******

Problem: You’ve received a bug report that sometimes the cell titleLabel is too close to right margin but not always.

In other words, if you for sure want a long text for the label without depending on the dataSource to hopefully provide you with some text and be able to reproduce the bug, you can create the bug yourself by providing the label with a very long text in debug mode without having to alter the real code.

Do -

p cell.titleLabel.text = “abc12345abc12345abc12345abc12345abc12345″

To reflect this change in the label in debug mode:

p CATransaction.flush()

and boom!, you just achieved a change in titleLabel text while still in debug mode. This method flushes changes to your UI.

Similarly we can also change background color of the Label to see it is too close to the right side of the screen or not and other tricks.

p cell.titleLabel.backgroundColor = UIColor.red

p CATransaction.flush()

That’s it :)

******View return values from callbacks or methods******

Problem: Say you received image from a callBack and you want to view the image. Here is how we can achieve it in Swift.

func getPlaceHolderImage() -> UIImage {

return UIImage(named: “placeholder”)

}

Place a breakpoint where is image is returned and type:

Do -

To see this image in variables pane (left pane of console), right click -> pick “Add Variable...” -> type “unsafeBitCast(”memoryLocation from above”, to: UIImage.self) and hit enter

Select the variable you just created and click on the quick look button (eye button at the bottom of this pane). This will display the image that was just returned.

******Executing a method in debug mode and stopping at breakpoints within that method******

Reasons why you want to stop at breakpoints within a method called from LLDB:

1) The method may not be returning the values you are expecting and you may want to know why?

2) You may want to manually trigger a method that may be very rarely be called and you want to manually debug it.

Set a break point in a method you want to call from LLDB. If you do -

p method()

you’ll see that the breakpoint inside the method() was not respected. In order for the debugger to stop at the breakpoint, type -

“expr -i false --method()”

Now if you run your code in debug, it’ll certainly stop the the breakpoint of your method you are trying to

NSOperationQueue VS GCD

NSOperationQueue and GCD both achieve the same thing. Meaning, both are meant to execute tasks concurrently/serially in a multi-threaded model. But they are different in performing this goal. Let’s start with how each of them work and then we’ll get into comparison of when to use which one :)

NSOperationQueue: NSOperations and NSOperationQueue are objective C classes. They are higher level of abstraction classes built on top of GCD.

Controlling the state of Operations: NSOperations can be cancelled, resumed as per our needs

Dependancy: NSOperations enable us to set up dependencies between them so that we can frame the order in which operations are executed.

Control over number of threads: NSOperationQueue allow us to specify maxNumberOfConcurrent threads that can be invoked at a given time.

Monitoring state of Operations: NSOperationQueue lets us monitor the state of operation - executing, finished, starting and so on.

GCD: It is a low level API which enables very simple task based concurrency model. Its implementation is super simple.

When to use which one:

Apple generally advices us to use NSOperationQueues since they are higher level of abstracted classes that have all the benefits of GCD. Whenever, we have tasks that needs to be monitored closely in the order we want them to run or if we have a need to cancel/resume them at any point we use NSOperationQueues. For example: Read/Write on a shared resource to avoid race conditions.

We use GCD, whenever, we don’t have to worry about logistics of what or how many tasks are being executed. When we just want to execute some block of code in background and need results from the execution, we use GCD. For Eg: Downloading image/file in background and displaying/using file contents to show them in tableView.

Found a very good Article: https://www.appcoda.com/ios-concurrency/ which gives very detailed explanation of all the little concepts involved in understanding concurrency, GCD and NSOpertionQueues. Simply Loved it!!

Hope this short note helps in clearing this complex topic to someone who is looking to glimpse over this topic.

#iOS #Swift #GCD #NSOperation #NSOperationQueue #objective c

GCD - Swift 4

GCD stands for Grand Central Dispatch. Funny name..

It simply means that it is an Apple given tool to do multithreading in our iOS apps.

We mainly have three types of queues that we can work with depending on the kind of work we need our app to do.

Below are the queues:

1) Main Queue

2) Global Queue

3) Custom Queue

We will discuss each of them below:

Main Queue - This thread is typically used for updating all UI related tasks. It is a serial queue.

In swift, the code looks like this:

DispatchQueue.main.asyc {

view.backgroundColor = UIColor.red

}

Notice, we used asyc keyword.. It means that we are asking our application to update the UI asynchronously - meaning, we don’t want to stop any other executing thread while we are updating our UI. In other words, we are saying to our app - “Dear app, just make the UI change concurrently with whatever other things you are doing. You do not need to stop the whole world for me. Just carry on but keep the updating of UI also as a high priority of tasks to do.”

2) GlobalQueue - The most common use of this type of queue is to perform background tasks in it.

Most common background tasks are - making api calls or computational work of any kind. For eg: Fetching images of the given url in background thread

Here is the code for global queues:

DispatchQueue.global().async { //fetching of images logic goes here }

There are four types of global concurrent queues provided by the system.

Quality of service (QOS) is an enum and we can use it to indicate the queue the priority in which the tasks must be executed. 1) .userInteractive - We apply this enum to queues that mainly perform UI related tasks that need to be fulfilled immediately. It should be used for small workloads that require low latency. This indicates highest priority and is carried out in main thread. 2) .userInitiated - queues that contain tasks which includes reaction to user's action are assigned this enum. It should be used when the user is waiting for immediate results, and for tasks required to continue user interaction. Tasks such as reacting to user initiated opening of a document or touch of a cell in tableview for eg. It is mapped to high priority. 3) .utility - queues with tasks that take a few seconds or minutes to complete are categorized to use this enum. This represents long-running tasks. It should be used for computations, I/O, networking, continuous data feeds and similar tasks. Tasks like downloading files, images and so on. It is mapped to low priority. 4) .background - queues with Tasks that takes minutes to hours like indexing, synching etc.. can be running with background priority. Tasks that don’t require user interaction and aren’t time-sensitive should be paced under this priority.

3) Custom queues - These are queues that are created by developer. Hence it requires manual management. Custom queues can be serial or concurrent. But it is preferred to use system queues for concurrency.

Here is the code for custom queues:

let queue = DispatchQueue(label: "com.cocoateam.serialQueue")

queue.async { //serial custom queue }

let concurrentQueue = DispatchQueue(label: "com.cocoateam.concurrentQueue", attributes: .concurrent)

concurrentQueue.async { //concurrent custom queue }

This was GCD in nutshell. More GCD and Swift stuff coming soon.

#ios #swift #multithreading #dispatchqueues #GCD #custom queues #global queues #main queue

Blocks vs Delegates vs Notifications in iOS Programming

There are two important questions that I'll try to answer in this blog which are very commonly asked in iOS developer interviews:

1) When to use Blocks vs Delegates for call backs?

2) When should you use Notifications vs Delegates?

First half of this blog will answer the first question and then we will jump to the second.

Lets start by defining Blocks and Delegates and then we will discuss when to use what?

Blocks: are self contained pieces of executable code. They are objects. Hence, they can be passed into methods.

Delegates: Delegation is handling the responsibility of execution of an event by one object to the other, thus delegating other object for that event

Eg: TableViewControllers always confirm to UITableViewDlegate. Here UITableView assigns the tableViewController as its delegate. So whenever a user selects a row of the tableView, delegate methods like didSelectRowAtIndexPath is called, our TableViewController (being a delegate of UITableView) handles the selection of row event.

When to use Blocks vs Delegates:

Prefer to use delegate pattern if an object has multiple distinct events. For example UITextField have multiple distinct events. It should tell when shouldBeginEditing, didBedingEditing, shouldEndEditing, didEndEditing, shouldReturn etc

If you are targeting to get call backs in your ViewController on several steps in a process - use Delegation. For example, the process of drawing the table in the view of viewcontroller, it needs to know the number of sections, number of rows in each sections and info to display in cell for each row. With the help of delegation design using UITableViewDataSource, the UITableView is able to communicate back and forth with ViewController.

If you are targeting the results from executing a process, use Blocks -- From Apple documentations- "Blocks are particularly useful as a callback because the block carries both the code to be executed on callback and the data needed during that execution". In other words, they are generally useful to inform the viewController whether a certain event is success or failure. For example, if you are trying to download images asynchronously in your helper classes, then the completion block in the ViewController, informs whether the download succeeded or failed. Hence the view gets updated accordingly. Here is the sample source code. Notice, that we make fetch call to get Menu Category list in MapCoordinator class and once we receive the results from processing the API request, we show the results in detail view for the selected restaurant. This is a perfect example of a process, where you are expecting a result from it in order to update your view in TableViewController. This is where blocks come in handy and are quite helpful in informing the view whether an operation is success or a failure.

Use Blocks when object is singleton as you cannot use Delegation. The reason is explained in the third point of my second half of this blog under Notification vs Delegates.

Now, here starts the second half of part of this blog. Here we will try to answer the question- "When should you use Notifications vs Delegates?"

We've already defined Delegates above. So, I'll start by giving you an overview of what do Notifications do for us.

NSNotifications: are used to notify the observer objects about completion of certain event (method/operation). Notifications is very useful as it decouples the objects (meaning, the classes do not have to know anything about each other - no inheritance or importing and they still get notified if they are the observer to a certain event in the other class).

Notifying another object about the occurrence of an event can be achieved with all of the above design patterns.

Question is - When do you use Notificatiion vs Delegates?

Delegate is used when there is mainly one class to be notified of the completion of an operation at a given time.

NSNotifications are used when there are multiple observers (classes) waiting to be notified for the completion of a certain event.

Other conditions to be considered when deciding the use of NSNotification vs Delegates:

1) If the object you are trying to communicate is unknown then NSNotification can be a better option. For Eg: Apple provided keyboard view which is not accessible for development yet it is important to be notified about its appearance and disappearance if there are custom things to be performed during those events. In such cases, notifications can be handy. Although, it has a small price to pay. The metadata about the info you are trying to pass (if any) is a form of dictionary (userInfo) which could be a little clumpsy to work with vs straight parameters data provided by delegates. But its still worth it as here you are trying to communicate between multiple classes and dealing with an unknown object.

2) Consider your object model as a tree. You may have an object B which may inherit from object A. Object C is a child of B and object D is a child of C and so on. Delegation is the answer when you have to pass data back and forth between an objects in such inheritance chains. But if you have objects which are built completely in separate parts of the object tree, then NSNotifications are the best way to convey messages to all or between the objects.

3) Delegates should only be used when the object being the delegate owns the object doing the delegation. Apple demos this by making the TableViewController the owner of UITableview where the TableViewController become the delegate of UITableView. For this reason, singletons should never have delegates because they are not the owner of any other object. They stand alone or they can be considered as child of application. If you attempt to do so, then the first object becomes its delegate but when second object assigns itself as delegate of the singleton then the previous delegation connection with first object gets overridden with the new delegation from second object without informing the first object. This way, first object never knows that its delegation link is broken and still thinks that is is the delegate of the singleton. This may break your application at some point.

To summarize -

Use delegates when the communication is between two objects.

Use Notifications when you want to communicate messages to multiple objects at the same time

Use blocks, when we need the results from the event/process/network call to do further action (generally displaying it on the UI).

#blocks #delegates #Notifications #callbacks #iOS interview Questions #iPhone developer interview Questions #iOS developer interview questions

Introduction to SpriteKit for UIKit developers

If you have developed iOS apps in the past you will enjoy the new SpriteKit framework that Apple has introduced with the iOS7 release. Here is the source code for this demo.

It is a sweet, simple framework that has everything to make your 2D game development easier:

> High performance rendering of 2d-sprites

> Animation support

> Physics engine integration

> Particle effects

> Atlas creation

> Raycasting

and many many more....

If you've ever developed using Cocos2D or Unity you will find these terms very familiar.

The easiest way to develop your knowledge about the SpriteKit framework is to understand the basic components and then apply them to a simple application.

In this project, I want to help you with integrating SpriteKit into your existing UIKit applications (eg: single view application, master detail application and so on). In order to successfully achieve the above, we'll first need to understand the basic structure of both - UIKit project and SpriteKit project.

In a typical UIKit project you would create:

- a UiViewController instance.

- As per MVC, we create UiView class separately which has all the code for creation and behavior of UI elements (labels, buttons, images).

- then the UiView is connected with the UIViewController.

Similarly, in a SpriteKit implementation you would create:

- a UiViewController instance

- a SKView and an SKScene

- this SKScene has all the UI elements (labels, buttons, images)

- then the SKView is connected with the UIViewController

The above is a screen shot from the pdf file on introduction to spritekit downloaded from WWDC videos 2013. As you can see here, UIView is the parent for SKView which in turn is responsible for presenting the SKScene class in which the creation and behavior of UI elements are defined.

Given the above info, we are now ready to start with our sample project. First, create a new project -> Single View Application

Launch the application, you will see your standard launch screen.

Nothing special about this project yet.

Next you would need to add the "SpriteKit" framework to the Project. Click your project -> Build Phases -> Link Binary With Libraries and then click the "+" button to add a framework.

Search and Add SpriteKit framework here.

Don't forget to mark it as optional. This is important if you'd like to support iOS 6.x or lower versions.

Let's say you want to display the SpritKit animation on startup. For that, we'll have to create a new class file - call it StartupScene, and inherit it from SKScene. Please note that as none of your classes has included SpriteKit.h file, SKScene will not show up as one of the existing classes while creating the StartUpScene. So, go ahead an fully type it and include it in your project.

Once, created the StartUpScene class, you'll see this error

This is because, we've not yet imported the SpriteKit.h file. So go ahead and import the required file here and this error will be resolved.

Let's edit the file (StartupScene.m) now and add a simple label to it.

@implementation StartupScene

-(id)initWithSize:(CGSize)size {

if (self = [super initWithSize:size]) {

/* Setup your scene here */

self.backgroundColor = [SKColor colorWithRed:0.15 green:0.15 blue:0.3 alpha:1.0];

// Create a simple label here - this is the equivalent of UILabel

SKLabelNode *myLabel = [SKLabelNode labelNodeWithFontNamed:@"Chalkduster"];

myLabel.text = @"Hello, World!";

myLabel.fontSize = 30;

myLabel.position = CGPointMake(CGRectGetMidX(self.frame),

CGRectGetMidY(self.frame));

[self addChild:myLabel];

}

return self;

}

Next, let's hookup this scene with our view controller (ViewController.m)

The key component we want to introduce in the view controller is an instance of SKView. An SKView inherits from UIView and it has all the basic building blocks that we have in a UIView object.

Here are a few custom edits you might want to do to connect the SKView our ViewController

- (void)viewDidLoad

{

[super viewDidLoad];

//Creating an instance of SKView

SKView * skView = [[SKView alloc] initWithFrame:CGRectMake(0, 0, 600, 600)];

//Setting frames per second property to be true

skView.showsFPS = YES;

//Setting count nodes property to be true because we want to know the number of nodes on the screen at any given time

skView.showsNodeCount = YES;

// Create and configure the scene.

SKScene * scene = [StartUpScene sceneWithSize:skView.bounds.size];

//SKSceneScaleModeAspectFill will make sure that your scene is scaled properly in all orientations

scene.scaleMode = SKSceneScaleModeAspectFill;

//Making the view controllers view a skview

self.view = skView;

// Present the scene.

[skView presentScene:scene];

}

That completes all the connections we wanted to create between the various classes. Let's summarize what we've completed so far.

StartupScene.m

- Inherits from SKScene

- Creates background color

- Has a SKLabelNode -- that is used to display text on screen

ViewController.m

- Inherits from UIViewController

- Has an instance of SkView

- Has an instance of SKScene (of StartupScene)

- The SKView instance presents the SKScene instance

Now you can run your application and it will display a sweet SpriteKit label on the screen.

Now, let's return back to our StartupScene.m and add some more logic to it. This time we want to introduce a basic interaction. We want a spaceship to appear in the scene as soon as a user touches the screen. The logic below will create that effect.

-(void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {

// Called when a touch begins

for (UITouch *touch in touches) {

CGPoint location = [touch locationInNode:self];

SKSpriteNode *sprite = [SKSpriteNode spriteNodeWithImageNamed:@"Spaceship"];

sprite.position = location;

SKAction *action = [SKAction rotateByAngle:M_PI duration:1];

[sprite runAction:[SKAction repeatActionForever:action]];

[self addChild:sprite];

}

Now, let's run the project and see what happens.

Just remember one thing. If you are still building apps for iOS 6.x then you might want to enclose the SpriteKit classes under the iOS 7 conditional logic.

Enjoy !!!

#sprite kit #objective C #UIKit #ios 7 #game programming

What are Hash Tables?

When data elements are stored in specific table locations based on a certain mathematical function(hash function) it is called hash tables. The benefit of storing data in such a table is that it will optimize the time for that search. In iOS NSDictionary class is an implementation of a hash table.

Imagine you have millions of books that you want to arrange in shelves of a library. There are different ways to do it but the traditional way is to arrange them in alphabetical ordered shelves. This way of arrangement would not only

a) make search for the book be quicker/faster - O(1) operation

b) But efficient meaning you dont have to look through all the books in the library to find that one book - avoid O(n) operation

c) Or Take a binary search approach which will be a O(log n) operations.

Thus just like the example above, hash tables are a type of data structures which will usually complete a lookup after just one comparison! Sometimes, however, two comparisons (or even more) are needed. A hash table thus delivers (almost) the ideal lookup time. The trade-off is that to get this great lookup time memory space is wasted. This may well be a good trade-off, however, as memory is cheap.

Hash Functions: The function used to calculate the location to store the record/data for each given key is called a hash function.

With reference to the arrangement of books in the library, There are different ways to arrange these books.

1) Alphabetical approach

2) Binary Search arrangement approach

3) Make a formula to calculate the location of the book -

A B C D E F G H I J K L M N O P Q R

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

S T U V W X Y Z

19 20 21 22 23 24 25 26

Let's say you want to store a book named "BAT MAN"

Let's compute the hash value of the book title using the position of the alphabet.

Therefore, BAT MAN = 2 + 1 + 20 + 13 + 1 + 14 = 51

Hence the book BAT MAN will go in shelf # 51.

The title of the book "BAT MAN" will be used to create the key and the hash value will be used to determine the location of the book. Hence, the chosen approach is called the Hash Function which produces the location where the record is stored in the Hash Table.

Grand Central Dispatch

What is Grand Central Dispatch?

Grand Central Dispatch (GCD) comprises of runtime libraries, that provide comprehensive improvements for concurrent code execution. It is a system wide load balancing technology that Apple has created to improve performance of the OS as a whole

How GCD works?

GCD uses blocks and series of dispatch queues to break parallel tasks down into small chunks and balance them across multiple cores. Basically, it extends the concepts of NSOperationQueues to entire system and any application that uses GCD benefits from having its load scaled down on whole OS depending on the resources available.

Dispatch Queues:

As its name suggests, its a queue of tasks to be executed. There are two types of dispatch queues: Serial Dispatch Queues which executes only one task at a time and other tasks wait until the running task finishes. Other type is Concurrent Dispatch queues which doesn't wait. It starts/runs all the tasks at the same time.

Working with Dispatch Queues

There are two ways to access dispatch queues:

1) Creating dispatch queues

2) Using main/global dispatch_queues

I will discuss each approach in details below:

dispatch_queue_create (Custom Threads)

We can create Serial or Concurrent types of dispatch queues depending on our requirements.

Below is the code to create a Serial dispatch queue:

dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.renupunjabi.gcdBasics", NULL);

here "mySerialDispatchQueue" is the name of our custom queue. And it takes two parameters. According to recommendation by Apple, the first parameter is where your company name goes in reverse order following what the task is about (This will be helpful while debugging because it will make sense what the code under debugging is about) and the second argument is where we put NULL.

Below is the code to create Concurrent dispatch queue

dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.renupunjabi.gcdBasics", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(myConcurrentDispatchQueue, ^{ NSLog( @" This is a concurrent dispatch queue"} );

here, the parameters are same except the second argument which is not NULL.

dispatch_async is another important command which actually is a "START" command to execute/run a thread.

Every queue that is created has to be released. A queue is not treated like an object in Objective C and so the programmer has to make sure to release it by calling dispatch_release when done using it.

dispatch_release(myConcurrentDispatchQueue);

This means, if the queues are created, then they should be managed according to the same rules of managing reference counting.

Here is a Lynda.com video which demonstrates where and when do we use dispatch queues.

Main/Global Dispatch Queue

System provides us with two types of dispatch queues which we dont have to create.

The Main dispatch queue as its name suggests, is a queue to execute on main thread. Usually, we use this thread to update the user interface of our application. This job should not be done on the Global (concurrent) thread.

Global dispatch queues are concurrent queues that can be used anywhere in the application. These queues can also be used instead of creating our own custom queues. XNU kernel manages the reference counting of system provided queues and so we don't have to worry about retaining or releasing them. Additionally, it also makes sure to balance the load at OS level. Hence this is one of the reasons why we should use global queues over creating concurrent queues.

Another benefit of using GCD is that it cuts down a lot of code that you may otherwise write when using NSOperations, NSOperationsQueue or manually manage threads yourself

Global queues are of four types based on their priorities: high, low, default, background.

Here is the source code which demonstrates the use of custom queues, main and global queues.

How Delegates work in Objective C

Delegates:

In Objective-C, messages are delivered only one way. The traditional way of communication is from parent class to child class. The other way communication from child class is not possible. This is where delegates are extremely useful.

UIScrollView and UITableView use delegates routinely to communicate between the model, view, and controller. There are many reasons why the delegate pattern is useful. A delegate might be used to make an object reusable, to provide a flexible way to send messages, or to implement customization.

Project Background:

In this project, we will animate the movement of a UIView across the screen and get a response back from the animation class using our custom delegate. This will demonstrate how to use delegates to make the two way communication possible between two classes.

So let's get started...

The flow will be between these two classes: ViewController <-> AnimationManager

Create new Project

Create a new Single View Application.

Creating an outlet of UIView in the .xib file:

In the .xib file drag a UIView into it.

Divide the screen to show the .xib file and the viewcontroller.h file simultaneously.

Ctrl +click on the small view and drag it in the ViewController.m file.

Name the view smallPinkView

Making Delegate Protocol methods:

Create a new class called AnimationManager - File > New > File > Objective C > Next. Type AnimationManager as the class name and inherit it from UIVIew. Click next and save it in the project.

Make a custom delegate called "AnimationDelegate" in AnimationManager.h class by writing the code below:

@protocol AnimationDelegate

-(void)animationCompleted;

@end

Create a property of AimationDelegate in AnimationManager.h

@property (nonatomic, weak) id <AnimationDelegate> animDelegate;

Notice that the type of ivar is id. This will allow it to accept any object type. Another thing to note is that AnimationDelegate gives an access to all the protocol methods to whatever object is assigned to animDelegate.

Get automatic setters and getters by synthesizing the property animDelegate in AnimationManager.m file

@synthesize animDelegate;

Quick recall: So until this point we've created our custom delegate and a property instance of AnimationDelegate. Now we will make connections between viewController and AnimationManager class so that the two classes can send messages to each other via delegate.

In ViewController.h file, import AnimationManager.h file. Let ViewController implement AnimationDelegate like this:

@interface ViewController : UIViewController <AnimationDelegate>

Make an IBAction on moveButton and outlet for statusLabel in ViewController.h

Here is where the main show begins.

First make an instance "animObj" of AnimationManager class in viewDidLoad method in ViewController.m file. Now the important part - assign ViewController to animationDelegate object of AnimationManager class like this:

animObj.animDelegate = self;

By writing the above line, the AnimationDelegate's method (animationCompleted) that is implemented in the ViewController class will be called once the animation completes.

So, now the viewDidLoad method looks like this:

- (void)viewDidLoad

{

[super viewDidLoad];

self.statusLabel.text = @" ";

animObj = [[AnimationManager alloc] init];

animObj.animDelegate = self;

}

So now when the user clicks the button to perform animation we will call startAnimationForView method in the moveButton method of the ViewController.m file like this:

- (IBAction)moveButton: (id)sender {

[animObj startAnimationForView:self.smallPinkView];

}

We also want to get notified in ViewController class about the completion of the animation movement of the smallView. For this, we will implement the animationCompleted method of AnimationDelegate in the ViewController class.

-(void) animationCompleted {

self.statusLabel.text = @"Done";

}

The above method is called at the completion of animation in AnimationManager.m class as shown below:

-(void)startAnimationForView:(UIView *)smallView {

[UIView animateWithDuration:1.0f animations:^{

smallView.frame = CGRectMake(0,0, smallView.frame.size.width, smallView.frame.size.height);

} completion:^(BOOL finished) {

[UIView animateWithDuration:1.0 animations:^{

smallView.frame = CGRectMake(320- smallView.frame.size.width, 460 - smallView.frame.size.height, smallView.frame.size.width, smallView.frame.size.height);

}completion:^(BOOL finished) {

[self.animDelegate animationCompleted];

}];

}

Notice that in the completion block, animationCompleted method is called by animDelegate property of AnimationManager class. This object is actually the ViewController object which we assigned in viewDidLoad method of ViewController class - animObj.animDelegate = self;

Target achieved - AnimationDelegate makes it possible for AnimationManager class to send messages back to ViewController.

TO SUMMARIZE

In ViewController.h

ViewController <AnimationDelegate>

viewDidLoad {

animManagerObj.animationDelegate = self; //Here we are assigning viewController to animationDelegate instance of AnimationManager class.

}

movebuttonpressed {

[animMgr startAnimationForView:myView]; // Calling a method in AnimationManager class

}

animationCompleted {

label.text = "Done";

}

In AnimationManager.m

startAnimationForView:myView {

//Do Animation

// On completion

[ self.animationDelegate animationCompleted ]; // Here self.animationDelegate is actually viewController object. So with viewController object we are calling a method in that class.

}

Let me know if this post was useful. I've also added the source code in github for downloads. Here is the link: https://github.com/renup/custom-delegate-renup

Trending Blogs

Recently Viewed Blogs

Renu Punjabi's Blog