Shulou(Shulou.com)06/02 Report--

In this issue, the editor will bring you about the common performance optimization skills in iOS development. The article is rich in content and analyzed and described from a professional point of view. I hope you can get something after reading this article.

Preface

The main causes of performance problems are the same and different, but in the final analysis, it is nothing more than memory usage, code efficiency, appropriate policy logic, code quality, installation package size and so on.

But from the perspective of user experience, what do we care about when we have to play an app as a user? If you are playing a mobile game, first of all, you must not want to play suddenly flicker, and then you do not want to stutter, followed by power consumption and traffic consumption do not want to be too serious, and finally, the installation package hopes to be smaller. The simple categories are as follows:

Fast: avoid stutter when using, respond quickly, reduce the waiting time of users, and meet the expectations of users.

Steady: do not crash and become unresponsive in the course of user use.

Save: save traffic and power consumption, reduce user costs, and avoid causing the phone to burn when in use.

Small: a small installation package can reduce the installation cost for users.

1. Come on

Applications start slowly and often stutter when using, which has a great impact on the user experience and should be avoided as far as possible. There are many scenarios of Catton, which can be divided into four categories according to the scene: UI drawing, application startup, page jump and event response. There are many reasons for stutter, but no matter what the cause and scene are, they are ultimately displayed on the device screen to reach the user. In the final analysis, there is something wrong with the display.

According to the display principle of iOS system, we can see that the root causes that affect rendering are as follows:

1. The drawing task is too heavy and it takes too long to draw a frame of content. two。 The main thread is too busy and the frame is lost when the data is not ready according to the VSYNC signal transmitted by the system.

Drawing takes too long, and there are some tools that can help us locate the problem. If the main thread is too busy, it should be noted that the key responsibility of the main thread is to handle user interaction, draw pixels on the screen, and load and display related data, so it is especially necessary to avoid any main thread thread. so that the application can maintain an immediate response to user actions. To sum up, the main thread mainly does the following work:

1.UI Lifecycle Control 2. System event handling 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, particularly complex data calculations and network requests.

Second, stability

The definition of application stability is very broad, and there are many reasons that affect the stability, such as unreasonable use of memory, inadequate 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, during the development of code review, look at some code design logic, business rationality and so on. two。 Code static scanning tool. Common tools are Clang Static Analyzer, OCLint, Infer, and so on. 3.Crash monitoring. Record some crash information and abnormal information in time for follow-up analysis. 4.Crash upload mechanism. After Crash, try to save the log locally, and then upload the log information next time when the network is normal.

III. Province

In mobile devices, the importance of batteries is self-evident. Nothing can be done without electricity. For operating system and device developers, power consumption optimization does not stop in pursuit of longer standby time, but for an app, power usage issues cannot be ignored, especially those classified as "battery killers". The end result is to be uninstalled. Therefore, while realizing the demand, application developers need to reduce power consumption as much as possible.

1.CPU

CPU is the main hardware used by the application no matter whether the user is using it directly or not. in the background operation and processing of push notification, the application will still consume CPU resources the more the application calculates, the more power it consumes. When completing the same basic operation, the older generation of devices will consume more power, and the consumption of computation depends on different factors.

two。 The network

Intelligent network access management can make applications respond faster and help extend battery life. When the network is unreachable, subsequent network requests should be postponed until the network connection is restored. In addition, high broadband consumption operations without a WiFi connection should be avoided. 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 multi-input and multi-output technology and use multiple simultaneous signals to maintain LTE links at both ends. Similarly, all cellular data links are scanned periodically for stronger signals. So: we need

1) check the availability of appropriate network connections before performing any network operations. 2) continuously monitor the availability of the network and give appropriate feedback when the link state changes. 3). Location Manager and * * GPS**

We all know that location services are very power-consuming, and using GPS to calculate coordinates requires two pieces of information:

1) each GPS satellite broadcasts a unique 1023-bit random number per millisecond, so the data transmission rate is that the receiving chip of the 1.024Mbit/s GPS must be correctly aligned with the satellite's time lock slot. 2) the frequency-locked GPS receiver must calculate the signal error caused by the Doppler offset caused by the relative motion between the receiver and the satellite.

Computing coordinates will constantly use the hardware resources of CPU and GPS, so they will quickly consume battery power, so how to reduce it?

1) turn off unimportant features

Determine when to track the change of location, call the startUpdatingLocation method when you need to trace, and call the stopUpdatingLocation method when you don't need to trace. Location tracking should also be turned off when the application is running in the background or when the user is not chatting with others, that is to say, when browsing the media library, viewing the list of friends, or adjusting application settings

