Common performance optimization techniques in iOS development

What are the main causes of performance issues? There are similar and different reasons, but in the final analysis, they are nothing more than memory usage, code efficiency, appropriate strategy logic, code quality, and installation package size.

[[260114]]

But from the perspective of user experience, when we put ourselves in the shoes of users and play an app, what do we care about? If we are playing a mobile game, first of all, we don’t want it to crash suddenly, then we don’t want it to be stuck, then we don’t want the power and data consumption to be too serious, and finally we want the installation package to be smaller. A simple classification is as follows:

• Fast: Avoid lags during use, respond quickly, reduce user waiting time, and meet user expectations.
• Stable: Do not crash or become unresponsive during user use.
• Save: Save traffic and power consumption, reduce user usage costs, and avoid overheating of the phone during use.
• Small: The small installation package can reduce the user's installation cost.

1. Fast

Slow application startup and frequent freezes during use greatly affect the user experience and should be avoided as much as possible. There are many scenarios for freezes, which can be divided into four categories: UI drawing, application startup, page jump, and event response. There are many reasons for freezes, but no matter what the reasons and scenarios are, they are ultimately displayed on the device screen to reach the user. In the final analysis, there is a problem with the display.

According to the iOS system display principle, the fundamental reasons that affect drawing are as follows:

1. The drawing task is too heavy and it takes too long to draw one frame of content.
2. The main thread is too busy, and the data is not ready when the VSYNC signal sent by the system arrives, resulting in frame loss.

If drawing takes too long, there are some tools that can help us locate the problem. If the main thread is too busy, you need to pay attention. The main thread's key responsibilities are to handle user interactions, draw pixels on the screen, and load display-related data, so it is particularly important to avoid anything that happens on the main thread so that the application can remain responsive to user operations. In summary, the main thread mainly does the following:

1. UI lifecycle control
2. System event processing
3. Message Processing
4. Interface layout
5. Interface drawing
6. Interface refresh

In addition, you should try to avoid putting other processing in the main thread, especially complex data calculations and network requests.

2. Stability

The definition of application stability is very broad. There are many reasons that affect stability, such as unreasonable memory usage, incomplete consideration of code exception scenarios, unreasonable code logic, etc., which will affect the stability of the application. The two most common scenarios are: Crash and ANR. These two errors will make the program unusable. The more common solutions are as follows:

1. Improve code quality. For example, code review during development to check code design logic, business rationality, etc.
2. Code static scanning tools. Common tools include Clang Static Analyzer, OCLint, Infer, etc.
3. Crash monitoring: Record some crash information and abnormal information in time for subsequent analysis and resolution.
4. Crash upload mechanism: After a crash, try to save the logs locally first, and then upload the log information when the network is normal next time.

3. Province

In mobile devices, the importance of battery is self-evident. Without power, nothing can be done. For operating system and device developers, power consumption optimization has never stopped in pursuit of longer standby time. However, for an application, the issue of power usage cannot be ignored, especially for those applications that are classified as "battery killers", which will eventually be uninstalled. Therefore, application developers need to minimize power consumption while meeting their needs.

1.CPU

Regardless of whether the user is directly using it or not, the CPU is the main hardware used by the application. When operating in the background and processing push notifications, the application will still consume CPU resources.

The more computation an application performs, the more power it consumes. Older devices consume more power to perform the same basic operations. The amount of computation consumed depends on different factors.

2. Network

Intelligent network access management can make applications respond faster and help extend battery life. When the network is inaccessible, subsequent network requests should be postponed until the network connection is restored. In addition, high bandwidth consumption operations should be avoided when there is no WiFi connection. For example, video streaming, it is well known that cellular wireless systems (LTE, 4G, 3G, etc.) consume much more power than WiFi signals. The root cause is that LTE devices are based on multiple-input, multiple-output technology and use multiple concurrent signals to maintain LTE links at both ends. Similarly, all cellular data links will scan regularly to find stronger signals. Therefore: we need

