Currently, the App Store has about 1.8 million available applications and in this Bundle we all want our application to stand out. Don’t we?

Rule number 1: Your app should consume less memory, which would result in faster and better user experience.

Apple provides great tools along with Xcode for profiling the app.
Today,we will discuss memory leaks in iOS apps and how to find and fix them.

Let us begin our story of memory leaks.

OH! Firstly, let me introduce you to The Protagonist, Spider-Man, our iOS developer, who works passionately, striving to achieve the best possible solution.

One day, Spider-Man was given the task of developing a simple application. Wherein, he had to show a list of images, and upon clicking of any image, the user should navigate to show the image in fullscreen.

Spiderman, our brilliant developer started coding and built the app within a mere 3 hours. But, Spidey was worried, wondering if he traded quality for speed. Unhappy with the development, as every time he would open the app and navigate to screen of different images, he could see a significant spike in memory.

When he launched the application he could see the memory usages at 25MB.

After 2 mins of usage and navigation through different images, the statistics were as follows:

Spidey was now perplexed, as to what was causing the jump in the memory. But, being a talented developer he knew the glitch is a memory leak, somewhere but didn’t know how to find the exact location of the leak in the project.

Spidey calls his mentor, IRON MAN. I mean, What is it that Iron Man can’t take care of.
Iron Man, suggested him to use profiling to find out the memory leak and busily hung up the phone. ( you know where)

Spidey losing patience as he wanted to solve the leak as soon as possible.

After 5 mins of panicking, he decides upon finding a solution. He remembered the word “Profiling” used by Iron Man, and started searching for Profiling in Xcode where he found Profile under the Product menu. The shortcut to Profile is Cmd + I.

Before we jump to profiling, let’s look at the code written by Spidey.

Download the starter project from :
https://github.com/mukulm24/iOSMemoryLeakDemo

Go ahead and run the project and follow the steps :

• Select an avenger from the list of avengers

• Click on any item to view the avenger image.

• Repeat these steps for around 40–50 times.

After doing the above steps, you will observe that the memory usage is increasing continuously, as we saw in the beginning.

Coming back to Spidey, he has already found the profile option under the Product menu. He came across the following screen with multiple options

As Spidey knew there was an issue with memory leak, he decided to select Allocations. INSTRUMENTS opened up with the below page

The red button on left looks tempting, let’s go ahead and press that.

Spidey starts using the app as he was testing before.

Spidey can see a spike in memory and is stuck at the same place, the question of leak locations still persists.
He calls up his mentor Iron Man again, and Iron Man replies with “Spidey! Check the CALL TREES option there”

The ground rule is pop the view controller, and observe the memory allocation. The popped view controller should no longer be listed. If you still see it, then you have a memory leak!

Spidey goes ahead and finds the call trees under after clicking on Statistics

He sees 26.29 MB (80%) used, goes down the tree to find the exact location by expanding it and following with the highest bytes used.

Spidey can see many system calls are there which are not useful for the purpose. He decided to hide those calls from a list by checking the option as shown in the below screenshot

There we go, now we are left with only a few traces.

He goes and inspects the elements with most reference counts, and, double click opens up the given file.

If you now repeatedly push and pop the leaking view controller, then you will see that the Persistent will increase. That is a count of the number of that object in memory.

As the UIImage unit had the problem, We clearly have an idea about where the problem lies.

Completely unexpected, Iron Man is here. Spidey is now looking forward to some advanced profiling.

Iron man appreciates Spidey but also suggests that he needs to find the exact location of the leak. For that move to ‘Statistics’ and search for your view controller whose push/pop is increasing the memory. Spidey goes ahead and searches for ‘AvengersDetailViewController’ and double clicks on it.

In real time, you can go and push/pop the view controllers and see new instances are created and not released, which means that there is a memory leak. On pop of the view, the view controller should get deallocated.

There were multiple instances created and none of them were released.
Finding the exact memory leak reference is difficult as ARC only keeps the count of references and not the information about the referenced objects.

Select unpaired for better required result set.
Now, Iron Man needs to find where the leak is by eliminating all the UIKit system responsible callers for whom the release is not present. He found it with the responsible caller AvengerDetailViewController.setupView(with:).

