Déclenchement alarme répétitive

**yrtera** · 20/04/2013, 14h08

bonjour,

j'ai crée une application pour modifier le mode du téléphone (vibreur, sonnerie, silencieux).

j'ai utilisé des alarmes répétitives a intervale journalié dont voici le code:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
this.active = true;
    	this.intent = new Intent(context,alarme_action.class);
		this.intent.setAction(type);
		this.pending_intent = PendingIntent.getBroadcast(context, 0, this.intent, 0);
		this.alarme_manager.set(AlarmManager.RTC_WAKEUP, this.date.getTimeInMillis(), this.pending_intent);

le problème est que certaines fois, la pending intent ne se déclenche pas.

Dans mon application il y a deux alarmes, la première alarme se déclenche tous les jour parfaitement, mais certaines fois la deuxième ne fait rien.

ma question: y a t'il un journal des erreur ou je peux voir pourquoi l'alarme ne s'est pas déclenché ? ou avez vous une idée d'où peux venir le problème ?

Merci.

**nicroman** · 20/04/2013, 14h58

Il semble que la l'alarme soit faite pour ne fonctionner qu'une seule fois... et n'est pas en mode répétition (setRepeating), ou n'a t-on qu'une petite partie du code ?

**yrtera** · 20/04/2013, 17h59

Ho oui, pardon, je me suis trompé de code.

voila le code:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
this.active = true;
		this.intent.setAction(type);
		this.pending_intent = PendingIntent.getBroadcast(context, 0, this.intent, 0);
long interval_defaut = AlarmManager.INTERVAL_DAY;
this.alarme_manager.setRepeating(AlarmManager.RTC_WAKEUP, this.date.getTimeInMillis(), this.intervale, this.pending_intent);

voila, Merci.

**nicroman** · 21/04/2013, 04h52

Et le code de la deuxième alarme ?

**yrtera** · 22/04/2013, 01h02

bonjour,

c'est le même code, je sais pas si je peux le faire comme ça (ou si c'est de la chance que ça marche des fois.)

j'ai crée un objet alarme dans lequel je crée mes alarmes:

création des objets:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
		alarme_debut = new alarme_repetitive("alarme debut", false, AlarmManager.INTERVAL_DAY, this);
		alarme_fin = new alarme_repetitive("alarme fin", false, AlarmManager.INTERVAL_DAY, this);
		alarme_debut.alarme_manager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
		alarme_fin.alarme_manager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);

puis la classe de l'objet:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package com.bibi.chuut;
 
import android.app.Activity;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
 
public class alarme_repetitive extends alarme{
 
	protected long interval_defaut = AlarmManager.INTERVAL_DAY;
	protected boolean inexact_defaut = false;
 
	long intervale;
	boolean inexact;
 
	public long getintervale() {
        return intervale;
    }
    public void setintervale(long _intervale) {
        this.intervale = _intervale;
    }
 
	public boolean getinexact() {
        return inexact;
    }
    public void setinexact(boolean _inexact) {
        this.inexact = _inexact;
    }
 
 
	public alarme_repetitive(String _nom) {
		super(_nom);
		this.intervale = interval_defaut;
		this.inexact = inexact_defaut;
	}
 
	public alarme_repetitive(String _nom, boolean _inexact, long _intervale,Context context) {
		super(_nom);		
		this.intervale=_intervale;
		this.inexact = _inexact;
 
		this.intent = new Intent(context,alarme_action.class);
		this.type = type_defaut;
		this.intent.setAction(type);
	}
 
 
    public void activer(Context context)
    {		
		this.active = true;
		this.intent.setAction(type);
		this.pending_intent = PendingIntent.getBroadcast(context, 0, this.intent, 0);
 
    	if(!this.inexact)
    	{
    		setRepeating(context);
    	}
    	else
    	{
    		setInexactRepeating(context);
    	}
 
    	enregistrement(context);
    }
 
 
	private void setRepeating(Context context)
	{
		this.alarme_manager.setRepeating(AlarmManager.RTC_WAKEUP, this.date.getTimeInMillis(), this.intervale, this.pending_intent);
	}
 
