Android Auto is a technology that enables seamless interaction between your Android smartphone and your car’s infotainment system. In this blog post, you’ll learn about the inner workings of Android Auto, and how to add this support to an Android app.

large_meta-logo-on-blue.png

medium_meta-logo-on-blue.png

small_meta-logo-on-blue.png

thumbnail_meta-logo-on-blue.png

meta-logo-on-blue.png

Developing Apps for Android Auto | Blog | Raja Software Labs

Android Auto is a technology that enables seamless interaction between your Android smartphone and your car’s infotainment system. In this blog post, you’ll learn about the inner workings of Android Auto, and how to add this support to an Android app.

Developing Apps for Android Auto

large_blog-developing-ios-apps-for-apple-carplay-hero-image.webp

medium_blog-developing-ios-apps-for-apple-carplay-hero-image.webp

small_blog-developing-ios-apps-for-apple-carplay-hero-image.webp

thumbnail_blog-developing-ios-apps-for-apple-carplay-hero-image.webp

blog-developing-ios-apps-for-apple-carplay-hero-image.webp

CarPlay enables safely using an iPhone in a car via its infotainment system. This blog post will teach you how to add CarPlay support to an iOS app. Along the way, we will also discuss how the CarPlay technology works under the hood.

Developing iOS Apps for Apple CarPlay | Blog | Raja Software Labs

CarPlay enables safely using an iPhone in a car via its infotainment system. This blog post will teach you how to add CarPlay support to an iOS app. Along the way, we will also discuss how the CarPlay technology works under the hood.

Developing iOS Apps for Apple CarPlay

This article offers a peek into the world of Prompt Engineering — a skill that will help you to communicate effectively with Generative AI tools and enable you to harness their full potential.

Prompts: Communicating Effectively with Generative AI | Blog | Raja Software Labs

This article offers a peek into the world of Prompt Engineering — a skill that will help you to communicate effectively with Generative AI tools and enable you to harness their full potential.

Prompts: Communicating Effectively with Generative AI

medium_blog_speed_up_your_app_launch_hero_image.jpg

small_blog_speed_up_your_app_launch_hero_image.jpg

thumbnail_blog_speed_up_your_app_launch_hero_image.jpg

blog_speed_up_your_app_launch_hero_image.jpg

A slow launching app is frustrating for users and developers alike. In this blog, we will delve into factors that might be causing slow app launch. We will also discuss different strategies to fix them.

large_blog-speed-up-your-app-launch-meta-image.jpg

medium_blog-speed-up-your-app-launch-meta-image.jpg

small_blog-speed-up-your-app-launch-meta-image.jpg

thumbnail_blog-speed-up-your-app-launch-meta-image.jpg

blog-speed-up-your-app-launch-meta-image.jpg

Speed Up Your App Launch: Techniques to Reduce Startup Time | Blog | Raja Software Labs

A slow launching app is frustrating for users and developers alike. In this blog, we will delve into factors that might be causing slow app launch. We will also discuss different strategies to fix them.

Speed Up Your App Launch: Techniques to Reduce Startup Time

In your development journey, oftentimes you will be faced with problems where the underlying code is quite complex, the issue involves multiple threads that are timing sensitive, and you could use a little extra help from the debugging tools to help you track down the issue. Some of the challenges you may encounter involve:
<ul>
<li>You are debugging a complex multi-threading problem and lose track of how different threads are working and the interaction between them.</li>
<li>You want to analyze a particular flow of code using a debugger but the breakpoints are executed through other flows as well, causing confusion.</li>
<li>You are using logs to create a story of how things are working but you do not have access to edit the library code to add any meaningful logs.</li>
<li>You want to observe the exact message queued on the main thread, but the debug window does not give an easy way to view the handler object at run-time.</li>
</ul>
Well, the Android Debugger provides a lot of advanced functionality to help in such scenarios — features like customized breakpoints, switching threads, tracing, evaluating objects/variables and many more. In this blog, we are going to cover a few Debugger features which will make your life easy and save a lot of debugging time and effort.
LET’S GET STARTED
<h2 id="breakpoint-customizations">Breakpoint customizations</h2>
Generally, developers use Breakpoints heavily in various parts of the flow to understand how the code runs — by adding it at a line, method, field, or exception. This causes the breakpoint to hit every time the path is executed. But oftentimes, the intent of a developer is to have a breakpoint only in specific conditions, or for a specific purpose. That is where the customized breakpoints such as conditional, dependent, and logging breakpoints come into play.
Let's understand them one by one.
<h3 id="conditional-breakpoints">Conditional breakpoints</h3>
Let’s assume, you have a loop which runs through 1 to 10000 numbers, and it has a bug which is observed only when the number is multiple of 100. To debug this bug, if you add a normal breakpoint inside the loop then that breakpoint will hit 10000 times, which would be quite frustrating.
Conditional breakpoints are a form of rescue when we are only interested in the code-path in a particular scenario.
In this scenario, you could add a condition to your normal breakpoint which will ensure it hits only when the loop is iterating with a multiple of 100. Refer below screen to customize your normal breakpoint to act as a “Conditional breakpoint”.
<figure>
 <img src="/uploads/1_01_conditional_breakpoint_bd4134ef1e.png" alt="Conditional Breakpoint">
 <figcaption>Fig. Conditional breakpoint</figcaption>
