Is it difficult to implement graceful backend keepalive? Not possible!

[[287287]]

Keep alive status

We know that the Android system will kill background processes, and with the update of the system version, the killing of processes is becoming more and more intense. The system's approach itself is good, because it can save memory, reduce power consumption, and avoid some rogue behaviors.

However, for some applications, the application scenarios themselves need to run in the background, and users are willing to let them run in the background, such as running applications. On the one hand, rogue software uses various rogue means to keep them alive, and on the other hand, the system increases the intensity of killing background applications, resulting in some of our applications that really need to run in the background being mistakenly killed, which is unbearable.

Elegant survival?

In order to keep the system alive, many "black technologies" have emerged, such as 1-pixel Activity, playing silent audio, dual processes guarding each other, etc. These practices can be said to be very rogue and even destroy the Android ecosystem. Fortunately, with the update of the Android system version, many of these unconventional methods of keeping the system alive have become invalid.

For those applications that really need to run in the background, how can we keep them alive gracefully?

Background running whitelist

Starting from Android 6.0, the system has added a sleep mode to save power. After the system has been idle for a period of time, it will kill the processes running in the background. However, the system will have a whitelist of background running applications, and the applications in the whitelist will not be affected. In the native system, you can see this whitelist through "Settings" - "Battery" - "Battery Optimization" - "Non-Optimized Applications". You will usually see the following two:

Next time the product says "XXX can stay alive, why can't we!", you will know how to fight back. Large companies cooperate with mobile phone manufacturers to add their own applications to the whitelist by default. If you are with a large company that can negotiate such cooperation, you don't need to read on.

Fortunately, the system has not abandoned us and allows us to apply to add the application to the whitelist.

First, configure the following permissions in the AndroidManifest.xml file:

 <uses-permission android: name = "android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" /> 

We can use the following methods to determine whether our application is in the whitelist:

 @RequiresApi(api = Build.VERSION_CODES.M)
 private boolean isIgnoringBatteryOptimizations() {
    boolean isIgnoring = false ;
    PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
    if (powerManager != null ) {
        isIgnoring = powerManager.isIgnoringBatteryOptimizations(getPackageName());
 }
 return isIgnoring;
 }

