Share: 10 tips for developing Android apps efficiently

If you want to do one of the most unsuccessful cases on Google Play, the simple and brutal approach is to develop an app that is incredibly slow, consumes power, and consumes memory. Then you will get a bad review of countless users, and finally no one to download, and no one to use. Even if your app design ideas are good, it doesn't work.

Focus on mobile applications in the cloud service platform- Love Beta (www.ineice.com) technology to share the following 10 tips to efficiently develop Android:

Recommendation one: How to cancel the action in some threads in the background

We know that all of the actions in the app run are done by default in the main thread (UI thread), so that the app's responsiveness is affected. can cause the program to stutter, die, or even get a system error.

To speed up responsiveness, you need to move time-consuming operations (such as network requests, database operations, or complex computations) from the main thread to a separate thread. The most efficient way to do this is to do this at the class level, and you can use Asynctask or intentservice to create a background operation. If you choose to use Intentservice, it starts up when needed and then processes the request (Intent) through a worker thread.

There are a few limitations to note when using Intentservice:

This class does not pass information to the UI, if you want to show the user processing results information, please use activity;

Only one request can be processed at a time;

Each processing request process can not be interrupted;

Recommendation two: How to remain responsive does not occur in ANR

Removing time-consuming actions from the UI thread also prevents user actions from appearing in the system not responding (ANR) dialog box. All you need to do is inherit asynctask to create a background worker thread and implement the Doinbackground () method.

Another way is to create a thread class or Handlerthread class yourself. It is important to note that this also slows down the app because the default thread priority is the same as the primary, unless you explicitly set the priority of the thread.

Recommendation three: How to initialize a query operation in a thread

When the query operation is being processed in the background, the presentation data is not instantaneous, but you can use the Cursorloader object to speed up the interaction between the activity and the user.

After using this object, your app will initialize a separate background thread for ContentProvider to query, and when the query is finished, it will return results to the activity that invoked the query.

Recommendation IV: Other areas to be aware of

Use Strictmode to check for potentially time-consuming operations in the UI thread;

Use special tools such as Systrace or TraceView to find bottlenecks in your application;

Use the progress bar to show the user the progress of the operation;

If the initialization operation is time consuming, please show a welcome interface.

Optimize the battery life of your device

If the app is very power-consuming, don't blame the user for uninstalling your app. For battery use, the main charges are as follows:

Wake up the program frequently when updating data;

Use Edge or 3G to transmit data;

Text data conversion for non-JIT regular expression operations.

Recommendation five: How to optimize the network

If you don't have an Internet connection, let your app skip network operations and update the data only if there is a network connection and no roaming;

Select a compatible data format to convert all requests containing textual data and binary data into binary data format requests;

Using efficient conversion tools, consider using streaming conversion tools, less tree-shaped conversion tools;

For a faster user experience, reduce the duplication of access to the server;

If you can, use the framework's gzip library to compress text data to efficiently use CPU resources.

Recommendation six: How to optimize the work of the application in the front end

If you consider using Wakelocks, try to set it to the minimum level;

To prevent potential bug-induced power consumption, specify the time-out period explicitly;

Enable the Android:keepscreenon property;

In addition to the system's GC operations, consider manually recycling Java objects, such as Xmlpullparserfactory and Bitmapfactory. There are also regular expression Matcher.reset (newstring) operations, Stringbuilder.setlength (0) operations;

Be aware of the problem of synchronization, although it is safe in the main thread;

In the ListView, the reuse strategy should be used more.

If allowed to use more rough network positioning instead of GPs, compared to GPS need 1mAh (25s * mA), and the general network only with 0.1mAh (2s * 180mA);

Make sure to unregister the GPS location update operation, as this update operation will continue in OnPause (). When all applications are logged out of this operation, the user can re-enable GPS in the system settings without wasting power;

Consider using low-precision variables in a large number of mathematical operations and caching the variable values when using Displaymetrics for DPI tasks;

Recommendation seven: How to optimize the application of the work in the foreground

Make sure that the service life cycle is short, because each process requires 2MB of memory and restarts when the foreground program needs memory;

Keep the amount of memory in use not too large;

If you want the app to be updated every 30 minutes, do so at the device's wake-up state;

Service is not good in pull or sleep state, which is why you should use Alarmmanager or configure attribute stopself () at the end of the service.

Recommendation VIII: Other considerations

Check the status and network status of the battery before making the overall update, and wait for the best state for a large-scale reload operation;

Let the user see electricity situation, such as update cycle, background operation;

Implementing a low memory footprint UI

Recommendation IX: How to find layout display problems

When we create a UI for the layout alone, we create an app that abuses memory, and it has a nasty delay in the UI. To achieve a smooth, low-footprint UI, the first step is to search your app to find out the potential bottleneck layout. Use the Hierarchy Viewertool tool that comes with androidsdk/tools/.

Another good tool is lint, which scans the application's source code for possible bugs and optimizes control results.

Recommendation 10: How to fix the problem

If the layout shows a problem, you can consider simplifying the layout structure. You can convert the LinearLayout type to a relativelayout type, reducing the hierarchy of the layout.

Copyright NOTICE: This article for Bo Master original article, without Bo Master permission not reproduced.

Share: 10 tips for developing Android apps efficiently