Come verificare se AlarmManager ha già impostato un allarme?

All'avvio della mia app, voglio che controlli se un determinato allarme (registrato tramite AlarmManager) è già impostato e in esecuzione. I risultati di Google sembrano indicare che non c'è modo di farlo. È ancora corretto? Devo fare questo controllo per avvisare l'utente prima di intraprendere qualsiasi azione per creare un nuovo allarme.

A seguito del commento pubblicato, ecco la soluzione dettagliata. Supponiamo che tu abbia registrato un allarme ripetuto con un intento in sospeso come questo:

Intent intent = new Intent("com.my.package.MY_UNIQUE_ACTION");
PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, 
                                      intent, PendingIntent.FLAG_UPDATE_CURRENT);
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(System.currentTimeMillis());
calendar.add(Calendar.MINUTE, 1);

AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), 1000 * 60, pendingIntent);

Il modo in cui verifichi se è attivo è:

boolean alarmUp = (PendingIntent.getBroadcast(context, 0, 
        new Intent("com.my.package.MY_UNIQUE_ACTION"), 
        PendingIntent.FLAG_NO_CREATE) != null);

if (alarmUp)
{
    Log.d("myTag", "Alarm is already active");
}

La chiave qui è la FLAG_NO_CREATEquale come descritto nel javadoc: if the described PendingIntent **does not** already exists, then simply return null(invece di crearne uno nuovo)

Per gli altri che potrebbero aver bisogno di questo, ecco una risposta.

Uso adb shell dumpsys alarm

Puoi sapere che la sveglia è stata impostata e quando stanno andando su allarme e intervallo. Inoltre, quante volte questo allarme è stato invocato.

Esempio funzionante con ricevitore (la risposta principale era solo con l'azione).

//starting
AlarmManager alarmManager = (AlarmManager) getActivity().getSystemService(Context.ALARM_SERVICE);
Intent intent = new Intent(getActivity(), MyReceiver.class);
intent.setAction(MyReceiver.ACTION_ALARM_RECEIVER);//my custom string action name
PendingIntent pendingIntent = PendingIntent.getBroadcast(getActivity(), 1001, intent, PendingIntent.FLAG_CANCEL_CURRENT);//used unique ID as 1001
alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(), aroundInterval, pendingIntent);//first start will start asap

//and stopping
Intent intent = new Intent(getActivity(), MyReceiver.class);//the same as up
intent.setAction(MyReceiver.ACTION_ALARM_RECEIVER);//the same as up
PendingIntent pendingIntent = PendingIntent.getBroadcast(getActivity(), 1001, intent, PendingIntent.FLAG_CANCEL_CURRENT);//the same as up
alarmManager.cancel(pendingIntent);//important
pendingIntent.cancel();//important

//checking if alarm is working with pendingIntent
Intent intent = new Intent(getActivity(), MyReceiver.class);//the same as up
intent.setAction(MyReceiver.ACTION_ALARM_RECEIVER);//the same as up
boolean isWorking = (PendingIntent.getBroadcast(getActivity(), 1001, intent, PendingIntent.FLAG_NO_CREATE) != null);//just changed the flag
Log.d(TAG, "alarm is " + (isWorking ? "" : "not") + " working...");

Vale la pena ricordare:

Se l'applicazione di creazione (processo) successiva recupera lo stesso tipo di PendingIntent (stessa operazione , stessi Intenti - azione, dati, categorie, componenti, flag ), riceverà un PendingIntent che rappresenta lo stesso token se è ancora valido e può quindi chiamare cancel () per rimuoverlo.

In breve, PendingIntent dovrebbe avere le stesse funzionalità (operazione e struttura dell'intento) per assumerne il controllo.

Nota questa citazione dai documenti per il metodo impostato di Alarm Manager:

Se esiste già un allarme per questo Intento programmato (con l'uguaglianza di due intenti definito da Intent.filterEquals), verrà rimosso e sostituito da questo.

Se sai di voler impostare la sveglia, non devi preoccuparti di controllare se esiste già o meno. Crealo ogni volta che la tua app si avvia. Sostituirai tutti gli allarmi passati con gli stessi Intent.

È necessario un approccio diverso se si sta tentando di calcolare quanto tempo è rimasto su un allarme precedentemente creato o se è davvero necessario sapere se tale allarme esiste. Per rispondere a queste domande, considera di salvare i dati pref condivisi nel momento in cui crei l'allarme. È possibile memorizzare il timestamp dell'orologio nel momento in cui è stata impostata la sveglia, l'ora in cui si prevede che la sveglia si spenga e il periodo di ripetizione (se si imposta una sveglia ripetuta).

Ho 2 allarmi. Sto usando intento con extra invece di azione per identificare gli eventi:

Intent i = new Intent(context, AppReciever.class);
i.putExtra("timer", "timer1");

il fatto è che con gli extra diff l'intento (e l'allarme) non saranno unici. Quindi, per poter identificare quale allarme è attivo o meno, ho dovuto definire le differenze requestCode:

boolean alarmUp = (PendingIntent.getBroadcast(context, MyApp.TIMER_1, i, 
                    PendingIntent.FLAG_NO_CREATE) != null);

ed ecco come è stato creato l'allarme:

public static final int TIMER_1 = 1;
public static final int TIMER_2 = 2;

PendingIntent pending = PendingIntent.getBroadcast(context, TIMER_1, i,
            PendingIntent.FLAG_CANCEL_CURRENT);
setInexactRepeating(AlarmManager.RTC_WAKEUP,
            cal.getTimeInMillis(), AlarmManager.INTERVAL_DAY, pending);
pending = PendingIntent.getBroadcast(context, TIMER_2, i,
            PendingIntent.FLAG_CANCEL_CURRENT);
setInexactRepeating(AlarmManager.RTC_WAKEUP,
            cal.getTimeInMillis(), AlarmManager.INTERVAL_DAY, pending);

Ho appena trovato un'altra soluzione, sembra funzionare per me

Intent myIntent = new Intent(MainActivity.this, MyReceiver.class);

boolean isWorking = (PendingIntent.getBroadcast(MainActivity.this, 0, myIntent, PendingIntent.FLAG_NO_CREATE) != null);
if (isWorking) {Log.d("alarm", "is working");} else {Log.d("alarm", "is not working");}

if(!isWorking) {
    pendingIntent = PendingIntent.getBroadcast(MainActivity.this, 0, myIntent,    PendingIntent.FLAG_UPDATE_CURRENT);
    alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
    int timeNotif = 5 * 60 * 1000;//time in ms, 7*24*60*60*1000 for 1 week
    Log.d("Notif", "Notification every (ms): " + timeNotif);
    alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(), timeNotif, pendingIntent);
    }