</figure>
Though Conditional breakpoint is quite useful, there is also a pitfall that you should be aware of. Even though it seems that the application does not stop at a breakpoint whose condition has not met, the debugger temporarily suspends the application while evaluating the condition. For most of the normal cases, this pause can be ignored. However, in multithreaded applications, such a pause can lead to change the order in which threads are dispatched.
<h3 id="dependent-breakpoints">Dependent breakpoints</h3>
We usually have functionalities / screens in our app that can get triggered from different code paths. Oftentimes we only want to debug a particular code-path — and not get the breakpoints to hit for other code paths.
For instance, let’s say your app has refresh screen functionality which fetches the latest data after every 2 mins. This refresh screen functionality can also get invoked manually by using a “Refresh” button click.
In such a case, let's consider your app has a bug which is only observed when you refresh the screen on button click. While debugging this issue, it could happen that the refresh screen function gets executed multiple times after each 2 mins and that would disturb your debugging session.
To avoid the unnecessary pauses due to automatic invocation of refresh screen functionality, you can add two breakpoints:
<ul>
<li>First, at “Refresh” button’s click listener.</li>
<li>Second, in the “refreshScreen()” method.</li>
</ul>
Then, you can customize the second breakpoint to be “dependent” on the first breakpoint.
You can refer below screens to understand how to add a “Dependent breakpoint”.
<figure>
 <img src="/uploads/1_02_dependent_breakpoint_code_aed62f86c2.png" alt="An image showing that a breakpoint at line 59 is dependent on a breakpoint at line 62">
 <figcaption>Fig. Image shows breakpoint at line 59 is dependent on breakpoint at line 62</figcaption>
</figure>
<figure>
 <img src="/uploads/1_03_dependent_breakpoint_0fca8975f0.png" alt="Dependent breakpoint">
 <figcaption>Fig. Dependent breakpoint</figcaption>
</figure>
<h3 id="logging-breakpoints">Logging breakpoints</h3>
While debugging the code, you might have faced a situation where you wish you could have a log that would help you to debug the suspected code block better. This might happen very often, which would waste your lot of time in just adding the logs, rebuilding the app and debugging it again.
We understand how painful and frustrating it is to rebuild an app multiple times while debugging a single bug. No more worries — Logging breakpoint is here to rescue!
We can customize the normal breakpoint and add a log which will then act as a “Logging breakpoint” and log the message when the breakpoint is hit.
To customize a breakpoint, right click on it and in the customize window add the log that you wanted to print under the “Evaluate and Log” option. You can also choose to show the “breakpoint hit” message and stack trace in the log.
<figure>
 <img src="/uploads/1_04_logging_breakpoint_ed0f1574c2.png" alt="">
 <figcaption>Fig. Logging breakpoint</figcaption>
</figure>
You can see the logs output in the “Console” of the debug window.
<figure>
 <img src="/uploads/1_05_logged_value_447a5bdb89.png" alt="">
 <figcaption>Fig. Debug window console</figcaption>