	private void setInexactRepeating(Context context)
	{
		this.alarme_manager.setInexactRepeating(AlarmManager.RTC_WAKEUP, this.date.getTimeInMillis(), this.intervale, this.pending_intent);
	}
 
 
	protected void enregistrement(Context context)
	{
		SharedPreferences donnees = context.getSharedPreferences(this.nom, Activity.MODE_PRIVATE);
		SharedPreferences.Editor ecriture = donnees.edit();
 
		ecriture.putString("nom", this.nom);
		ecriture.putString("type", this.type);
		ecriture.putLong("date", this.date.getTimeInMillis());
		ecriture.putBoolean("active", this.active);
		ecriture.putLong("intervale", this.intervale);
		ecriture.putBoolean("inexact", this.inexact);
 
		ecriture.apply();
	}
 
	public void recupereration(Context context)
	{
		SharedPreferences donnees = context.getSharedPreferences(this.nom, Activity.MODE_PRIVATE);
 
		this.nom = donnees.getString("nom", "faux nom");
		this.type = donnees.getString("type", this.type_defaut);
		this.date.setTimeInMillis(donnees.getLong("date", 0));
		this.active = donnees.getBoolean("active", this.active_defaut);
		this.intervale = donnees.getLong("intervale", this.interval_defaut);
		this.inexact = donnees.getBoolean("inexact", this.inexact_defaut);
	}
}

et enfin la super classe:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
package com.bibi.chuut;
 
import java.util.Calendar;
 
import android.app.Activity;
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
 
public class alarme {
 
	protected String type_defaut = "normal";
	protected boolean active_defaut = true;
 
	String nom;
	String type; //sert pour le setAction de l'intent
	AlarmManager alarme_manager;
	PendingIntent pending_intent;
	Intent intent;
	Calendar date;
	boolean active;
 
 
	public String getnom() {
        return nom;
    }
    public void setnom(String _nom) {
        this.nom = _nom;
    }
 
	public String gettype() {
        return type;
    }
    public void settype(String _type) {
        this.type = _type;
    }
 
	public Calendar getdate() {
        return date;
    }
    public void setcalendrier(Calendar _date) {
        this.date = _date;
    }
 
    public alarme(String _nom)
    {
    	this.nom = _nom;
    	this.type = type_defaut;
    	this.date = Calendar.getInstance();
    	this.active = false;
    }
 
	public void activer(Context context)
	{
		this.active = true;
    	this.intent = new Intent(context,alarme_action.class);
		this.intent.setAction(type);
		this.pending_intent = PendingIntent.getBroadcast(context, 0, this.intent, 0);
		this.alarme_manager.set(AlarmManager.RTC_WAKEUP, this.date.getTimeInMillis(), this.pending_intent);
 
		enregistrement(context);
	}
 
	protected void enregistrement(Context context)
	{
		SharedPreferences donnees = context.getSharedPreferences(this.nom, Activity.MODE_PRIVATE);
		SharedPreferences.Editor ecriture = donnees.edit();
 
		ecriture.putString("nom", this.nom);
		ecriture.putString("type", this.type);
		ecriture.putLong("date", this.date.getTimeInMillis());
		ecriture.putBoolean("active", this.active);
 
		ecriture.apply();
	}
 
	public void recupereration(Context context)
	{
		SharedPreferences donnees = context.getSharedPreferences(this.nom, Activity.MODE_PRIVATE);
 
		this.nom = donnees.getString("nom", "");
		this.type = donnees.getString("type", this.type_defaut);
		this.date.setTimeInMillis(donnees.getLong("date", 0));
		this.active = donnees.getBoolean("active", this.active_defaut);
	}
 
