Jak sprawdzić, czy AlarmManager ma już ustawiony alarm?

Po uruchomieniu mojej aplikacji chcę, aby sprawdził, czy określony alarm (zarejestrowany przez AlarmManager) jest już ustawiony i działa. Wyniki z Google wydają się wskazywać, że nie ma na to sposobu. Czy to nadal jest poprawne? Muszę to sprawdzić, aby poinformować użytkownika przed podjęciem jakichkolwiek działań w celu utworzenia nowego alarmu.

W odpowiedzi na opublikowany komentarz, oto szczegółowe rozwiązanie. Załóżmy, że zarejestrowałeś powtarzający się alarm z takim zamiarem:

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

Aby sprawdzić, czy jest aktywny, możesz:

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

Kluczem tutaj jest to, FLAG_NO_CREATEco opisano w javadoc: if the described PendingIntent **does not** already exists, then simply return null(zamiast tworzenia nowego)

Dla innych, którzy mogą tego potrzebować, oto odpowiedź.

Posługiwać się adb shell dumpsys alarm

Możesz wiedzieć, że alarm został ustawiony i kiedy będą alarmowane i interwały. Również ile razy ten alarm był wywoływany.

Przykład działania z odbiornikiem (najlepsza odpowiedź dotyczyła tylko akcji).

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

Warto wspomnieć:

Jeśli aplikacja tworząca później (proces) ponownie pobierze ten sam rodzaj PendingIntent (ta sama operacja , ten sam Intent - działanie, dane, kategorie, komponenty, flagi ), otrzyma PendingIntent reprezentujący ten sam token, jeśli jest nadal ważny, i może w ten sposób wywołać cancel (), aby go usunąć.

Krótko mówiąc, Twój obiekt PendingIntent powinien mieć te same funkcje (działanie i struktura intencji), aby przejąć nad nim kontrolę.

Zwróć uwagę na ten cytat z dokumentacji dla ustawionej metody Alarm Managera:

Jeśli jest już zaplanowany alarm dla tej intencji (przy równej wartości dwóch intencji zdefiniowanej przez Intent.filterEquals), zostanie on usunięty i zastąpiony tym.

Jeśli wiesz, że chcesz ustawić alarm, nie musisz zawracać sobie głowy sprawdzaniem, czy już istnieje. Po prostu utwórz go przy każdym uruchomieniu aplikacji. Wszystkie wcześniejsze alarmy zastąpisz tym samym Intent.

Potrzebujesz innego podejścia, jeśli próbujesz obliczyć, ile czasu pozostało do wcześniej utworzonego alarmu lub jeśli naprawdę potrzebujesz wiedzieć, czy taki alarm w ogóle istnieje. Aby odpowiedzieć na te pytania, rozważ zapisanie udostępnionych danych wstępnych w momencie tworzenia alarmu. Możesz zapisać znacznik czasu w momencie ustawienia alarmu, oczekiwany czas wyłączenia alarmu oraz okres powtarzania (jeśli ustawisz alarm powtarzalny).

Mam 2 alarmy. Używam zamiaru z dodatkami zamiast akcji, aby zidentyfikować zdarzenia:

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

Chodzi o to, że w przypadku dodatków różnicowych cel (i alarm) nie będzie unikalny. Aby móc zidentyfikować, który alarm jest aktywny, czy nie, musiałem zdefiniować diff requestCode:

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

a oto jak powstał alarm:

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

Właśnie znalazłem inne rozwiązanie, wydaje mi się, że działa

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

Chociaż prawie wszyscy tutaj udzielili prawidłowej odpowiedzi, żadne ciało nie wyjaśniło, na jakiej podstawie działają Alarmy

Możesz dowiedzieć się więcej o tym AlarmManageri jak działa tutaj . Ale oto szybka odpowiedź

Widzisz AlarmManagerzasadniczo harmonogramy PendingIntentw przyszłości. Aby więc anulować zaplanowany alarm, musisz anulować PendingIntent.

Zawsze miej na uwadze dwie rzeczy podczas tworzenia PendingIntent

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

• Kod żądania - Działa jako unikalny identyfikator
• Flaga - określa zachowanie PendingIntent

Teraz, aby sprawdzić, czy alarm jest już zaplanowany lub anulować alarm, wystarczy uzyskać do niego dostęp PendingIntent. Można to zrobić, jeśli używasz tego samego kodu żądania i używasz go FLAG_NO_CREATEjak pokazano poniżej

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

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

Dzięki FLAG_NO_CREATEnie wróci, nulljeśli jeszcze PendingIntentnie istnieje. Jeśli już istnieje, zwraca odwołanie do istniejącegoPendingIntent

Zrobiłem prosty (głupi lub nie) skrypt bashowy, który wyodrębnia te długie z powłoki adb, konwertuje je na znaczniki czasu i pokazuje na czerwono.

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

Spróbuj ;)

    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 nie jest tworzony w oczekiwaniu, więc podaje wartość logiczną false.

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

Po sprawdzeniu przez AlarmManager wartości Pending Intent, daje wartość true, ponieważ AlarmManager Update The Flag of Pending Intent.

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

            }

Mam wrażenie, że nie ma takiej możliwości, byłoby jednak miło.

Możesz osiągnąć podobny wynik, nagrywając gdzieś Alarm_last_set_time, i mając coś w rodzaju On_boot_starter BroadcastReciever: BOOT_COMPLETED.