</figure>
You can also use this in the library (where you cannot edit code) and log the details that you need, which we feel is quite awesome.
Note: All this logging can be done without suspending the application at the breakpoint. To do so, uncheck the “Suspend” option from the above customization window.
<figure>
 <img src="/uploads/1_06_disable_suspend_c3179c59d0.png" alt="">
 <figcaption>Fig. Disable suspend</figcaption>
</figure>
<h3 id="suspending-single-thread-vs-all-thread">Suspending single thread vs all thread</h3>
<img src="/uploads/1_07_suspend_thread_f6bee5301c.png" alt="Suspend Thread">
By default, all threads are suspended when breakpoint is hit but suspending a single thread is quite useful while debugging threading issues such as race conditions. You can check out this good <a href="https://www.jetbrains.com/help/idea/detect-concurrency-issues.html" target="_blank" rel="nofollow">example</a> of pausing the single thread to debug the race condition.
<h2 id="debug-window-features">Debug Window features</h2>
We often see developers not using the full feature sets of the Debug window provided by the debugging tool. Debug window gives many easy ways to analyze and customize the data you are working with. Let us explore some of them. If you are new to debugging do check out <a href="https://www.jetbrains.com/help/idea/debug-tool-window.html" target="_blank" rel="nofollow">debug window</a> documentation.
<h3 id="update-variable-value">Update variable value</h3>
Let's say you have an enum value that controls your screen, and you are facing a bug which is observed only for one of those enum inputs — you need to figure out which one. In this case, manually debugging all the enum-values by going through different code paths is quite time consuming. Here what developers might do is to force the value by mocking it and iterating (involves code changes). But a rather smarter way is to update the variable in the debug window and execute the code.
To update the value, right click on the variable and select the “Set value” option and you can easily go through the different enum inputs now.
<figure>
 <img src="/uploads/2_01_update_value_b1bea8c8f8.png" alt="">
 <figcaption>Fig. Update variable</figcaption>
</figure>
<h3 id="pinning-the-important-object-properties">Pinning the Important object properties</h3>
Debug window shows objects with all its fields — a lot of them are not useful for debugging. In such a case, if you want to focus on any particular field of the object, you can use the “pin to top” feature which will help you to show the field at the top of the fields list.
One of the best use cases, in our experience, of pinning properties is to pin the "next" property on Handler messages to know when your message is being queued.
To pin the property, right click on the property and select the “Pin to top” option. Now, observe that it will be shown at the start of the object.
<figure>
 <img src="/uploads/2_02_before_pinning_44e623380c.png" alt="">
 <figcaption>Fig. Before pinning properties</figcaption>
</figure>
<figure>
 <img src="/uploads/2_03_after_pinning_93f37f83de.png" alt="">
 <figcaption>Fig. After pinning properties</figcaption>
</figure>
<h3 id="watches">Watches</h3>
All the variables and objects in the current context are already shown in the variables tab, but what if you want to keep track of an expression value? For instance, in the sorting function, how do you analyze the value of the “i + 1” expression in an ongoing loop? To analyze and keep track of such and many more complex expressions you can add your own watch — which will then be shown in the debug window along with other variables / objects it already shows.
<figure>
 <img src="/uploads/2_04_add_watch_d3d57c1d91.png" alt="">
 <figcaption>Fig. Watches</figcaption>
</figure>
<h3 id="track-objects-throughout-the-debugger-session">Track Objects throughout the Debugger session</h3>
The debug window only shows the variables / objects that are present in the current debugging context. For instance, when you switch screens in your application, the variables from the previous module are not shown in the debug window (even if they are in memory).
There can be scenarios where you would be interested to track the value of that object for your bug use-case / conditional breakpoint / watcher. You can achieve that by marking your object and it will get highlighted in any part of the debug window.
To Mark an object, right click on the object shown in the variables window and select the “Mark object” option. It will then ask you a label to show for this object and you can add any label of your choice. Label is just to quickly identify the object — it's optional.
<figure>
 <img src="/uploads/2_05_mark_object_ef1fd0add3.png" alt="">
 <figcaption>Fig. Mark and Label object</figcaption>
