Android performance optimization: battery life

Google recently released an online course on Android performance optimization on Udacity, which introduces how to optimize performance from the aspects of rendering, computing, memory, and power. These courses are a refinement and supplement of the Android performance optimization classic course previously released by Google on Youtube.

Below are the study notes for the power chapter. Some of the content overlaps with the previous performance optimization examples. Everyone is welcome to study and communicate together!
1) Understanding Battery Drain

The power consumption of each hardware module of a mobile phone is different. Some modules consume a lot of power, while some modules consume relatively less power.

The calculation and statistics of power consumption is a troublesome and contradictory task, and recording power consumption itself is also a waste of power. The only feasible solution is to use a third-party power monitoring device to obtain the real power consumption.

When the device is in standby mode, it consumes very little power. For example, N5 can be in standby mode for nearly a month when the airplane mode is turned on. However, when the screen is turned on, the hardware modules need to start working, which consumes a lot of power.

After using WakeLock or JobScheduler to wake up the device to process a scheduled task, be sure to return the device to its original state in a timely manner. Each time you wake up the cellular signal for data transmission, it consumes a lot of power, which is more power-consuming than WiFi and other operations.

2) Battery Historian

Battery Historian is a new API introduced in Android 5.0. You can get the battery consumption information on the device through the following command:

 $ adb shell dumpsys batterystats > xxx.txt //Get the power consumption information of the entire device  
 $ adb shell dumpsys batterystats > com. package .name > xxx.txt //Get the power consumption information related to the specified app  

After getting the raw power consumption data, we need to convert the data information into a more readable HTML file through a python script written by Google:

 $ python historian.py xxx.txt > xxx.html

Open this converted HTML file, and you can see the list data similar to that generated by TraceView. The amount of data here is very large, so I will not expand it here.

3)Track Battery Status & Battery Manager

We can get the current charging status of the phone through the following code:

 // It is very easy to subscribe to changes to the battery state, but you can get the current  
 // state by simply passing null in as your receiver. Nifty, isn't that?  
 IntentFilter filter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
 Intent batteryStatus = this .registerReceiver( null , filter);
 int chargePlug = batteryStatus.getIntExtra(BatteryManager.EXTRA_PLUGGED, - 1 );
 boolean acCharge = (chargePlug == BatteryManager.BATTERY_PLUGGED_AC);
 if (acCharge) {
 Log.v(LOG_TAG,“The phone is charging!”);
 }

The above example demonstrates how to immediately obtain the charging status of a mobile phone. After obtaining the charging status information, we can optimize some of the code in a targeted manner. For example, we can determine that only when the current mobile phone is in AC charging state will some power-consuming operations be performed.

 /**
 * This method checks for power by comparing the current battery state against all possible
 * plugged in states. In this case, a device may be considered plugged in either by USB, AC, or
 * wireless charge. (Wireless charge was introduced in API Level 17.)
 */  
 private   boolean checkForPower() {
 // It is very easy to subscribe to changes to the battery state, but you can get the current  
 // state by simply passing null in as your receiver. Nifty, isn't that?  
 IntentFilter filter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
 Intent batteryStatus = this .registerReceiver( null , filter); 
 
 // There are currently three ways a device can be plugged in. We should check them all.  
 int chargePlug = batteryStatus.getIntExtra(BatteryManager.EXTRA_PLUGGED, - 1 );
 boolean usbCharge = (chargePlug == BatteryManager.BATTERY_PLUGGED_USB);
 boolean acCharge = (chargePlug == BatteryManager.BATTERY_PLUGGED_AC);
 boolean wirelessCharge = false ;
 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
 wirelessCharge = (chargePlug == BatteryManager.BATTERY_PLUGGED_WIRELESS);
 }
 return (usbCharge || acCharge || wirelessCharge);
 }

4) Wakelock and Battery Drain

Efficiently retaining more power and constantly urging users to use your app will consume power, which is a contradictory choice. However, we can use some better ways to balance the two.

Suppose your phone is loaded with a lot of social apps. Even when the phone is in standby mode, it will often be woken up by these apps to check and synchronize new data information. Android will constantly shut down various hardware to extend the standby time of the phone. First, the screen will gradually dim until it turns off, and then the CPU will go to sleep. All these operations are to save precious power resources. But even in this sleep state, most applications will still try to work, and they will constantly wake up the phone. One of the simplest ways to wake up the phone is to use the PowerManager.WakeLock API to keep the CPU working and prevent the screen from dimming and turning off. This allows the phone to be woken up, perform work, and then go back to sleep. Knowing how to acquire WakeLock is simple, but releasing WakeLock in time is also very important. Improper use of WakeLock can lead to serious errors. For example, the data return time of a network request is uncertain, resulting in a wait of 1 hour for something that should only take 10 seconds, which will waste power. This is why it is critical to use the wakelock.acquice() method with a timeout parameter.

