Quando si inizia a programmare in Android, ci si abitua a veder funzionare il proprio codice all’interno di un’applicazione. Eppure le API messe a disposizione ci permettono di interagire con il sistema operativo in una moltitudine di tempistiche.

In questo post, ci occupiamo di far attivare delle operazioni in tempi prestabiliti anche se la nostra applicazione non è in uso da parte dell’utente. Allo scattare di questo “allarme” verrà invocato del nostro codice che potrà svolgere qualsiasi operazione anche se, nel nostro caso, riguarderà per lo più l’apparizione di una notifica nella status bar. Pertanto, nell’esempio che segue (il cui codice è scaricabile qui)  vedremo al lavoro insieme tre tipi di componenti:

• l’AlarmManager, servizio di sistema che permette di attivare in momenti precisi o a intervalli prestabiliti una determinata azione ;
• un BroadcastReceiver, componente che ha la capacità di restare dormiente finchè non viene attivata da un messaggio (in questo caso lanciato dall’AlarmManager);
• il NotificationManager, altro servizio di sistema, specializzato nel far apparire notifiche nella barra di stato del dispositivo.

AlarmManager: tempistiche di attivazione

L’AlarmManager permette di attivare del codice al momento richiesto. Avrà bisogno di ricevere nostre istruzioni riguardanti le tempistiche e le modalità di attivazione ed un Intent che descrive l’azione da intraprendere.

Per avere a disposizione un’istanza dell’AlarmManager faremo questo:

AlarmManager manager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);

e, nel momento della necessità, invocheremo un suo metodo per richiedere la temporizzazione di funzionalità:

int intervallo = 10000;
manager.setInexactRepeating(AlarmManager.RTC_WAKEUP, 
                               System.currentTimeMillis(), 
                                   intervallo, 
                                       pendingIntent);

In questo caso, si richiede l’impostazione di un allarme periodico a partire da ora (System.currentTimeMillis) che scatti ogni 10 secondi (i millisecondi impostati nella variabile intervallo). L’allarme è di tipo RTC ossia scatta all’ora impostata, in alternativa si può utilizzare un allarme di tipo ELAPSED_REALTIME che si innesca dopo un determinato periodo di tempo contato a partire dal boot di sistema.

Il riferimento pendingIntent che appare come ultimo parametro rappresenta l’azione che deve essere svolta ad ogni allarme ed è di classe PendingIntent. Possiamo considerare questi oggetti dei contenitori di Intent che li conservano lasciandoli in sospeso fino al momento dell’attivazione.

BroadcastReceiver: attivazione di codice su richiesta

Il BroadcastReceiver viene creato come una normale classe Java che vede al suo interno solo un metodo, onReceive, contenente il codice da attivare al momento della ricezione di un Intent. Nel nostro esempio, questo Intent da inviare sarà consegnato all’AlarmManager incapsulato nel PendingIntent.

Questa la struttura di un BroadcastReceiver:

public class MyReceiver extends BroadcastReceiver {

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

       /*
        * codice da eseguire al momento dell'attivazione
        */

    }
}

Come si vede, l’implementazione di un componente simile è banalissima. Il metodo onReceive riceverà in input un riferimento al Context per poter avviare qualunque richiesta nel sistema ed un Intent, quello con cui è stato attivato il Receiver.

Da non dimenticare che un BroadcastReceiver, in quanto componente dell’applicazione, va dichiarato nel file AndroidManifest.xml:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="....">

    <application
       ... 
      >

        <receiver
            android:name=".MyReceiver"
            android:enabled="true"
            android:exported="false" />

    </application>

</manifest>

dove, essenzialmente non passeremo altro che il nome della classe che rappresenta il Receiver.

NotificationManager: informare l’utente al momento giusto

Nel nostro esempio, all’interno del metodo onReceive del BroadcastReceiver, richiederemo l’apparizione di una notifica all’utente e lo faremo così:

  NotificationCompat.Builder builder =
                new NotificationCompat.Builder(context)
                        .setSmallIcon(android.R.drawable.ic_dialog_alert)
                        .setContentTitle("Titolo della notifica")
                        .setContentIntent(resultPendingIntent)
                        .setContentText("Descrizione dell'evento");

Con il Builder costruiremo la notifica ma non la faremo ancora apparire. Quello che si vede nel codice richiederà che la nostra notifica abbia un titolo, un testo, un’icona piccola ed un’azione da svolgere attivata al momento in cui la notifica stessa venga cliccata: anche questa azione pronta all’uso viene impacchettata in un PendingIntent.