• 1) Before performing any network operations, check whether a suitable network connection is available.
• 2) Continuously monitor network availability and provide appropriate feedback when link status changes
• 3). Location Manager and **GPS**

We all know that location services consume a lot of power. To calculate coordinates using GPS, you need to determine two pieces of information:

• 1) Time lock Each GPS satellite broadcasts a unique 1023-bit random number every millisecond, so the data transmission rate is 1.024Mbit/s. The GPS receiving chip must be correctly aligned with the satellite's time lock slot.
• 2) Frequency-locked GPS receivers must calculate signal errors caused by the Doppler shift caused by the relative motion between the receiver and the satellite.

Calculating coordinates will constantly use CPU and GPS hardware resources, so they will quickly consume battery power. So how can we reduce it?

1) Turn off unimportant features

Determine when you need to track location changes. Call the startUpdatingLocation method when tracking is needed, and call the stopUpdatingLocation method when tracking is not needed.

Location tracking should also be turned off when the app is running in the background or the user is not chatting with others. In other words, location tracking should be turned off when browsing the media library, checking the friend list, or adjusting the app settings.

2) Use the Internet only when necessary

In order to improve the efficiency of power usage, iOS always keeps the wireless network closed as much as possible. When an application needs to establish a network connection, iOS will take this opportunity to share the network session with the background application so that some low-priority applications can be processed, such as push notifications, receiving emails, etc.

The key is that every time a user establishes a network connection, the network hardware will remain active for a few seconds after the connection is completed. Each concentrated network communication consumes a lot of power.

To mitigate this problem, your software needs to use the network sparingly. It should periodically use the network for short bursts, rather than maintaining a constant stream of active data. Only then will the network hardware have a chance to shut down.

4. Screen

Screens use a lot of power, and the larger the screen, the more power it uses. Of course, if your app is in the foreground and interacting with the user, it will inevitably use the screen and consume power.

Here are some ideas for optimizing screen usage:

1) Animation optimization

When the app is in the foreground, use animation. Once the app enters the background, pause the animation immediately. Generally speaking, you can pause or stop the animation by listening to the notification events of UIApplicationWillResignActiveNotification or UIApplicationDIdEnterBackgroundNotification, or you can resume the animation by listening to the notification event of UIApplicationDidBecomeActiveNotification.

2) Video Optimization

During video playback, the screen should be kept constant. You can use the idleTimerDisabled property of the UIApplication object to achieve this. Once set to YES, it will prevent the screen from sleeping, thus achieving constant light.

Similar to animations, you can release and acquire locks through notifications from the corresponding app.

Users always carry their mobile phones with them, so it is particularly important to write power-saving code. After all, mobile power banks are not available everywhere. When the complexity of the task cannot be reduced, providing a solution that is sensitive to the battery level and prompting the user at the appropriate time will give the user a good user experience.

4. Small

The size of the application installation package has no effect on the use of the application, but the larger the application installation package, the higher the threshold for users to download it. Especially in the case of mobile networks, users have higher requirements for the size of the installation package when downloading applications. Therefore, reducing the size of the installation package can make more users willing to download and experience the product.

Of course, although slimming down and reducing the burden are good, we need to pay attention to the impact of slimming down on the maintainability of the project. It is recommended to select techniques based on your own project.

The App installation package consists of two parts: resources and executable files. The installation package is slimmed down and optimized from the following three parts.

Resource optimization:

1. Delete unused resources
2. Deleting Duplicate Resources
3. Lossless compression of images
4. Uncommon resources are replaced by downloads

Compilation optimization:

1. Remove debug symbols
2. Enable compilation optimization
3. Avoid compiling for multiple architectures

Executable file optimization:

1. Remove unused code
2. Count library usage and remove useless libraries
3. Obfuscate class/method names
4. Reduce redundant strings
5. ARC->MRC (It is generally not recommended to do this unless it is a special case, as it will increase maintenance costs)