But just setting a timeout is not enough to solve the problem. For example, how long is the appropriate timeout? When should I retry? To solve the above problems, the right way may be to use an inaccurate timer. Usually, we set a time to perform an operation, but it may be better to modify this time dynamically. For example, if there is another program that needs to wake up 5 minutes later than the time you set, it can only wait until then, and the two tasks can be bundled together and performed at the same time. This is the core working principle of the inaccurate timer. We can customize the scheduled tasks, but if the system detects a better time, it can postpone your task to save power consumption.

This is exactly what the JobScheduler API does. It will combine the ideal wake-up time based on the current situation and tasks, such as waiting until it is charging or connected to WiFi, or concentrating tasks together. We can implement many free scheduling algorithms through this API.
5) Network and Battery Drain

The following content comes from the efficient download section of the official Training document about the power consumption of mobile phone (Radio) cellular signals.

Normally, when using 3G mobile network to transmit data, there are three states of power consumption:

Full power: The highest energy state, the mobile network connection is activated, allowing the device to operate at maximum data rate.
Low power: An intermediate state that consumes about 50% of the power of the Full power state.
Standby: The latest state, no data connection needs to be transmitted, and the power consumption is minimal.

The following figure is a typical diagram of a 3G Radio State Machine

In short, in order to reduce power consumption, it is best to execute network requests in batches under cellular mobile networks and try to avoid frequent intervals of network requests.

Through the Battery Historian we learned earlier, we can get the power consumption data of the device. If the power consumption of the mobile cellular network (Mobile Radio) in the data shows the following situation, with small intervals and frequent intermittent occurrences, it means that the power consumption performance is very poor:

After optimization, if the following diagram is displayed, it means that the power consumption performance is good:

In addition, under WiFi connection, the power consumption of network transmission is much less than that of mobile network. You should try to reduce data transmission under mobile network and transmit data more under WiFi environment.

So how can we cache tasks and execute them in batches? This is where Job Scheduler comes in.
6) Using Job Scheduler

When using Job Scheduler, all the application needs to do is to determine which tasks are not urgent and can be handed over to Job Scheduler for processing. Job Scheduler centrally processes the received tasks, selects the appropriate time and the appropriate network, and then executes them together.