	public void cancel(Context context)
	{
		this.active = false;
		this.alarme_manager.cancel(this.pending_intent);
		enregistrement(context);
	}
 
}

je peux utiliser ces classes ? ou j'ai tout faux ?

Merci.

**nicroman** · 22/04/2013, 13h52

Ok... compris....

Bon, la notion de PendingIntent est un poil plus complexe à appréhender que les Intent. Les Intent sont simple: on y colle ce qu-on veut, et bim, on le lance au système.
Un PendingIntent est un poil plus complexe: il doit résister à un arrêt/redémarrage du device, et surtout, transporte des "autorisations" avec lui.
C'est grosso-modo un "token" d'utilisation de données applications... réutilisable à souhait par l'application destinataire, jusqu'à ce qu'un "cancel" soit réalisé dessus.

Ce qui veut dire que l'on a pas un PendingIntent par Intent:

Envoyé par PendingIntent

Because of this behavior, it is important to know when two Intents are considered to be the same for purposes of retrieving a PendingIntent. A common mistake people make is to create multiple PendingIntent objects with Intents that only vary in their "extra" contents, expecting to get a different PendingIntent each time. This does not happen. The parts of the Intent that are used for matching are the same ones defined by Intent.filterEquals. If you use two Intent objects that are equivalent as per Intent.filterEquals, then you will get the same PendingIntent for both of them.

Envoyé par Intent.filterEquals

Determine if two intents are the same for the purposes of intent resolution (filtering). That is, if their action, data, type, class, and categories are the same. This does not compare any extra data included in the intents.