Per quanto riguarda, l’apparizione della notifica dovremo utilizzare il seguente servizio di sistema:

NotificationManager manager =
                (NotificationManager) 
                       context.getSystemService(Context.NOTIFICATION_SERVICE);
manager.notify(NOTIFICATION_ID, builder.build());

dove il metodo notify non chiede altro che un identificativo numerico che contraddistingua la notifica e il risultato del metodo build invocato sull’oggetto builder con cui abbiamo preparato la notifica.

L’esempio: mettiamo tutto insieme

La nostra applicazione di esempio sarà molto semplice: un layout con due pulsanti di cui il primo – etichettato come “Attiva allarme” – indicherà al sistema di “svegliare” il nostro BroadcastReceiver ogni dieci secondi ed il secondo – chiamato “Ferma allarme” – servirà a disattivare tali segnalazioni. L’aspetto interessante è che la gestione degli avvisi è totalmente demandata al sistema operativo, per mezzo dell’AlarmManager, quindi la loro propagazione sarà indipendente dalla nostra Activity che, nel frattempo potrà essere chiusa.

Ecco il layout:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="10dp"
    android:orientation="vertical">

    <Button android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:layout_marginTop="20dp"
        android:text="Attiva allarme"
        android:onClick="impostaAllarme"/>

    <Button android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_horizontal"
        android:layout_marginTop="20dp"
        android:text="Ferma allarme"
        android:onClick="cancellaAllarme"/>
  </LinearLayout>

e questo il risultato che produrrà:

I pulsanti attiveranno i metodi dell’Activity impostaAllarme e cancellaAllarme il cui effetto sarà quello di interagire con il servizio AlarmManager come accennato in precedenza:

public class MainActivity extends AppCompatActivity {

    private PendingIntent pendingIntent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Intent intent = new Intent(this, AlarmReceiver.class);
        pendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);

    }

    public void impostaAllarme(View v)
    {
        AlarmManager manager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
        int intervallo = 10000;

        manager.setInexactRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), intervallo, pendingIntent);
        Toast.makeText(this, "Attivato!", Toast.LENGTH_SHORT).show();
    }

    public void cancellaAllarme(View v)
    {
        AlarmManager manager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
        manager.cancel(pendingIntent);
        Toast.makeText(this, "Cancellato!", Toast.LENGTH_SHORT).show();
    }
}

A tal proposito, si noti che per cancellare un allarme già impostato è necessario invocare il metodo cancel passando un PendingIntent che si riferisce alla medesima azione.

Nell’onCreate,  il PendingIntent viene inizializzato con il metodo getBroadcast che mirerà ad attivare il BroadcastReceiver che definiremo così:

public class AlarmReceiver extends BroadcastReceiver {

    private static final int NOTIFICATION_ID = 5555;
    @Override
    public void onReceive(Context context, Intent intent) {

        Intent actionIntent = new Intent(context, MainActivity.class);

        PendingIntent pending =
                PendingIntent.getActivity(
                        context,
                        0,
                        actionIntent,
                        PendingIntent.FLAG_UPDATE_CURRENT
                );

        NotificationCompat.Builder builder =
                new NotificationCompat.Builder(context.getApplicationContext())
                        .setSmallIcon(android.R.drawable.ic_dialog_alert)
                        .setContentTitle("Orario: "+new Date().toString())
                        .setContentIntent(pending)
                        .setContentText("Allarme scattato...");


        NotificationManager manager =
                (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        manager.notify(NOTIFICATION_ID, builder.build());

    }
}

Nel metodo onReceive, prepareremo la notifica per l’utente, l’attiveremo e, mediante l’azione impostata al suo interno, si potrà richiamare l’Activity per interrompere la schedulazione degli allarmi cliccando sul tasto “Ferma allarme”.

Il semplice esempio visto in questo post non fa nulla di particolare ma imposta un’architettura minimale di uno schema molto ricorrente: attivazione secondo tempistiche proprie di un allarme (singolo o ricorrente), attivazione di codice anche quando l’applicazione non è in uso, svolgimento delle operazioni e, al termine, ove necessarie, attività di notifica all’utente. Il tutto potrà essere personalizzato per i propri scopi, anche solo sostituendo il codice contenuto all’interno del metodo onReceive del BroadcastReceiver.