</figure>
<h3 id="switch-between-threads-and-get-thread-dump">Switch between threads and get thread dump</h3>
In a multithreaded environment, it becomes quite important to analyze different threads at same time. It is often important to analyze the call stack of the different threads if you found any issue in one of the thread executions. For both these requirements the debug window provides options to switch between threads and get thread dump.
<figure>
 <img src="/uploads/2_06_switch_threads_8383e9cb7d.png" alt="">
 <figcaption>Fig. Switch threads and get thread dump</figcaption>
</figure>
<h3 id="evaluating-expressions">Evaluating expressions</h3>
Watches are useful to keep track of specific expressions or objects for a long run path. But if your requirement is to evaluate the expression just for the current use case, then use “evaluate expressions” functionality. With “evaluate expressions”, you can freely analyze the result of complex expressions and multi-line code which will give the evaluation when you run it.
<figure>
 <img src="/uploads/2_07_evaluate_expression_c44e456efe.png" alt="">
 <figcaption>Fig. Evaluate expression</figcaption>
</figure>
<h3 id="smart-step-into">Smart Step Into</h3>
<figure>
 <img src="/uploads/2_08_step_into_option_1e9991bad0.png" alt="">
 <figcaption>Fig. Step into option</figcaption>
</figure>
We would already know about Step into option, which helps to take you inside a method present on the current execution line. But there are often times when a single line has multiple methods inline (think chained factory methods), which is where “Smart Step Into” comes into play.
To use this option, follow below steps:
<ul>
<li>Go to the Android studio “Run” menu option.</li>
<li>Select “Debugging options -> Smart Step Into” option.</li>
<li>Click on the method which you want to step into from the line.</li>
</ul>
<h3 id="force-run-to-cursor">Force run to cursor</h3>
“Force run to cursor” will ignore all the breakpoints between the current execution point and the current cursor line and pauses on the cursor line.
This is especially useful when there are hundreds of breakpoints in your code, which happens often, but you want the debugger to continue execution until the current code cursor point is executed.
To use this option, go to “Run -> Debugging options -> Force run to cursor”.
<h3 id="reset-frame">Reset frame</h3>
This is a fancy option — but do use with diligence.
Say you mistakenly stepped too far or wanted to re-enter into a method where you missed to debug some critical code block. If you didn’t know about “Reset Frame”, you would start the debugging session again to debug the missed method. Rebuilding and debugging each time when you miss the method can be time consuming.
By using the “Reset frame” option, it helps to undo the last frame and restore the previous frame in the stack.
<figure>
 <img src="/uploads/2_09_reset_frames_5ed68cb628.png" alt="">
 <figcaption>Fig. Reset frame option</figcaption>
</figure>
In the below example, the reset frame will take you back to line 57 as if “withEntryPoint()” were never called.
<img src="/uploads/2_10_reset_frames_code_06e7579b0c.png" alt="Reset Frames Code">
Note, the changes that were made to the global states will not get reverted when you reset the frame, only local states will be reverted. Means, if “withEntryPoint()” updates any global state and then you reset the frame, then the global state updates will not get reverted which could lead to some weird behavior or crashes. So be aware when using this option!
<h2 id="wrapping-up">Wrapping up</h2>
Debugging is hard. A lot of times knowing the right tools helps you think and approach a problem in the right direction. We hope the above features of customized breakpoints and the debug window will help you fix those hard problems. There are multiple other features in Android debugger like “Tracing current stream chain”, Force returning from method or throw exception from method, Force step into/over which, although we did not cover here, have great use cases as well. Do check them out on <a href="https://www.jetbrains.com/help/idea/debugging-code.html" target="_blank" rel="nofollow">JetBrains documentation</a> and official <a href="https://developer.android.com/studio/debug" target="_blank" rel="nofollow">Android documentation</a>.
Thank you for reading!

Solving tricky problems like multithreading issues, library bugs or a rare scenario crash is hard. Unlock the full potential of Android studio debugger and leverage it to debug tricky problems with advanced features like customized breakpoints, threads handling, tracing, evaluating objects/variables. Let’s Dive!

Leveraging the Android Debugger to Debug Tricky Issues | Blog | Raja Software Labs

Solving tricky problems like multithreading issues, library bugs or a rare scenario crash is hard. Unlock the full potential of Android studio debugger and leverage it to debug tricky problems with advanced features like customized breakpoints, threads handling, tracing, evaluating objects/variables. Let’s Dive!