2) use the network only if necessary

In order to improve the efficiency of electricity use, IOS always keeps the wireless network off as much as possible. When the application needs to establish a network connection, IOS will take the opportunity to share the network session with the background application so that some low priorities can be dealt with, such as pushing notifications, receiving email, etc.

The key is that every time a user establishes a network connection, the network hardware will remain active for a few more seconds after the connection is completed. Each centralized network communication consumes a lot of electricity. to mitigate the harm caused by this problem, your software needs to use the network with reservations. You should focus on using the network for a short time on a regular basis, rather than continuously maintaining an active data stream. Only in this way can the network hardware have a chance to shut down.

4. Screen

The screen consumes a lot of power, and the bigger the screen, the more power it consumes. Of course, if your application runs in the foreground and interacts with users, you are bound to use the screen and consume power. Here are some ways to optimize screen use:

1) Animation optimization

When applied in the foreground, use animation, and once the application enters the background, the animation is paused immediately. In general, you can pause or stop animation by listening for notification events of UIApplicationWillResignActiveNotification or UIApplicationDIdEnterBackgroundNotification, or you can resume animation by listening for notification events of UIApplicationDidBecomeActiveNotification

2) Video optimization

During video playback, it is best to keep the screen constant. You can use the idleTimerDisabled property of the UIApplication object to do this. Once YES is set, it will prevent the screen from sleeping so that it is always bright.

Similar to animation, you can release and acquire locks through notification of the appropriate application

Users always carry their mobile phone with them, so it is particularly important to write power-saving code. after all, mobile power is not everywhere, and when it is impossible to reduce the complexity of the task, provide a solution that is sensitive to battery power and prompt the user at the right time, it will make the user experience good.

4. Small

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

Of course, slimming and burden reduction are good, but we need to pay attention to the impact of slimming on the maintainability of the project. It is recommended to choose skills according to your own project.

The App installation package is made up of resources and executable files. The installation package is slimmed down and optimized from the following three parts.

Resource optimization:

1. Delete useless resources

two。 Delete duplicate resources

3. Lossless compression of pictures

4. Replace uncommonly used resources with downloads

Compilation optimization:

1. Remove debug symbol

two。 Turn on compilation optimization

3. Avoid compiling multiple schemas

Executable file optimization:

1. Remove useless code

two。 Take up the statistical database and remove the useless database

3. Confuse class / method names

4. Reduce redundant strings

5. Arc-> MRC (this is generally not recommended under special circumstances, which will increase maintenance costs)

Reducing the size of the iOS installation package is what many medium and large APP have to do. Generally, they will first start with resource files, compress pictures / audio, and remove unnecessary resources. After these resource optimizations are done, we can also try to reduce the size of executable files. The larger the project, the larger the size of executable files. Because AppStore encrypts executable files, the compression ratio of executable files is low. After compression, executable files account for about 80% and 90% of the volume of the entire APP installation package, which is worth optimizing.

Here are some common optimization scenarios:

TableViewCell reuse

In the case of cellForRowAtIndexPath: callback, only the instance is created, and cell is returned quickly without binding data. Bind the data (assignment) when willDisplayCell: forRowAtIndexPath:.

High caching

When tableView slips, heightForRowAtIndexPath:, will be called constantly. When the cell height needs to be adapted, each callback will calculate the height, which will cause UI stutters. To avoid repeating meaningless calculations, cache height is required.

How do I cache it?

Dictionary, NSCache.

UITableView-FDTemplateLayoutCell

[if! supportLineBreakNewLine]

[endif]

View level optimization

Do not create views dynamically

Cache subview on the premise that the memory is controllable.

Make good use of hidden.

[if! supportLineBreakNewLine]

[endif]

Reduce the view level

Reduce the number of subviews and draw elements with layer.

Use less clearColor,maskToBounds, shadow effects, etc.

[if! supportLineBreakNewLine]

[endif]

Reduce redundant drawing operations

Picture

Don't use JPEG pictures, you should use PNG pictures.

Sub-thread pre-decoding (Decode), the main thread directly rendered. Because when image has no Decode, assigning a value directly to imageView will do a Decode operation.

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

Combine as many pictures as possible into one for display.

[if! supportLineBreakNewLine] [endif]

Reduce transparent view

The use of transparent view causes blending. In the graphics processing of iOS, blending mainly refers to the calculation of mixed pixel colors. The most intuitive example is that we superimpose two layers together. If the first layer is transparent, then the final pixel color calculation needs to take the second layer into account. This process is called Blending.

Causes of blending:

Alpha of UIView

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.