Reducing the size of iOS installation packages is something that many medium and large APPs have to do. Generally, they will start with resource files, compress images/audio, and remove unnecessary resources. After these resource optimizations are completed, we can also try to slim down the executable files. The larger the project, the larger the volume occupied by the executable file. Because the AppStore will encrypt the executable file, the compression rate of the executable file is low. After compression, the executable file accounts for about 80%~90% of the volume of the entire APP installation package, which is still worth optimizing.

Here are some common optimization solutions:

TableViewCell Reuse

In the cellForRowAtIndexPath: callback, only the instance is created, the cell is returned quickly, and the data is not bound. In willDisplayCell: forRowAtIndexPath:, the data is bound (assigned).

Height Cache

When the tableView is sliding, heightForRowAtIndexPath: is called continuously. When the cell height needs to be adaptive, the height needs to be calculated every time the callback is called, which will cause the UI to freeze. In order to avoid repeated meaningless calculations, the height needs to be cached.

How to cache?

 Dictionary, NSCache. 
 
 UITableView-FDTemplateLayoutCell  
 [if !supportLineBreakNewLine]  
 [endif] 
 
 View Hierarchy Optimization 
 
 Don't create views dynamically 
 
 Cache subviews under the premise that memory is controllable. 
 
 Make good use of hidden. 
 
 [if !supportLineBreakNewLine]  
 [endif] 
 
 Reduce the view hierarchy 
 
 Reduce the number of subviews and use layer to draw elements. 
 
 Use clearColor, maskToBounds, shadow effects, etc. less. 
 
 [if !supportLineBreakNewLine]  
 [endif] 
 
 Reduce redundant drawing operations 
 
 picture

Don't use JPEG images, use PNG images.

The child thread pre-decodes (Decode), and the main thread renders directly. Because when the image is not decoded, directly assigning it to imageView will perform a Decode operation.

Optimize the image size and try not to dynamically scale it (contentMode).

Whenever possible, combine multiple images into one for display.

 [if !supportLineBreakNewLine]  
 [endif]

Reduce transparent views

Using transparent views will cause blending. In iOS graphics processing, blending mainly refers to the calculation of mixed pixel colors. The most intuitive example is that when we stack two layers together, if the first layer is transparent, the final pixel color calculation needs to take the second layer into account. This process is called blending.

Reasons that can cause blending:

UIView has alpha < 1.

The image of UIImageView contains an alpha channel (even if the alpha of UIImageView is 1, as long as the image contains a transparent channel, it will still cause blending).

 [if !supportLineBreakNewLine]  
 [endif]

Why does blending cause performance loss?

The reason is very intuitive. If a layer is opaque, the system can directly display the color of the layer. If the layer is transparent, it will cause more calculations because the other layer needs to be included in the mixed color calculation.

Setting opaque to YES reduces performance overhead since the GPU will not do any compositing but simply copy from this layer.

 [if !supportLineBreakNewLine]  
 [endif]

Reduce off-screen rendering

Off-screen rendering means that the image needs to be rendered once before it is drawn to the current screen.

In OpenGL, GPU screen rendering has the following two modes:

On-Screen

Rendering refers to the current screen rendering, which means that the GPU rendering operation is performed in the screen buffer currently used for display.

Off-Screen

Rendering is off-screen rendering, which means that the GPU opens a new buffer outside the current screen buffer for rendering operations.

 [if !supportLineBreakNewLine]
 [endif]

summary

Performance optimization cannot be solved by updating one or two versions. It is a continuous demand, continuous integration and iterative feedback. In actual projects, at the beginning of the project, due to manpower and project completion time constraints, the priority of performance optimization is relatively low. When the project enters the commissioning stage, the priority needs to be increased. However, in the early stage of the project, when designing the architecture plan, performance optimization points also need to be considered in advance, which reflects a programmer's technical skills.

When there is a need for performance optimization, it usually starts with discovering the problem, then analyzing the cause and background of the problem, and then looking for the best solution, and finally solving the problem. This is also a processing method often used in daily work.