Solution for Android alarm setting

Setting an alarm on Android is not as simple as setting an alarm on iOS. Developers who have done this know how difficult it is. Here is my solution to setting an alarm on Android.

[[172016]]

Main Issues

1. API19 started to modify the mechanism of AlarmManager.
2. After the application is killed, the set alarm will not ring.
3. Entering Doze mode in versions 6.0 and above will stop JobScheduler from working.
4. After the phone is restarted, the alarm becomes invalid.

Modification of AlarmManager mechanism above API19

Before API 19, AlarmManager provided three methods to set alarms. Since the alarm only needs to be set once, the method set(int type, long startTime, PendingIntent pi) is used. Starting from API 19, the mechanism of AlarmManager is inaccurate transmission. The operating system will convert the alarm to minimize wake-up and battery usage.

Because the previous program did not handle the alarm settings above API19, setting the alarm on phones above 4.4 was unresponsive (there was no alarm even if the application was not killed).

Therefore, setting the alarm needs to be processed and set according to the API version. The code is as follows:

 AlarmManager am = (AlarmManager) getActivity()
       .getSystemService(Context.ALARM_SERVICE);
 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
    am.setExact(AlarmManager.RTC_WAKEUP, TimeUtils
        .stringToLong(recordTime, TimeUtils.NO_SECOND_FORMAT), sender);
 } else {
    am.set (AlarmManager.RTC_WAKEUP, TimeUtils
        .stringToLong(recordTime, TimeUtils.NO_SECOND_FORMAT), sender);
 }

This ensures that the alarm is set even when the application is not killed.

What to do when an application is killed

After the application is killed, the set alarm becomes invalid. Here, the daemon process and gray keep alive are used to ensure that the background alarm service is not killed. When the application and the alarm service are killed, the daemon process and gray keep alive restart the alarm service and reset the alarm.

Regarding the processing of daemon processes, an open source daemon library is used here. Android-AppDaemon

Add the open source daemon Android-AppDaemon to the onCreate of the alarm service. The code is as follows:

 @Override
 public void onCreate() {
 super.onCreate();
    Daemon.run(DaemonService.this,
           DaemonService.class, Daemon.INTERVAL_ONE_MINUTE);
 startTimeTask();
 grayGuard();
 }

To further ensure the survival of the alarm service, add gray keep-alive (using the system vulnerability to start the foreground Service). The code is as follows:

 private void grayGuard() {
    if (Build.VERSION.SDK_INT < 18) {
 //API < 18, this method can effectively hide the icon on the Notification
        startForeground(GRAY_SERVICE_ID, new Notification());
 } else {
        Intent innerIntent = new Intent(this, DaemonInnerService.class);
        startService(innerIntent);
        startForeground(GRAY_SERVICE_ID, new Notification());
 } 
 
 //Send a wake-up broadcast to restart the hung UI process
    AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
    Intent alarmIntent = new Intent();
    alarmIntent.setAction(WakeReceiver.GRAY_WAKE_ACTION);
    PendingIntent operation = PendingIntent.getBroadcast(this,
        WAKE_REQUEST_CODE, alarmIntent, PendingIntent.FLAG_UPDATE_CURRENT);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        alarmManager.setWindow(AlarmManager.RTC_WAKEUP,
            System.currentTimeMillis(), ALARM_INTERVAL, operation);
 } else {
        alarmManager.setInexactRepeating(AlarmManager.RTC_WAKEUP,
            System.currentTimeMillis(), ALARM_INTERVAL, operation);
 }
 } 
 
 /**
 * Gray keep-alive method for platforms with API >= 18
 */
 public   static class DaemonInnerService extends Service { 
 
 @Override
 public void onCreate() {
        Log.i(LOG_TAG, "InnerService -> onCreate" );
 super.onCreate();
 } 
 
 @Override
 public   int onStartCommand(Intent intent, int flags, int startId) {
        Log.i(LOG_TAG, "InnerService -> onStartCommand" );
        startForeground(GRAY_SERVICE_ID, new Notification());
        //stopForeground( true );
 stopSelf();
 return super.onStartCommand(intent, flags, startId);
 } 
 
 @Override
 public IBinder onBind(Intent intent) {
        throw new UnsupportedOperationException( "Not yet implemented" );
 } 
 
 @Override
 public void onDestroy() {
        Log.i(LOG_TAG, "InnerService -> onDestroy" );
 super.onDestroy();
 }
 }

The above operation can improve the survival of the alarm service as much as possible. However, on mobile phones with version 5.0 or higher, the alarm service will be completely killed when the system's built-in Clean function is used. In order to solve the problem above version 5.0, the new feature JobScheduler of version 5.0 or higher is introduced here.

JobScheduler 5.0 and above

You can read this article first about the new JobScheduler API in 5.0.

Here, we use JobScheduler 5.0 or higher to create a scheduled task, which periodically checks whether the alarm service exists. If it does not exist, we restart the alarm service. (Here, I set the alarm service to be checked once every minute)

