Como verificar se o AlarmManager já possui um alarme definido?

Quando meu aplicativo é iniciado, quero verificar se um alarme específico (registrado pelo AlarmManager) já está definido e em execução. Os resultados do google parecem indicar que não há como fazer isso. Isso ainda está correto? Preciso fazer essa verificação para aconselhar o usuário antes que qualquer ação seja tomada para criar um novo alarme.

Após o comentário publicado por Ron, aqui está a solução detalhada. Digamos que você registrou um alarme repetido com uma intenção pendente como esta:

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);

A maneira como você verificaria se está ativo é:

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");
}

A chave aqui é a FLAG_NO_CREATEque, conforme descrito no javadoc: if the described PendingIntent **does not** already exists, then simply return null(em vez de criar um novo)

Para outras pessoas que possam precisar disso, aqui está uma resposta.

Usar adb shell dumpsys alarm

Você pode saber que o alarme foi definido e quando eles vão alarmar e intervalo. Também quantas vezes esse alarme foi chamado.

Exemplo de trabalho com o receptor (a resposta principal foi apenas com ação).

//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 mencionar:

Se o aplicativo de criação (processo) recuperar novamente o mesmo tipo de PendingIntent (a mesma operação , a mesma Intent - ação, dados, categorias, componentes, sinalizadores ), ele receberá um PendingIntent representando o mesmo token, se isso ainda for válido, e pode chamar cancel () para removê-lo.

Em resumo, seu PendingIntent deve ter os mesmos recursos (estrutura de operação e intenção) para assumir o controle sobre ele.

Observe esta citação dos documentos para o método definido do Gerenciador de alarmes:

Se já houver um alarme para este Intent agendado (com a igualdade de dois intentos sendo definida por Intent.filterEquals), ele será removido e substituído por este.

Se você sabe que deseja definir o alarme, não precisa se preocupar em verificar se ele já existe ou não. Basta criá-lo sempre que seu aplicativo inicializar. Você substituirá todos os alarmes passados ​​pelos mesmos Intent.

Você precisa de uma abordagem diferente se estiver tentando calcular quanto tempo resta em um alarme criado anteriormente ou se realmente precisa saber se esse alarme existe. Para responder a essas perguntas, considere salvar dados pref compartilhados no momento em que você criou o alarme. Você pode armazenar o registro de data e hora do relógio no momento em que o alarme foi definido, a hora em que espera que o alarme seja disparado e o período de repetição (se você configurar um alarme repetido).

Eu tenho 2 alarmes. Estou usando intenção com extras em vez de ação para identificar os eventos:

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

o fato é que, com diff extras, a intenção (e o alarme) não serão únicos. Então, para identificar qual alarme está ativo ou não, tive que definir diff requestCode-s:

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

e aqui está como o alarme foi criado:

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);

Acabei de encontrar outra solução, parece funcionar para mim

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);
    }

Embora quase todo mundo aqui tenha dado a resposta correta, nenhum organismo explicou em que base os Alarmes funcionam

Você pode realmente aprender mais sobre AlarmManagere sobre como está funcionando aqui . Mas aqui está a resposta rápida

Você vê AlarmManagerbasicamente programações PendingIntentem algum momento no futuro. Portanto, para cancelar o alarme programado, você precisa cancelar o PendingIntent.

Sempre anote duas coisas ao criar o arquivo PendingIntent

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

• Código de solicitação - atua como o identificador exclusivo
• Flag - Define o comportamento de PendingIntent

Agora, para verificar se o alarme já está agendado ou para cancelar o alarme, você só precisa ter acesso ao mesmo PendingIntent. Isso pode ser feito se você usar o mesmo código de solicitação e usar FLAG_NO_CREATEcomo mostrado abaixo

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

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

Com FLAG_NO_CREATEele retornará nullse o PendingIntentjá não existir. Se ele já existir, retornará referência ao existentePendingIntent

Eu criei um script bash simples (estúpido ou não), que extrai os longos do shell adb, os converte em carimbos de data e hora e mostra em vermelho.

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;)

tente ;)

    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 não é criar intenção pendente, de modo a fornecer um valor 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);

Depois que o AlarmManager verifica o valor de Intenção pendente, ele é verdadeiro porque o AlarmManager atualiza o sinalizador de Intenção pendente.

            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");

            }

Estou com a impressão de que não há como fazer isso, seria bom.

Você pode obter um resultado semelhante tendo um Alarm_last_set_time gravado em algum lugar e tendo um On_boot_starter BroadcastReciever: BOOT_COMPLETED meio que.