This is our responsible function, he has narrowed Spidey’s leak search to the function where the leak is taking place.
Now, it’s Spidey’s job to find the leak in the function

Spidey looks closely at the function setupView

He is not sure about the image view and tries and goes to find out the declaration of delegate.

There it is, our smarty Spidey has found that delegate is strong by default making the strong reference cycle between self (detail view controller) and image view.

So the delegate needs to be assigned as weak to solve the problem of the memory leak.

But as the variable is declared as Any?, it throws an error
‘weak’ must not be applied to non-class-bound ‘Any’; consider adding a protocol conformance that has a class bound.

So Spidey went ahead and made the change:

EUREKA!!!

Spidey is now celebrating, doing the Spidey dance. Post changes, the app runs as smooth as his web.He observes the memory graph shows no spike even with continuous usage!

Spidey treats Iron Man and makes sure that he profiles every controller after development to eliminate the chances of memory leak.

Codable protocol not just helps you with JSON encoding and decoding but if we look at it from a broader perspective it lets you convert the objects to data and reverse. Later, you can choose how you want your data to be serialized or deserialized, it can be property lists or JSON without worrying about losing the value types.

Let’s go ahead and dive in to the code and understand how can Codable help us.

I have been trying to rent an appartment for a long time now. So we’ll revolve around appartments and addresses in our sample codes.

Let’s create our first model Apartment which will have details about building name it’s rent and address.

Many people prefer using Class to create models but since I won’t be using inheritance over here and using structs is light weight compared to classes. We will go ahead using struct in the sample. Though using Class would not be a problem; Codable protocol works with both Struct and Class.

As you can see, apartment has a property named address which can be defined as follows.

Most of you might have a question in your head that can we create nested JSON objects/arrays after implementing codable. The answer is a big YES. To understand the same we have created a property named address which is another codable implemented struct.

THE ENCODER

Let’s now go ahead and initialise them

With NSCoding you had to write encoding decoding methods, may be create layers to take care of it, all of these were error prone and a tedious task to handle.

We’ll go ahead and convert the created apartment to data object and encode it to JSON.

The below function is the crux of converting the object to JSON. Depending on your requirement you can either choose to return JSON String or JSON encoded data.

You can create the following function as extensions or add it to the struct itself. It completely depends on how you want to design your application. For better understanding, I have used a generalised function definition.

We will not get into the error handling part as this blog is more about understanding the use of Codable protocol. If you wish you can make changes in the code and use the try catch block more efficiently.

We can call the above function as follows on the ‘oxfordApt’ object we created above.

let jsonAptDetails = convertToJSON(apartmentInfo: oxfordApt)

The log for the above is :

Yes. That’s it. You have successfully converted your model object to JSON without going through the hassle of encoding or even assigning the values manually.

THE DECODER

Another thing that we are going to look at is Decoding the JSON objects. Previously when codable didn’t exist in our lives we had to manually parse the JSON or use some sort of library to do the task for us but with codable if you design your model in such a way that it’s in sync with JSON used as it’s data source the hard work will be drastically reduced and the code’s performance will be improved.

Let’s just go ahead and convert a JSON data to it’s corresponding model object.

For sample purpose’s let’s just create a sample JSON String corresponding to our Apartment struct.

Now we’’ll create our decoder function as follows:

The above function can be called as follows where aptJSONString is the sample JSON string we created above.

let bravuriaApt = self.decodingJSONToApartment(aptJSON: aptJSONString)

The log for above :

BINGO! Another task of converting JSON to it’s corresponding model object has been successfully completed. Again without any hassle of parsing or writing lines of code.

NOTE: If you don’t have a JSON string but a JSON data object you can skip the part of converting JSON string to data and directly jump to JSONDeocder().
If Using Alamofire and response is expected in JSON format, we get JSON data as response. Hence we can directly use it instead and not use the conversion of JSON string to data.

We are done here! Questions and queries are most welcome. I have shared the link to the GIT project if you want to go ahead and play with values and try it yourself. Go ahead.

The code is written in a way to make a beginner understand, I would recommend adding the functions to helper classes or extensions when using in actual project. This is just a stub to get a feel of how things work with Codable protocol.

mukulm24/CodableDemo