Donc si on fait deux PendingIntent à partir de deux Intent différents qui ont:
* La même action (ce qui est le cas)
* Les même données (URL, c'est le cas)
* Le même data-type (mime-type, c'est le cas)
* La même classe (le listener: c'est le cas)
* La même catégorie (c'est le cas)

Même si a chaque fois les "extra" sont différents, on aura en fait le même PendingIntent dans les deux cas... et donc on peut faire 20 appels à setRepeating, un seul sera pris en compte.

Il y a une astuce pour différencier les PendingIntent si on ne peut vraiment rien faire autrement sur l'Intent, c'est utiliser le "requestCode" du getActivity ou getBroadcast.... Si le request-code est différent, le PendingIntent sera différent (même si les Intents sont identiques).

Mais dans notre cas présent, passer l'identifieur d'alarme dans l'URL est encore le plus simple !

**yrtera** · 22/04/2013, 15h14

bonjour,

Envoyé par nicroman

Un PendingIntent est un poil plus complexe: il doit résister à un arrêt/redémarrage du device ...

il résiste a un redémarrage du device ? parce que je le recrée au redémarrage du device.

Envoyé par nicroman

C'est grosso-modo un "token" d'utilisation de données applications... réutilisable à souhait par l'application destinataire, jusqu'à ce qu'un "cancel" soit réalisé dessus.

ok, j'ai saisi.

Envoyé par nicroman

Même si a chaque fois les "extra" sont différents, on aura en fait le même PendingIntent dans les deux cas... et donc on peut faire 20 appels à setRepeating, un seul sera pris en compte.

ça aussi j'ai compris.

Envoyé par nicroman

Il y a une astuce pour différencier les PendingIntent si on ne peut vraiment rien faire autrement sur l'Intent, c'est utiliser le "requestCode" du getActivity ou getBroadcast.... Si le request-code est différent, le PendingIntent sera différent (même si les Intents sont identiques).

ça pas trop. c'est quoi le "requestCode" du getActivity ?

Envoyé par nicroman

Mais dans notre cas présent, passer l'identifieur d'alarme dans l'URL est encore le plus simple !

l'identifieur d'alarme = nom ?, on le passe a qui ?, dans quelle URL ?

Merci.

**nicroman** · 22/04/2013, 16h02

Envoyé par yrtera

il résiste a un redémarrage du device ? parce que je le recrée au redémarrage du device.

Si une alarme est programmé... quand le device redémarre elle sera toujours programmée.... Nul besoin de la recréer.
En général tous les PendingIntent sont ainsi réutilisables *apres* un reboot du device (et même d'un cold-boot, il n'y a guère qu'un factory-reset je crois pour les virer).

ça aussi j'ai compris.

Donc tu as compris que tu programmais deux fois la même alarme ? La deuxième programmation "effaçant" la première.

ça pas trop. c'est quoi le "requestCode" du getActivity ?

Les fonctions getBroadcast et getActivity de PendingIntent prennent toutes deux (en second paramètre je crois) un "requestCode" (à 0 dans ton code). En faisant varier ce requestCode, on obtient des PendingIntent différents. Mais cette solution n'est à utiliser qu'en dernier recours.

l'identifieur d'alarme = nom ?, on le passe a qui ?, dans quelle URL ?

Oui par exemple. N'importe quoi qui permet de savoir de quelle alarme on parle.
par les fonctions "setData()" ou "setDataAndType()"
Prévoir un schema adapté, par exemple: "com.myapp.alarm:####""
http://www.faqs.org/rfcs/rfc2396.html

**yrtera** · 22/04/2013, 20h11

bonjour,

Envoyé par nicroman

Si une alarme est programmé... quand le device redémarre elle sera toujours programmée.... Nul besoin de la recréer.

j'ai fais le test de redémarrer sans recréer l'alarme mais elle ne se déclenche pas.
peut être un problème au niveau du code ?
dans mon livre (Android 4 développement d'applications avancées) ils disent que les alarmes sont toutes annulées lorsque l'appareil est redémarré.
il y a une autre façons que des alarmes répétitives pour exécuter mon pendingIntent ?

Envoyé par nicroman

Donc tu as compris que tu programmais deux fois la même alarme ? La deuxième programmation "effaçant" la première.

oui, mais je comprend pas pourquoi ça marchait la plupart du temps.

voici mon code d'activation de l'alarme:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 public void activer(Context context)
    {		
		this.active = true;
		this.intent.setAction(type);
		this.intent.setData(Uri.parse("com.bibi.chuut.alarme:"+this.nom));
		this.pending_intent = PendingIntent.getBroadcast(context, 0, this.intent, 0);
 
    	if(!this.inexact)
    	{
    		setRepeating(context);
    	}
    	else
    	{
    		setInexactRepeating(context);
    	}
 
    	enregistrement(context);
    }

ça a l'air de fonctionner, mais je vais faire des test sur la durée (plusieurs jours).

Merci.

**nicroman** · 23/04/2013, 01h30

Envoyé par yrtera

j'ai fais le test de redémarrer sans recréer l'alarme mais elle ne se déclenche pas.
peut être un problème au niveau du code ?
dans mon livre (Android 4 développement d'applications avancées) ils disent que les alarmes sont toutes annulées lorsque l'appareil est redémarré.
il y a une autre façons que des alarmes répétitives pour exécuter mon pendingIntent ?

Non pardon, je me suis mal exprimé... les PendingIntent resistent au cold-boot (on peut donc les sérialiser), par contre les alarmes du AlarmManager doivent être reprogrammées.

**yrtera** · 23/04/2013, 02h26

bonjour,

je me suis rendu compte que j'ai un autre problème, lorsque je paramètre mon alarme, je définis une heure, mais l'alarme se déclenche imédiatement puis a l'heure indiquée.

exemple: mon téléphone est en sonnerie, a 18H00 je crée une alarme pour qu'il passe en silencieux a 18H10, l'alarme se déclenche a 18H00, le téléphone passe en silencieux, puis elle se déclenche de nouveaux a 18H10.

pourquoi l'alarme se déclenche dès que je la crée alors que l'heure est definie plus tard ?

Merci.

**nicroman** · 23/04/2013, 02h41

On peut voir le code de la construction de la Date initiale ?
(je subodore une date la veille)

**yrtera** · 23/04/2013, 03h00

voici le code pour le TimePickerDialog.OnTimeSetListener:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
	TimePickerDialog.OnTimeSetListener debut=
			new TimePickerDialog.OnTimeSetListener() {
			public void onTimeSet(TimePicker view, int hourOfDay,
			int minute) {
			alarme_debut.date.set(Calendar.HOUR_OF_DAY, hourOfDay);
			alarme_debut.date.set(Calendar.MINUTE, minute);
			alarme_debut.date.set(Calendar.SECOND, 00);
			alarme_debut.date.set(Calendar.MILLISECOND, 0);
			actualise(true);
			}
			};

et pour le TimePickerDialog:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
			TimePickerDialog tpd_debut = new TimePickerDialog(this,2, debut,
					alarme_debut.date.get(Calendar.HOUR_OF_DAY),
					alarme_debut.date.get(Calendar.MINUTE),
					true);
 
			tpd_debut.setCancelable(true);
			tpd_debut.setTitle("Définir l'heure");
			tpd_debut.show();

**nicroman** · 23/04/2013, 03h50

ou c'est bien ce qu'il me semblait, à aucun moment on ne fait un set du jour...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
alarme_debut.date.set(Calendar.HOUR_OF_DAY, hourOfDay);
			alarme_debut.date.set(Calendar.MINUTE, minute);
			alarme_debut.date.set(Calendar.SECOND, 00);
			alarme_debut.date.set(Calendar.MILLISECOND, 0);

Va juste mettre à jour l'heure, les minutes, secondes et millisecondes, mais la date est inchangée.
Si "alarm_debut.date" contient une date dans le passé, cela ne va plus !

Il faut trouver un autre moyen de passer les informations, par exemple une fonction "setTime(int hourOfDay, int minutes)" dans l'objet d'alarme qui fera tout:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
public void setTime(int hourOfDay, int minutes)
{
    this.date = Calendar.getInstance();
    Date now = date.getTime();
    this.date.set(Calendar.HOUR_OF_DAY,hourOfDay);
    this.date.set(Calendar.MINUTE,minute);
    this.date.set(Calendar.SECOND, 0);
    this.date.set(Calendar.MILLISECOND,0);
    if (this.date.getTime().before(now)) 
        this.date.add(Calendar.DATE,1); // on s'assure que la date est *au moins* le lendemain
}

Attention pendant la sérialisation de bien utiliser cette fonction (et non stocker une date en millisecondes.

**yrtera** · 23/04/2013, 15h35

bonjour,

j'ai modifié mon code en mettant la méthode pour la date.

pour la sauvegarde, j'ai fait:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
SharedPreferences donnees = context.getSharedPreferences(this.nom, Activity.MODE_PRIVATE);
		SharedPreferences.Editor ecriture = donnees.edit();
 
		ecriture.putString("nom", this.nom);
		ecriture.putString("type", this.type);
		ecriture.putInt("heure", this.date.get(Calendar.HOUR_OF_DAY));
		ecriture.putInt("minute", this.date.get(Calendar.MINUTE));
		ecriture.putBoolean("active", this.active);
		ecriture.putLong("intervale", this.intervale);
		ecriture.putBoolean("inexact", this.inexact);
 
		ecriture.apply();

et pour la récuperation:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
		SharedPreferences donnees = context.getSharedPreferences(this.nom, Activity.MODE_PRIVATE);
 
		this.nom = donnees.getString("nom", "faux nom");
		this.type = donnees.getString("type", this.type_defaut);
		setTime(donnees.getInt("heure", 12), donnees.getInt("minute", 40));
		this.active = donnees.getBoolean("active", this.active_defaut);
		this.intervale = donnees.getLong("intervale", this.interval_defaut);
		this.inexact = donnees.getBoolean("inexact", this.inexact_defaut);

j'ai un problème, lorsque je récupère les infos, il me met que les valeurs par défaut, les deuxièmes arguments.

je comprend pas, ça marchait bien et maintenant non, je sais pas si c'est la sauvegarde ou la récupération qui pose problème.

si un des SharedPreferences ne fonctionne pas, il écrit les autres ou il ne fait rien ?

Merci.

je sais pas trop pourquoi mais ça marche bien sur mon émulateur mais sur mon téléphone ça ne marche pas.

j'ai testé de désinstaller l'appli sur l'emulateur et de réinstaller l'appli, ca marche plus.

et là je suis un peux perdu. ca vien peut etre de ma récupération des données, dans la méthode oncreate de ma mainactivity, je fais appel a une méthode pour récuperer les infos des alarmes:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public void recup_alarme()
	{
		if(PendingIntent.getBroadcast(this, 0, alarme_debut.intent,PendingIntent.FLAG_CANCEL_CURRENT)!=null)
		{			
			alarme_debut.recupereration(this);
			if(alarme_debut.active)
			{
				swh_selection.setChecked(false);
				layout_2.setVisibility(4);
				actualise(true);
				selection_mode(alarme_debut,true);
			}
		}
 
		if(PendingIntent.getBroadcast(this, 0, alarme_fin.intent,PendingIntent.FLAG_CANCEL_CURRENT)!=null)
		{
			alarme_fin.recupereration(this);
			if(alarme_fin.active)
			{
				swh_selection.setChecked(true);
				layout_2.setVisibility(0);
				actualise(false);
				selection_mode(alarme_fin,false);
			}
		}

je pense que le probleme viens de là, même si les alarmes n'ont pas étés créée, il rentre dans les if, et donc ne trouve pas d'infos.

Merci.

**yrtera** · 24/04/2013, 18h54

bonjour,

j'ai testé avec:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

PendingIntent.getBroadcast(this, 0, alarme_debut.intent,PendingIntent.FLAG_NO_CREATE)==null)

mais ca ne marche pas, peut etre avec une méthode dans ma classe objet ?
je vais tester, pour supprimer mes alarmes j'utilise:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

this.alarme_manager.cancel(this.pending_intent);

mais je crois que le pendinginntent existe toujours, mais qu'il est désactivé. c'est ça ?

Merci.

**yrtera** · 25/04/2013, 03h49

bonjour,

j'ai trouvé ça:

Retrieve a PendingIntent that will perform a broadcast, like calling Context.sendBroadcast().

Parameters
context The Context in which this PendingIntent should perform the broadcast.
requestCode Private request code for the sender (currently not used).
intent The Intent to be broadcast.
flags May be FLAG_ONE_SHOT, FLAG_NO_CREATE, FLAG_CANCEL_CURRENT, FLAG_UPDATE_CURRENT, or any of the flags as supported by Intent.fillIn() to control which unspecified parts of the intent that can be supplied when the actual send happens.
Returns
Returns an existing or new PendingIntent matching the given parameters. May return null only if FLAG_NO_CREATE has been supplied.

dans la partie flags ils mettent qu'on peut faire avec les flags de Intent.fillIn().

j'ai voulu utiliser FILL_IN_DATA :

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

if(PendingIntent.getBroadcast(this, 0, alarme_debut.intent,Intent.FILL_IN_DATA)==2)

mais j'ai une erreur: Incompatible operand types PendingIntent and int.

je suis pas sûr de me servir de cette méthode correctement, je veut savoir si la pending intent de l'alarme existe et est toujours active.

Merci.

**yrtera** · 27/04/2013, 00h58

bonjour,

après plusieurs recherche je suis passé par une autre solution,

voir ce post.

Merci nicroman pour ton aide.

Déclenchement alarme répétitive

Android

Discussions similaires

Partager

Partager