If it is not in the whitelist, you can apply to join the whitelist through the following code:

 @RequiresApi(api = Build.VERSION_CODES.M)
 public void requestIgnoreBatteryOptimizations() {
 try {
        Intent intent = new Intent(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
        intent.setData(Uri.parse( "package:" + getPackageName()));
        startActivity(intent);
 } catch (Exception e) {
 e.printStackTrace();
 }
 }

When applying, a window like this will appear on the app:

As you can see, this system pop-up window will have a reminder that battery life will be affected, so if you want the user to click to allow, there must be relevant instructions. If you want to determine whether the user has clicked to allow, you can call startActivityForResult when applying, and determine again in onActivityResult whether it is in the whitelist.

Manufacturer backend management

One difficulty in Android development is that major mobile phone manufacturers have customized the native system differently, which requires us to make different adaptations. Background management is a good example. Almost every manufacturer has its own background management. Even if the application is added to the background running whitelist, it may still be killed by the manufacturer's own background management.

If you can add the application to the manufacturer's system background management whitelist, you can further reduce the probability of the process being killed. Different manufacturers set it in different places, usually in their own "mobile phone manager", but what is more difficult is that even if it is the same manufacturer's system, different versions may be set in different places.

The ideal approach is to present a graphic operation step to the user according to different mobile phones and even different system versions, and provide a button to jump directly to the specified page for setting. However, it is necessary to adapt to each version of each manufacturer, which is a lot of work. After testing most of the mainstream Android manufacturers' mobile phones with real machines, I sorted out the relevant information of some mobile phones.

First we can define two methods:

 /**
 * Jump to the homepage of the specified application
 */
 private void showActivity(@NonNull String packageName) {
    Intent intent = getPackageManager().getLaunchIntentForPackage(packageName);
 startActivity(intent);
 } 
 
 /**
 * Jump to the specified page of the specified application
 */
 private void showActivity(@NonNull String packageName, @NonNull String activityDir) {
    Intent intent = new Intent();
    intent.setComponent(new ComponentName(packageName, activityDir));
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
 startActivity(intent);
 }

The following are the manufacturers' judgments, jump methods and corresponding setting steps for some mobile phones. The jump method does not guarantee successful jump on all versions, and try catch is required.

Huawei

Manufacturer's judgment:

 public boolean isHuawei() {
    if (Build.BRAND == null ) {
 return   false ;
 } else {
 return Build.BRAND.toLowerCase().equals( "huawei" ) || Build.BRAND.toLowerCase().equals( "honor" );
 }
 }

Jump to the startup management page of Huawei Mobile Manager:

 private void goHuaweiSetting() {
 try {
        showActivity( "com.huawei.systemmanager" ,
 "com.huawei.systemmanager.startupmgr.ui.StartupNormalAppListActivity" );
 } catch (Exception e) {
        showActivity( "com.huawei.systemmanager" ,
 "com.huawei.systemmanager.optimize.bootstart.BootStartActivity" );
 }
 }

Operation steps: Application startup management -> Turn off the application switch -> Turn on Allow automatic startup

Millet

Manufacturer's judgment:

 public   static boolean isXiaomi() {
 return Build.BRAND != null && Build.BRAND.toLowerCase().equals( "xiaomi" );
 }

Jump to the self-start management page of Xiaomi Security Center:

 private void goXiaomiSetting() {
    showActivity( "com.miui.securitycenter" ,
 "com.miui.permcenter.autostart.AutoStartManagementActivity" );
 }

Operation steps: Authorization Management -> Auto-start Management -> Allow application to auto-start

OPPO

Manufacturer's judgment:

 public   static boolean isOPPO() {
 return Build.BRAND != null && Build.BRAND.toLowerCase().equals( "oppo" );
 }

Jump to OPPO Mobile Manager:

 private void goOPPOSetting() {
 try {
        showActivity( "com.coloros.phonemanager" );
 } catch (Exception e1) {
 try {
            showActivity( "com.oppo.safe" );
        } catch (Exception e2) {
 try {
                showActivity( "com.coloros.oppoguardelf" );
            } catch (Exception e3) {
                showActivity( "com.coloros.safecenter" );
 }
 }
 }
 }

Operation steps: Permissions and Privacy -> Auto-start Management -> Allow the application to auto-start

VIVO

Manufacturer's judgment:

 public   static boolean isVIVO() {
 return Build.BRAND != null && Build.BRAND.toLowerCase().equals( "vivo" );
 }

Jump to VIVO Mobile Manager:

 private void goVIVOSetting() {
    showActivity( "com.iqoo.secure" );
 }

Operation steps: Permission management -> Auto-start -> Allow application to auto-start

Meizu

Manufacturer's judgment:

 public   static boolean isMeizu() {
 return Build.BRAND != null && Build.BRAND.toLowerCase().equals( "meizu" );
 }

Jump to Meizu Mobile Manager:

 private void goMeizuSetting() {
    showActivity( "com.meizu.safe" );
 }

Operation steps: Permission Management -> Background Management -> Click on the application -> Allow background running

Samsung

Manufacturer's judgment:

 public   static boolean isSamsung() {
 return Build.BRAND != null && Build.BRAND.toLowerCase().equals( "samsung" );
 }

Jump to Samsung Smart Manager:

 private void goSamsungSetting() {
 try {
        showActivity( "com.samsung.android.sm_cn" );
 } catch (Exception e) {
        showActivity( "com.samsung.android.sm" );
 }
 }

Operation steps: Automatically run applications -> Turn on the application switch -> Battery management -> Unmonitored applications -> Add applications

LeTV

Manufacturer's judgment:

 public   static boolean isLeTV() {
 return Build.BRAND != null && Build.BRAND.toLowerCase().equals( "letv" );
 }

Jump to LeTV Mobile Manager:

 private void goLetvSetting() {
    showActivity( "com.letv.android.letvsafe" ,
 "com.letv.android.letvsafe.AutobootManageActivity" );
 }

Operation steps: Auto-start management -> Allow application to auto-start

hammer

Manufacturer's judgment:

 public   static boolean isSmartisan() {
 return Build.BRAND != null && Build.BRAND.toLowerCase().equals( "smartisan" );
 }

Jump to mobile phone management:

 private void goSmartisanSetting() {
    showActivity( "com.smartisanos.security" );
 }

Operation steps: Permission Management -> Auto-start Permission Management -> Click Apply -> Allow to be started by the system

Tribute to friends?

In the running app I made before, I added a permission setting page in the settings and put the settings mentioned above in it. Recently, I found that a competitor, Moudong, also followed up. Figure 1 was made by us, and Figure 2 was made by Moudong:

Moudong paid tribute to me from all aspects, from the design, from the poor copywriting I wrote, and even from the pictures I took from more than a dozen mobile phones. I am grateful for Moudong's recognition, but I heard this sentence at a press conference recently: While paying tribute, can I say thank you?

The tribute from Moudong, on the one hand, shows that there is indeed a problem that processes are easy to be killed and difficult to keep alive. On the other hand, it also shows that the method of guiding users to set up whitelists is effective.