Leveraging the Android Debugger to Debug Tricky Issues

Let’s peek under the hood of the Xcode build system and understand the steps it performs to build an app. Along the way, let’s also discover some internal tools the build system uses to perform these steps.

A Peek Into the Xcode Build System | Blog | Raja Software Labs

Let’s peek under the hood of the Xcode build system and understand the steps it performs to build an app. Along the way, let’s also discover some internal tools the build system uses to perform these steps.

A Peek Into the Xcode Build System

As developers, we constantly strive to unlock the potential of our applications and deliver seamless performance to our users. In this blog, we will dive deep into Xcode Instruments and its suite of performance profiling and debugging tools to help achieve that.

Using Xcode Instruments to Optimize App Performance | Blog | Raja Software Labs

As developers, we constantly strive to unlock the potential of our applications and deliver seamless performance to our users. In this blog, we will dive deep into Xcode Instruments and its suite of performance profiling and debugging tools to help achieve that.

Using Xcode Instruments to Optimize App Performance

I was recently working on an application which required me to display an animation which scales a <code>UIView</code> down to zero. The approach I took was to apply a <code>CGAffineTransform</code> (with scale factor set to zero) to the <code>UIView</code> in a <code>UIView.animate()</code> block. However, when I implemented this, the view did not animate but just disappeared from the UI. The problem turned out to be something which is not really obvious from the iOS docs and hence I decided to write up this post in the hope that it will help others.
This is the behaviour I wanted to implement:
<img src="/uploads/demo_blog_post_expected_animation_df1bfd743f.gif" alt="demo-blog-post-expected-animation.gif">
This is the code I initially wrote up to do this:
<pre><code class="hljs language-swift">let someView = UIView()
let scaleTransform = CGAffineTransform(scaleX: 0, y: 0)
UIView.animate(withDuration: 3.0, animations: {
 view.transform = scaleTransform
})
</code></pre>
Here is the actual result of the above code on iOS 12.0 (quick note — this seems to behave differently on different iOS versions):
<img src="/uploads/demo_blog_post_actual_buggy_animation_cb3e1d8bee.gif" alt="demo-blog-post-actual-buggy-animation.gif">
This is an intriguing problem since, based on the iOS docs, this should have worked. After digging into this by creating a sample app and reading up on some “Affine Transform” math, I was able to track down the root cause.
For the impatient, here is a quick explanation of the root cause and a potential solution (a more detailed explanation follows this):
<ol>
<li>To perform a <code>CGAffineTransform</code> animation, iOS first decomposes both, the <code>scaleTransform</code> matrix and the current <code>UIView</code> transform (lets call this <code>currentTransform</code> which in our case is the identity transform) into its constituents — scale, shear, rotate and translate.</li>
<li>It then interpolates over each of these values from the <code>currentTransform</code> to <code>scaleTransform</code>, internally creating a new <code>CGAffineTransform</code> for each animation frame.</li>
<li>Finally, it applies these generated transforms to the UIView at the required frame rate to display the animation.</li>
<li>The root cause of our problem lies with the math to decompose a <code>CGAffineTransform</code> matrix. If the scale factor is zero, the math involved tries to divide by zero (which is undefined / infinity) and, as a result, the iOS animation behaves unpredictably.</li>
</ol>
A potential solution (and the one I used in my implementation) was to use a really small but non-zero value for the scale factor (e.g. <code>0.001</code>) and then set the <code>UIView.isHidden = true</code> when the animation completes so that the view is completely hidden from the UI.
<h2 id="detailed-explanation">Detailed explanation:</h2>
Let us now move on to a more detailed explanation on why iOS decomposes the <code>CGAffineTransform</code> matrix, the math used to do this and how that leads to a problem.
A quick recap of the <code>CGAffineTransform</code> matrix and <code>UIView.animate()</code> methods:
<h2 id="cgaffinetransform-matrix">CGAffineTransform matrix</h2>
The <code>CGAffineTransform</code> is a 3x3 matrix where <code>a</code>, <code>b</code>, <code>c</code>, <code>d</code> together define the scale, shear and rotation while <code>tx</code> and <code>ty</code> define translation. Of these, specifically, <code>a</code> and <code>d</code> play a part in defining the scale (refer below image). This is how a standard <code>CGAffineTransform</code> matrix looks like:
<img src="/uploads/demo_blog_post_matrix_4488d30fcd.webp" alt="demo-blog-post-matrix.webp">
By default, the <code>UIView.transform</code> property is set to an identity matrix (<code>CGAffineTransform.identity</code>) and applying any of scale / shear / rotate / translate operations basically involves multiplying this identity matrix with the required matrix.
<h2 id="uiviewanimate">UIView.animate()</h2>
<code>UIView.animate()</code> interpolates values for the animated properties from the initial value (i.e. value before animation) to the final value and applies this to the UIView for each animation frame over the specified duration. For example, the following code will interpolate <code>x</code> and <code>y</code> from 0 to 10 and keep applying it to the <code>someView.center</code> property at the required frame rate so that the user sees the <code>someView</code> animate to the new position over a duration of 3 seconds.
<pre><code class="hljs language-swift">let someView = UIView()
someView.center = CGPoint(x: 0, y: 0)
UIView.animate(withDuration: 3.0, animations: {
 someView.center = CGPoint(x: 10, y: 10)
})
</code></pre>
With this information, consider the original (buggy) code snippet (which animates the <code>UIView.transform</code> property). At face value, it is easy to assume that the iOS animation will just interpolate the identity matrix <code>[[1,0,0], [0,1,0], [0,0,1]]</code> (<code>initialTransform</code>) to <code>[[0,0,0], [0,0,0], [0,0,1]]</code> (<code>scaleTransform</code>) by interpolating each value of the matrix. Something like:
<img src="/uploads/demo_blog_post_interpolation_7e461cc84c.webp" alt="demo-blog-post-interpolation.webp">
CGAffineTransform animation interpolation assumption
To test if that is what actually happens, I put together a sample iOS application. This application uses a <code>CGAffineTransform</code> to rotate a <code>UIView</code> (I used rotation in the sample since the problem with our assumption is clearly demonstrated with this). The sample application works as follows:
<ol>
<li>Tapping on the “Run UIView animation” button runs the iOS animation to rotate the image by 160 degrees by generating a <code>CGAffineTransform</code> rotation matrix and applying it in a <code>UIView</code> animation block. (The intention is to understand how iOS internally does this).</li>
<li>Moving “Affine Transform Matrix Interpolation” slider generates intermediate matrices by interpolating each value of the matrix (similar to the what we discussed in the assumption) from the identity transform to a 160 degree rotation transform and applies it to the image.</li>
<li>Moving the “Angle Interpolation” slider generates intermediate matrices by interpolating over the angle (0 to 160 degrees) and apples it to the image.</li>
</ol>
This is how the sample application works:
<img src="/uploads/demo_blog_post_interpolation_24eb9cb518.gif" alt="demo-blog-post-interpolation.gif">
Notice that the intermediate frames in the actual iOS animation generated by tapping the “Run UIView animation” button look the same as the ones generated by “Angle Interpolation” where as those generated by interpolating each value of the <code>CGAffineTransform</code> matrix looks different and is not the expected behaviour. For this reason, when animating the <code>UIView.transform</code> property, iOS actually: decomposes the initial <code>CGAffineTransform</code> into its components values (scale, shear, rotation, translation etc.), then interpolates over each of these values, constructs a new <code>CGAffineTransform</code> matrix for each animation frame and applies it to the <code>UIView.transform</code> property.
Now, to debug further, lets look at the math used for decomposing the <code>CGAffineTransform</code> matrix. The math below is for the case when we scale, shear and rotate (in that order). Also, we can ignore translation (tx, ty) for this example since those values do not impact scale / shear / rotate.
<img src="/uploads/demo_blog_post_math_4864f11bf8.webp" alt="demo-blog-post-math.webp">
This means, the iOS SDK needs to divide by <code>a</code> to calculate the rotation angle and the shear factor. Now, If <code>s</code> (i.e. scale) is zero, <code>a</code> becomes zero (refer #1 above) and produces undefined results. As a result, the matrix decomposition fails and the iOS animation system produces unpredictable results.
Now, that we have the root cause, let us move on to the solution. To display a animation where the <code>UIView</code> needs to be scaled to zero, I suggest the following:
<ol>
<li>Using a very small but non-zero scale factor when creating the final <code>CGAffineTransform</code> for the animation.</li>
<li>On completion of the animation, setting the <code>UIView.isHidden</code> property to <code>true</code> so the UIView is hidden from the user.</li>
</ol>
In my case, I was able to make the animation work as expected by using a scale factor of <code>0.001</code> (i.e. <code>CGAffineTransform(scaleX: 0.001, y: 0.001)</code>). To see how this looks in an iOS app, please check the “expected behaviour” GIF which is the very first image in this post.
Wrapping up: in this post, we discussed how the internal workings of <code>UIView.animation()</code> and the math to decompose a <code>CGAffineTransform</code> matrix together lead to the “scale to zero” animation to fail unpredictably on iOS. We also discussed a potential solution / work around for this problem.
Thanks for taking the time to read this post. Hope you found it interesting and that it helps others facing a similar problem.
Happy coding!
References:
<ol>
<li><a href="https://developer.apple.com/documentation/coregraphics/cgaffinetransform" target="_blank" rel="nofollow">CGAffineTransform</a></li>
<li><a href="https://stackoverflow.com/questions/25964224/cgaffinetransformscale-not-working-with-zero-scale/25966733#25966733" target="_blank" rel="nofollow">CGAffineTransformScale not working with zero scale</a></li>
<li><a href="https://math.stackexchange.com/questions/612006/decomposing-an-affine-transformation/614807#614807" target="_blank" rel="nofollow">Decomposing an Affine transformation</a></li>
</ol>

Scaling a UIView down to 0 using CGAffineTransform results in unpredictable behavior on iOS. Read on to understand the basic animation math, root cause analysis and a quick fix to the problem.

Debugging CGAffineTransform Scale to Zero Animations on iOS | Blog | Raja Software Labs

Scaling a <code>UIView</code> down to 0 using <code>CGAffineTransform</code> results in unpredictable behavior on iOS. Read on to understand the basic animation math, root cause analysis and a quick fix to the problem.

Debugging CGAffineTransform Scale to Zero Animations on iOS

If you are an iOS developer, at one point or another you will run into an <code>EXC_BAD_ACCESS</code> crash. If you have already tried enabling <code>NSZombie</code> without any luck (thus ruling out memory problems / dangling pointers), a potential cause could be a Data Race Condition in your code. This post discusses what a Data Race Condition is and how you can use the Thread Sanitizer to debug the issue.
<h2 id="what-is-a-data-race-condition">What is a Data Race Condition?</h2>
A Data Race Condition occurs when multiple threads access the same memory location without synchronization and atleast one of these accesses is a write.
Data Race Conditions are notoriously hard to debug since they are timing dependent and will not occur every time the code is run. Step In — Thread Sanitizer.
<h2 id="what-is-thread-sanitizer">What is Thread Sanitizer?</h2>
Thread Sanitizer (or TSan) is a part of a family of LLVM tools which combines compile time instrumentation and runtime monitoring to detect threading bugs in the code. It was introduced in Xcode 8 and has support for both Objective C and Swift. It can detect multiple types of threading bugs one of which is the Data Race Condition.
<h2 id="running-with-the-tsan-enabled--">Running with the TSan enabled -</h2>
a) Tap on application scheme and then on “Edit Scheme”
<img src="/uploads/demo_blog_post_edit_scheme_9137c5ec24.webp" alt="demo-blog-post-edit-scheme.webp">
b) Under the “Diagnostics” tab, in the “Runtime Sanitizer” section, enable the “Thread Sanitizer” checkbox. You can also choose to pause the program execution when a data race is detected by checking the “Pause on issues” checkbox. (Note — The “Thread Sanitizer” option is only available when you are running on an iOS Simulator. It is not supported on a device)
<img src="/uploads/demo_blog_post_thread_sanitizer_c46a58e150.webp" alt="demo-blog-post-thread-sanitizer.webp">
c) Run your application and execute the steps which cause the <code>EXC_BAD_ACCESS</code> crash.
If your application has a Data Race Condition, TSan will detect it and log it to the console. (Note —TSan might not detect all Data Race Conditions in a single attempt. In that case, try executing the steps to reproduce multiple times).
<h2 id="interpreting-the-tsan-log--">Interpreting the TSan log -</h2>
The TSan log for a Data Race Condition will look like this (important parts are highlighted in red) -
<img src="/uploads/demo_blog_post_tsan_log_3859025531.webp" alt="demo-blog-post-tsan-log.webp">
Sample Thread Sanitizer Log
<ol>
<li>TSan log has information about which exact threads participated in the Data Race Condition. In the above example, the <code>main thread</code> and <code>thread T7</code> were involved in the Data Race Condition.</li>
<li>The log contains a stack trace for each participating thread. Asterisk (*) in the logged stack traces points to the exact code which accessed / mutated the data. In the above log, the data race occurred when setting / reading the <code>someBool</code> variable. Also, if you go one level down in the call stack, you will get the exact method where the memory location in question was accessed / mutated (<code>startConsumer()</code> and <code>updateBoolValue()</code>)</li>
<li>The log also tells you if the memory location in question is present in the heap / stack / data segment of your program and which thread allocated this memory. In the above example, TSan log states — <code>Location is heap block of size 880 at 0x7b5c00000380 allocated by main thread</code>.</li>
</ol>
Please Note — The TSan log will contain at most 4 call stacks which accessed the memory location in question. This is because the TSan is designed to keep a track of upto 4 different accesses only.
Now that you have tracked down the Data Race Condition, lets see how it can be fixed.
Fixing a Data Race Condition -
The fix for a Data Race Condition largely depends on how the code is designed. There is no “correct / standard” way to fix this problem. This means only you will know what the correct fix should be.
Broadly speaking, there are 2 ways to fix a Data Race Condition -
<ol>
<li>Prevent multiple threads from accessing the same memory location. To do this, you could — choose to dispatch all accesses (read / write) to the same queue using GCD functions (<code>DispatchQueue.sync()</code> / <code>DispatchQueue.async()</code>) or copy your objects when passing them between different threads.</li>
<li>Synchronize access to memory locations used by multiple threads by using synchronization primitives provided by Apple like <code>@synchronized()</code>, <code>NSLock</code> etc.</li>
</ol>
<h2 id="wrapping-up-few-key-points-about-tsan--">Wrapping up (Few key points about TSan) -</h2>
<ol>
<li>The TSan can a detect Data Race Condition even when it does not manifest itself in a particular application run.</li>
<li>TSan might not detect a Data Race Condition in a single application run. This is especially true if a memory location is being accessed by more than 4 threads.</li>
<li>TSan requires recompilation of the code so it cannot be used on pre-built binaries.</li>
<li>Running your code with TSan checks enabled can result in CPU slowdown of 2⨉ to 20⨉, and an increase in memory usage by 5⨉ to 10⨉.</li>
<li>The TSan only works with the iOS simulator and cannot be enabled when running on a real iOS device.</li>
</ol>
Hope this post helps you debug / fix Data Race Conditions in your code. To summarize — we discussed what a Data Race Condition is, how to debug this using TSan and some potential ways to this problem in your code.
Happy Coding!

Data Races are notoriously hard to reproduce and debug. Read on to understand how the Thread Sanitizer makes it easy to track these down and some potential ways to fix them in your code.

Thread Sanitizer (TSan): Debugging iOS Data Race EXC_BAD_ACCESS Errors | Blog | Raja Software Labs

Data Races are notoriously hard to reproduce and debug. Read on to understand how the Thread Sanitizer makes it easy to track these down and some potential ways to fix them in your code.

Thread Sanitizer (TSan): Debugging iOS Data Race EXC_BAD_ACCESS Errors

Software engineers with a passion for shipping products will love working at RSL.

JoinTeam2.webp

Join the Team

RSL helps companies like LinkedIn and Google Nest with development of their flagship mobile apps.

OurWork2.webp

Our Work

“RSL has literally saved dozens of commercial projects for me at three separate companies.”
Michael Plasterer, WIMM Labs

Testomonials.webp

Testimonials

logo-transparent.svg

Home

About Us

Blog

Careers

Contact

Stay up-to-date on the latest trends in Android, iOS, Web, and Backend development with our blog. We post regular articles with tutorials, best practices, debugging guides, etc. to help you master these technologies.