Here is a brief example of using Job Scheduler. You need to have a JobService first:

 public   class MyJobService extends JobService {
 private   static   final String LOG_TAG = "MyJobService" ; 
 
 @Override  
 public   void onCreate() {
 super .onCreate();
 Log.i(LOG_TAG, "MyJobService created" );
 } 
 
 @Override  
 public   void onDestroy() {
 super .onDestroy();
 Log.i(LOG_TAG, "MyJobService destroyed" );
 } 
 
 @Override  
 public   boolean onStartJob(JobParameters params) {
 // This is where you would implement all of the logic for your job. Note that this runs  
 // on the main thread, so you will want to use a separate thread for asynchronous work  
 // (as we demonstrate below to establish a network connection).  
 // If you use a separate thread, return true to indicate that you need a "reschedule" to  
 // return to the job at some point in the future to finish processing the work. Otherwise,  
 // return false when finished.  
 Log.i(LOG_TAG, "Totally and completely working on job " + params.getJobId());
 // First, check the network, and then attempt to connect.  
 if (isNetworkConnected()) {
 new SimpleDownloadTask() .execute(params);
 return   true ;
 } else {
 Log.i(LOG_TAG, "No connection on job " + params.getJobId() + "; sad face" );
 }
 return   false ;
 } 
 
 @Override  
 public   boolean onStopJob(JobParameters params) {
 // Called if the job must be stopped before jobFinished() has been called. This may  
 // happen if the requirements are no longer being met, such as the user no longer  
 // connecting to WiFi, or the device no longer being idle. Use this callback to resolve  
 // anything that may cause your application to misbehave from the job being halted.  
 // Return true if the job should be rescheduled based on the retry criteria specified  
 // when the job was created or return false to drop the job. Regardless of the value  
 // returned, your job must stop executing.  
 Log.i(LOG_TAG, "Whelp, something changed, so I'm calling it on job " + params.getJobId());
 return   false ;
 } 
 
 /**
 * Determines if the device is currently online.
 */  
 private   boolean isNetworkConnected() {
 ConnectivityManager connectivityManager =
 (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
 NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
 return (networkInfo != null && networkInfo.isConnected());
 } 
 
 /**
 * Uses AsyncTask to create a task away from the main UI thread. This task creates a
 * HTTPUrlConnection, and then downloads the contents of the webpage as an InputStream.
 * The InputStream is then converted to a String, which is logged by the
 * onPostExecute() method.
 */  
 private   class SimpleDownloadTask extends AsyncTask<JobParameters, Void, String> { 
 
 protected JobParameters mJobParam; 
 
 @Override  
 protected String doInBackground(JobParameters... params) {
 // cache system provided job requirements  
 mJobParam = params[ 0 ];
 try {
 InputStream is = null ;
 // Only display the first 50 characters of the retrieved web page content.  
 int len ​​= 50 ; 
 
 URL url = new URL( "https://www.google.com" );
 HttpURLConnection conn = (HttpURLConnection) url.openConnection();
 conn.setReadTimeout( 10000 ); //10sec  
 conn.setConnectTimeout( 15000 ); //15sec  
 conn.setRequestMethod( "GET" );
 //Starts the query  
 conn.connect();
 int response = conn.getResponseCode();
 Log.d(LOG_TAG, "The response is: " + response);
 is = conn.getInputStream(); 
 
 // Convert the input stream to a string  
 Reader reader = null ;
 reader = new InputStreamReader(is, "UTF-8" );
 char [] buffer = new   char [len];
 reader.read(buffer);
 return   new String(buffer); 
 
 } catch (IOException e) {
 return   "Unable to retrieve web page." ;
 }
 } 
 
 @Override  
 protected   void onPostExecute(String result) {
 jobFinished(mJobParam, false );
 Log.i(LOG_TAG, result);
 }
 }
 }

Then simulate triggering N tasks by clicking Button and handing them over to JobService for processing

 public   class FreeTheWakelockActivity extends ActionBarActivity {
 public   static   final String LOG_TAG = "FreeTheWakelockActivity" ; 
 
 TextView mWakeLockMsg;
 ComponentName mServiceComponent; 
 
 @Override  
 protected   void onCreate(Bundle savedInstanceState) {
 super .onCreate(savedInstanceState);
 setContentView(R.layout.activity_wakelock); 
 
 mWakeLockMsg = (TextView) findViewById(R.id.wakelock_txt);
 mServiceComponent = new ComponentName( this , MyJobService. class );
 Intent startServiceIntent = new Intent( this , MyJobService. class );
 startService(startServiceIntent); 
 
 Button theButtonThatWakelocks = (Button) findViewById(R.id.wakelock_poll);
 theButtonThatWakelocks.setText(R.string.poll_server_button); 
 
 theButtonThatWakelocks.setOnClickListener( new View.OnClickListener() {
 @Override  
 public   void onClick(View v) {
 pollServer();
 }
 });
 } 
 
 /**
 * This method polls the server via the JobScheduler API. By scheduling the job with this API,
 * your app can be confident it will execute, but without the need for a wake lock. Rather, the
 * API will take your network jobs and execute them in batch to best take advantage of the
 * initial network connection cost.
 *
 * The JobScheduler API works through a background service. In this sample, we have
 * a simple service in MyJobService to get you started. The job is scheduled here in
 * the activity, but the job itself is executed in MyJobService in the startJob() method. For
 * example, to poll your server, you would create the network connection, send your GET
 * request, and then process the response all in MyJobService. This allows the JobScheduler API
 * to invoke your logic without needed to restart your activity.
 *
 * For brevity in the sample, we are scheduling the same job several times in quick succession,
 * but again, try to consider similar tasks occurring over time in your application that can
 * afford to wait and may benefit from batching.
 */  
 public   void pollServer() {
 JobScheduler scheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
 for ( int i= 0 ; i< 10 ; i++) {
 JobInfo jobInfo = new JobInfo.Builder(i, mServiceComponent)
 .setMinimumLatency( 5000 ) // 5 seconds  
 .setOverrideDeadline( 60000 ) // 60 seconds (for brevity in the sample)  
 .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY) // WiFi or data connections  
 .build(); 
 
 mWakeLockMsg.append( "Scheduling job " + i + "!\n" );
 scheduler.schedule(jobInfo);
 }
 }
 }