Create Cron on Android

I have found a solution to my problem fulfilling the points that I wanted the cron to have as described in the question.

Explanation

After researching and looking to use the Timer in the OnBootReceiver as @sioesi advised me, I found that they AlarmManagerconsume less resources and according to this StackOverflow question it is more advisable to use them, since they work at the Kernel level. In this link you can see how an alarm is defined and the different types that exist.

On the other hand, to guarantee that the service operations are carried out without the service falling asleep and not completing its operations, I have decided to use wakefulBroadcastReceiverboth in ConnectivityReceiverand OnAlarmWakefulReceiver, as explained here . Since these Receivers are in charge of calling the service that will carry out the operations and it is not important that they remain without finishing their operations, to guarantee their correct operation.

Code

I have modified the OnBootReceiver so that it creates an alarm that will take care of waking up the dispatch process every 10 minutes in my case, regardless of whether the application is running or not. The code would be as follows:

public class OnBootReceiver extends BroadcastReceiver {

    private static final String TAG = OnBootReceiver.class.getSimpleName();

    private static final int PERIOD = 1000 * 60 * 10;  // 10 minutes

    @Override
    public void onReceive(Context context, Intent intent) {

        if (intent.getAction().equals("android.intent.action.BOOT_COMPLETED")) {
            setAlarm(context);
        }
    }

    public static void setAlarm(Context context) {
        AlarmManager mgr =(AlarmManager)context.getSystemService(Context.ALARM_SERVICE);

        //configuramos una alarma para que se haga el envio de las estadisticas sino esta creada ya
        boolean alarmUp = (PendingIntent.getBroadcast(context, 0,
                new Intent(context, OnAlarmWakefulReceiver.class),PendingIntent.FLAG_NO_CREATE) != null);

        if (!alarmUp){    
            mgr.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP,
                    SystemClock.elapsedRealtime()+60000,
                    PERIOD,
                    getPendingIntent(context));
        }else{
            Log.i(TAG, "EnvioEstadisService: Alarm is already active");
        }
    }

    public static void cancelAlarm(Context ctxt) {
        AlarmManager mgr=(AlarmManager)ctxt.getSystemService(Context.ALARM_SERVICE);

        mgr.cancel(getPendingIntent(ctxt));
    }

    private static PendingIntent getPendingIntent(Context ctxt) {
        Intent i=new Intent(ctxt, OnAlarmWakefulReceiver.class);

        return(PendingIntent.getBroadcast(ctxt, 0, i, PendingIntent.FLAG_UPDATE_CURRENT));
    }
 }

In addition, to call the service for sending statistics from the alarm , I have created the followingReceiver

public class OnAlarmWakefulReceiver extends WakefulBroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {

        Intent i =  new Intent(context, EnvioEstadisticasService.class);
        i.putExtra(Constants.proviene, Constants.provAlarm);

        startWakefulService(context, i);
    }
}

to the manifest of the question should be added:

<receiver android:name=".cron.OnAlarmWakefulReceiver"></receiver>

the ConnectivityReceiver would be the same as the one in the question except that it would have to be added i.putExtra(Constants.proviene, Constants.provConnectivity);when making the intent to be able to tell the Service from where it is called

And finally , the following code should be added to the serviceWakefulBroadcastReceiver to indicate to those who have called it that it has finished performing the operations:

 // Release the wake lock provided by the WakefulBroadcastReceiver.
 if(Constants.provConnectivity.equals(proviene))
      ConnectivityReceiver.completeWakefulIntent(intent);
 else
     OnAlarmWakefulReceiver.completeWakefulIntent(intent);

I think I have described it quite detailed, but if there is something that is not very clear I will try to explain it as best as possible by editing the answer.

The first thing you must be clear about in order to execute a task equivalent to a cronjobis that it must be an asynchronous task. For this you can see the Android AsyncTask Android documentation .

The important thing is that this task is always 1 and only 1 its instance. Therefore you have to occupy the design pattern Singleton. You can create a class that extends from AsyncTask, you create the methods.

EDITION

Inside your service you can create a class

private class MyAsyncTask extends AsyncTask < String, Void, String > {

    @Override
    protected String doInBackground(String...params) {

        return "Executed";
    }

    @Override
    protected void onPostExecute(String result) {

    }

    @Override
    protected void onPreExecute() {}

    @Override
    protected void onProgressUpdate(Void...values) {}
}

After that in your service you identify when the receiver identifies:

public class OnBootReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        if ("android.intent.action.BOOT_COMPLETED".equals(intent.getAction())) {
            new Timer().schedule(new TimerTask() {
                @Override
                public void run() {
                    new MyAsyncTask().execute();
                }
            }, 0, 10000); //Son ms
        }
    }
}

Where doInBackgrounddoes the task of your function and then executes onPostExecute. Use the method onProgressUpdateis to show progress of your task, for example a counter, a progress bar etc etc. I don't know if it's so necessary, but you can use it!

I couldn't be very specific with the code as I don't fully understand your exercise, but I hope it can guide you!

It's better to do it with ScheduledExecutorService, since the WakefulBroadcastReceiver class is deprecated. Schedule also works when the app is closed.

I am going to put an example:

This class is responsible for printing a toast on the screen (this is where you have to do the actions you want in the background). It will do this when it receives an alarm.

public class ReadMessagesService extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
    Toast toastSend = Toast.makeText(context, "Esto es una alarma", Toast.LENGTH_SHORT);
    toastSend.show();
}

To configure an alarm you simply have to do it with the AlarmManager class, indicate the Intent you want it to execute and indicate the period with the setRepeating function.

private void setAlarm(){
    AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
    Intent intent = new Intent(this, ReadMessagesService.class);
    PendingIntent pendingIntent = PendingIntent.getBroadcast(this, 0, intent,0);
    alarmManager.setRepeating(AlarmManager.RTC, 0, TIME_ALARM, pendingIntent);
}

If you have any questions do not hesitate to ask. All the best.

The most common option is via ScheduledExecutorService

final Runnable myTask = new Runnable() {
                public void run() {
                    //llama método cada x segundos.
                    Servicio(); 
                }
            };
            ScheduledExecutorService timer = Executors.newSingleThreadScheduledExecutor();
            timer.scheduleAtFixedRate(myTask, 10, 10, TimeUnit.SECONDS);