When entering the application, check whether the current system is 5.0 or above. If it is, start the JobScheduler service. The code is as follows:

 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    mJobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
    JobInfo.Builder builder = new JobInfo.Builder(JOB_ID,
            new ComponentName(getPackageName(), JobSchedulerService.class.getName())); 
 
 builder.setPeriodic(60 * 1000); //Run every 60 seconds
    builder.setRequiresCharging( true );
 builder.setPersisted( true ); //Set whether to re-execute the task after the device restarts
    builder.setRequiresDeviceIdle( true ); 
 
    if (mJobScheduler.schedule(builder.build()) <= 0) {
        //If something goes wrong
 }
 }

The builder.setPersisted(true); method is used to check whether to re-execute the task after the device is restarted. It has been tested that the task can be restarted.

The above operation further ensures that the alarm service is restarted after being killed. However, Doze mode is introduced in 6.0 and above. When a mobile phone above 6.0 enters this mode, JobScheduler will stop working.

Doze mode processing above 6.0

In order to allow JobScheduler to work in Doze mode in versions above 6.0, special processing is done here for Doze mode above 6.0 - ignoring battery optimization.

• Add permissions in Manifest.xml.

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

• When setting the alarm, determine whether the system is 6.0 or above. If so, determine whether to ignore battery optimization. The code to determine whether to ignore battery optimization is as follows:

 TargetApi(Build.VERSION_CODES.M)
 public   static boolean isIgnoringBatteryOptimizations(Activity activity){
    String packageName = activity.getPackageName();
    PowerManager pm = (PowerManager) activity
            .getSystemService(Context.POWER_SERVICE);
    if (pm.isIgnoringBatteryOptimizations(packageName)) {
 return   true ;
 } else {
 return   false ;
 }
 }

If the battery optimization is not ignored, a reminder dialog box will pop up to prompt the user to ignore the battery optimization operation. The code is as follows:

 /**
 * For Doze mode above N
 *
 * @param activity
 */
 public   static void isIgnoreBatteryOption(Activity activity) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
 try {
            Intent intent = new Intent();
            String packageName = activity.getPackageName();
            PowerManager pm = (PowerManager) activity.getSystemService(Context.POWER_SERVICE);
            if (!pm.isIgnoringBatteryOptimizations(packageName)) {
 // intent.setAction(Settings.ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS);
                intent.setAction(Settings.ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS);
                intent.setData(Uri.parse( "package:" + packageName));
                activity.startActivityForResult(intent, REQUEST_IGNORE_BATTERY_CODE);
 }
        } catch (Exception e) {
            e.printStackTrace();
 }
 }
 }

Rewrite the onActivityResult method in the interface to capture the user's selection. For example, the code is as follows:

 @Override
 protected void onActivityResult( int requestCode, int resultCode, Intent data) {
    if (resultCode == RESULT_OK) {
        if (requestCode == BatteryUtils.REQUEST_IGNORE_BATTERY_CODE){
 //TODO something
 }
    } else if (resultCode == RESULT_CANCELED){
        if (requestCode == BatteryUtils.REQUEST_IGNORE_BATTERY_CODE){
 ToastUtils.show(getActivity(), "Please turn on ignoring battery optimization~" );
 }
 }
 }

Replenish

When the application is killed, but the alarm service is not killed, the alarm is set again. This means that the set alarm is not put into the alarm service. So in this case, the set alarm will be invalid. To solve this problem, use AIDL (the alarm service is in another process and needs inter-process communication) to call the reset alarm method of the alarm service to reset the alarm.

Start the alarm service in the onCreat() method of the application, and then bind the alarm service.

 private void initAlarmService() {
 startService(new Intent(this, DaemonService.class)); //Start the alarm service
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
 //JobScheduler
 ...
 } 
 
 //Bind alarm service
    Intent intent = new Intent(this, DaemonService.class);
    intent.setAction( "android.intent.action.DaemonService" );
    bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
 }

In the onDestroy() method, call the reset alarm method of the alarm service. The code is as follows:

 @Override
 protected void onDestroy() {
 super.onDestroy();
 try {//Judge whether there is an alarm, if not, turn off the alarm service
        String alarm = localPreferencesHelper.getString(LocalPreferencesHelper.ALARM_CLOCK);
        if (daemonService != -1 && mIRemoteService != null ) {
 // android.os.Process.killProcess(daemonService);
            mIRemoteService.resetAlarm();
 } 
         
        if (!alarm.equals( "[]" )) {
            if (daemonService != -1) {
                startService(new Intent(this, DaemonService.class));
 }
 } else {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                mJobScheduler.cancel(JOB_ID);
 } 
 
 }
 unbindService(mConnection); //Unbind service.
 } catch (Exception e) { 
 
 }
 }

Here is a note, when the service is started and bound, unbindService will not stop the service. For details, please refer to this article.

***

The above does not mean that the alarm clocks of all Android phones can be used. This just tries to ensure that most phones can be used.