Mentre quasi tutti qui hanno dato la risposta corretta, nessun organismo ha spiegato su quali basi funzionano gli allarmi

Puoi effettivamente saperne di più AlarmManagere come funziona qui . Ma ecco la risposta rapida

In AlarmManagerpratica vedrai pianificazioni PendingIntenta qualche ora in futuro. Quindi, per annullare l'allarme programmato è necessario annullare il PendingIntent.

Prendi sempre nota di due cose durante la creazione di PendingIntent

PendingIntent.getBroadcast(context,REQUEST_CODE,intent, PendingIntent.FLAG_UPDATE_CURRENT);

• Codice richiesta: funge da identificatore univoco
• Flag: definisce il comportamento di PendingIntent

Ora per verificare se l'allarme è già programmato o per annullare l'allarme, è sufficiente accedere alla stessa PendingIntent. Questo può essere fatto se si utilizza lo stesso codice di richiesta e si utilizza FLAG_NO_CREATEcome mostrato di seguito

PendingIntent pendingIntent=PendingIntent.getBroadcast(this,REQUEST_CODE,intent,PendingIntent.FLAG_NO_CREATE);

if (pendingIntent!=null)
   alarmManager.cancel(pendingIntent);

Con FLAG_NO_CREATEesso tornerà nullse il PendingIntentnon esiste già. Se esiste già, restituisce riferimento all'esistentePendingIntent

Ho creato un semplice script bash (stupido o no), che estrae i long dalla shell adb, li converte in timestamp e lo mostra in rosso.

echo "Please set a search filter"
read search

adb shell dumpsys alarm | grep $search | (while read i; do echo $i; _DT=$(echo $i | grep -Eo 'when\s+([0-9]{10})' | tr -d '[[:alpha:][:space:]]'); if [ $_DT ]; then echo -e "\e[31m$(date -d @$_DT)\e[0m"; fi; done;)

Provalo ;)

    Intent intent = new Intent("com.my.package.MY_UNIQUE_ACTION");
            PendingIntent pendingIntent = PendingIntent.getBroadcast(
                    sqlitewraper.context, 0, intent,
                    PendingIntent.FLAG_NO_CREATE);

FLAG_NO_CREATE non viene creato con l'intento in sospeso in modo che dia un valore booleano falso.

            boolean alarmUp = (PendingIntent.getBroadcast(sqlitewraper.context, 0,
                    new Intent("com.my.package.MY_UNIQUE_ACTION"),
                    PendingIntent.FLAG_NO_CREATE) != null);

            if (alarmUp) {
                System.out.print("k");

            }

            AlarmManager alarmManager = (AlarmManager) sqlitewraper.context
                    .getSystemService(Context.ALARM_SERVICE);
            alarmManager.setRepeating(AlarmManager.RTC_WAKEUP,
                    System.currentTimeMillis(), 1000 * 60, pendingIntent);

Dopo che AlarmManager verifica il valore di Intento in sospeso, questo diventa vero perché AlarmManager aggiorna la bandiera dell'intento in sospeso.

            boolean alarmUp1 = (PendingIntent.getBroadcast(sqlitewraper.context, 0,
                    new Intent("com.my.package.MY_UNIQUE_ACTION"),
                    PendingIntent.FLAG_UPDATE_CURRENT) != null);
            if (alarmUp1) {
                System.out.print("k");

            }

Ho l'impressione che non ci sia modo di farlo, sarebbe bello però.

È possibile ottenere un risultato simile registrando un Alarm_last_set_time da qualche parte e avendo un On_boot_starter BroadcastReciever: BOOT_COMPLETED in qualche modo.