Autore Topic: Mantenere le vecchie notifiche  (Letto 1420 volte)

Offline Auron

  • Utente junior
  • **
  • Post: 104
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    Motorola Milestone Android 2.2.1
  • Sistema operativo:
    Windows
Mantenere le vecchie notifiche
« il: 17 Gennaio 2012, 12:07:11 CET »
0
Salve gente,
Mi stavo cimentando con le notifiche e ho trovato l'impossibilità nel poter accumulare lo stesso tipo di notifiche.

Ovvero, mettiamo il caso che io riceva una notifica che se cliccata mi porta ad una specifica Activity con dei parametri da passargli in Intent. Io decido di non guardare la notifica ma subito dopo ne arriva una nuova dello stesso tipo e poichè esistono solo:

FLAG_ONE_SHOT Indica che il particolare PendingIntent può essere utilizzato solamente
una volta. Ogni ulteriore tentativo porta alla generazione di un errore.
FLAG_NO_CREATE Se il corrispondente PendingIntent non esiste già, il metodo i creazione
ritorna null.
FLAG_CANCEL_CURRENT Se il corrispondente PendinIntent esiste già, viene eliminato a favore
di uno nuovo,
FLAG_UPDATE_CURRENT Se il corrispondente PendingIntent esiste già, viene mantenuto e ne
vengono aggiornate solamente le informazioni relative all’Extra.

come faccio a poter vedere entrambe le notifiche che pur invocando la stessa Activity inviano però dati diversi l'una dall'altra?

Spero di esser stato chiaro.

Grazie
È stata trovata una soluzione al tuo problema?Evidenzia il post più utile premendo . È un ottimo modo per ringraziare chi ti ha aiutato ;-)

Offline teskio

  • Moderatore globale
  • Utente normale
  • *****
  • Post: 387
  • Respect: +118
    • Github
    • Google+
    • Mostra profilo
    • Skullab
  • Dispositivo Android:
    Cubot GT99 / SurfTab Ventos 10.1
  • Play Store ID:
    Skullab Software
  • Sistema operativo:
    windows 7 / ubuntu 12.04
Re:Mantenere le vecchie notifiche
« Risposta #1 il: 18 Gennaio 2012, 01:17:46 CET »
0
Cosa c'entrano i flag del PendigIntent ?

Citazione
public void notify (int id, Notification notification)

Since: API Level 1
Post a notification to be shown in the status bar. If a notification with the same id has already been posted by your application and has not yet been canceled, it will be replaced by the updated information.

Basta che le notifiche abbiano id differente e queste non saranno rimpiazzate ma bensì aggiunte :-)

Offline Auron

  • Utente junior
  • **
  • Post: 104
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    Motorola Milestone Android 2.2.1
  • Sistema operativo:
    Windows
Re:Mantenere le vecchie notifiche
« Risposta #2 il: 18 Gennaio 2012, 09:21:29 CET »
0
Si ma non voglio che abbiano ID differente...perchè in quello che devo vorrei fare io è possibile che una notifica dello stesso tipo invii un dato diverso...
In pratica interrogo il server ogni secondo ricevendo dati da MySql che continuano a cambiare.
Mettiamo che ricevo un calcolo matematico da dei numeri che vengono sempre aggiornati nelle tabelle MySql, il calcolo è sempre lo stesso (quindi stesso tipo di notifica) ma il dato che ricevo dal server è sempre diverso.
Se mi arrivano 2 notifiche nella quale in una il risultato è 20 e l'altra 30, vorrei che entrambe inviino alla stessa activity la stessa variabile (che però in questo caso avrà valore diverso). E' una cosa possibile oppure devo per forza creare N ID di notifiche diversi?
È stata trovata una soluzione al tuo problema?Evidenzia il post più utile premendo . È un ottimo modo per ringraziare chi ti ha aiutato ;-)

Offline teskio

  • Moderatore globale
  • Utente normale
  • *****
  • Post: 387
  • Respect: +118
    • Github
    • Google+
    • Mostra profilo
    • Skullab
  • Dispositivo Android:
    Cubot GT99 / SurfTab Ventos 10.1
  • Play Store ID:
    Skullab Software
  • Sistema operativo:
    windows 7 / ubuntu 12.04
Re:Mantenere le vecchie notifiche
« Risposta #3 il: 18 Gennaio 2012, 19:37:38 CET »
+1
Ma cambi solo l'id...l'istanza della classe Notification puoi mantenere la stessa...cambierai solo il dato passato come extra dell'intent :
Codice (Java): [Seleziona]
//questo metodo è deprecato...Google consiglia si usare Notification.Builder (peccato che sia supportato solo a partire dalle api level 11)
Notification notification = new Notification(R.drawable.ic_notification,"tickerText",System.currentTimeMillis());
//crei l'intent con gli extra per i dati...
Intent dataIntent = new Intent(this,MyActivity.class);
dataIntent.putExtra("MyData",100);
//crei il PendingIntent...
PendingIntent myPending = PendingIntent.getActivity(this, 0, dataIntent, 0);
//e infine completi la notifica...
notification.setLatestEventInfo(getApplicationContext(), contentTitle, contentText, myPending);

NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
//effettui la notifica con id 1
mNotificationManager.notify(1,notification);
// ora la stessa notifica può essere inviata con id diverso, in questo modo la notifica verrà aggiunta alla coda e non sostituita
mNofiticationManager.notify(2,notification);
« Ultima modifica: 18 Gennaio 2012, 19:41:56 CET da teskio »

Offline Auron

  • Utente junior
  • **
  • Post: 104
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    Motorola Milestone Android 2.2.1
  • Sistema operativo:
    Windows
Re:Mantenere le vecchie notifiche
« Risposta #4 il: 25 Gennaio 2012, 10:06:41 CET »
0
L'dea dell'ID diverso è una buona idea e ti ringrazio per la dritta  :-) però ti spiego più a fondo il mio problema...

In pratica ho un Thread all'interno del Service che viene richiamato ogni secondo e fa una richiesta dati al DB e riceve altrettanti dati salvandoli in alcune variabili. Il mio DB viene ogni secondo alterato da un programmino esterno che fa query ogni secondo ma non è SEMPRE detto che le query cambino valori.
Facciamo un esempio: nella tabella X in cui faccio gli UPDATE dal programmino esterno è la stessa che interrogo da Android, facciamo finta che il programmino esterno faccia un UPDATE incrementando di 1 o 0 un ID (una volta al secondo) e mettiamo che questo ID ogni tanto non venga incrementato.
A questo ID c'è associato un altro campo "Check" che può valere o 0 o 1
Quindi ci son dei momenti (questi momenti appunto) in cui alla ricezione dati ricevo gli stessi dati (stesso ID e quindi stesso Check) e quando faccio il controllo di questi mando la notifica se per esempio è settato a 1 il Check.

Se l'UPDATE del programmino esterno fa 4 UPDATE senza variare la Tabella X, di conseguenza anche il Service Android mi farà 4 volte la Notifica...

Come faccio a risolvere  questo problema??

Spero di aver spiegato abbastanza bene il problema  :-[

Grazie, e scusate se rispondo solo ora al post  :-(
È stata trovata una soluzione al tuo problema?Evidenzia il post più utile premendo . È un ottimo modo per ringraziare chi ti ha aiutato ;-)

Offline teskio

  • Moderatore globale
  • Utente normale
  • *****
  • Post: 387
  • Respect: +118
    • Github
    • Google+
    • Mostra profilo
    • Skullab
  • Dispositivo Android:
    Cubot GT99 / SurfTab Ventos 10.1
  • Play Store ID:
    Skullab Software
  • Sistema operativo:
    windows 7 / ubuntu 12.04
Re:Mantenere le vecchie notifiche
« Risposta #5 il: 25 Gennaio 2012, 12:45:20 CET »
0
Citazione
Se l'UPDATE del programmino esterno fa 4 UPDATE senza variare la Tabella X, di conseguenza anche il Service Android mi farà 4 volte la Notifica...

Ma è proprio qua il punto. Se tu implenti un controllo lato client (cioè Android) sui dati ricevuti, sarai tu stesso a decidere se inviare una nuova notifica oppure no.
Quindi, ipotizzo, che se per ogni dato hai una notifica diversa (anche in questo caso io farei un oggetto notifica unico e cambierei l'intent assocciato) basterà controllare se il dato di ritorno è cambiato, se si, lancerai la notifica con id diverso (ad esempio incrementandolo ogni volta). Così facendo manterrai le vecchie notifiche con i vecchi dati.

Offline Auron

  • Utente junior
  • **
  • Post: 104
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    Motorola Milestone Android 2.2.1
  • Sistema operativo:
    Windows
Re:Mantenere le vecchie notifiche
« Risposta #6 il: 25 Gennaio 2012, 12:48:48 CET »
0
Ok dai  ;-) Provo e ti faccio sapere. Grazie  :-)
È stata trovata una soluzione al tuo problema?Evidenzia il post più utile premendo . È un ottimo modo per ringraziare chi ti ha aiutato ;-)

Offline Auron

  • Utente junior
  • **
  • Post: 104
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    Motorola Milestone Android 2.2.1
  • Sistema operativo:
    Windows
Re:Mantenere le vecchie notifiche
« Risposta #7 il: 25 Gennaio 2012, 23:01:34 CET »
0
Mi escono le 2 notifiche separate, ma mi apre solamente la SimpleNotification 2.
La SimpleNotification1 rimane solo nella statusBar e se la clicco non succede nulla (nemmeno si azzera/cancella)

Quando clicco la SimpleNotification2 invece parte regolarmente l'activity di destinazione con l'intent corretto....

Questo è il codice (semplificato senza connessioni dati ecc ecc).

Codice (Java): [Seleziona]
public class MyLocalService extends Service {
        /*
         * Tag del Log
         */

        private final static String LOG_TAG = "MyLocalService";
        /*
         * Numero massimo di notifiche da inviare dopo il quale il servizio muore
         */

        private final static int MAX_NOTIFICATION_NUMBER = 10;
        /*
         * Identifciatori delle notifiche
         */

        private final static int SIMPLE_NOTIFICATION_ID = 1;
        /*
         * Riferimento al NotificationManager
         */

        private NotificationManager notificationManager;       
        /*
         * Riferimento al Thread in background
         */

        private BackgroundThread backgroundThread;
        /*
         * Notifica da inviare piu' volte
         */

        private Notification notification;
        /*
         * Intent della Notification
         */

        private PendingIntent pIntent;

        /*
         * Numero di notifiche inviate
         */

        private int notificationNumber;
       
        @Override
        public void onCreate() {
                super.onCreate();
                // Facciamo partire il BackgroundThread
                backgroundThread = new BackgroundThread();
                backgroundThread.start();
                // Otteniamo il riferimento al NotificationManager
                notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
                Log.i(LOG_TAG, "Service Created");
               
        }
       
        public void sendNotification1(){
                // Creiamo la Notification
                notification = new Notification(R.drawable.icon,
                                "Simple Notification1", System.currentTimeMillis());           
                notification.flags |= Notification.FLAG_AUTO_CANCEL;
                // Impostiamo le altre informazioni tra cui l'Intent
                Intent intent = new Intent(this, NotificationActivity.class);
                intent.putExtra("notificationType", "Simple Notification1");
                pIntent = PendingIntent.getActivity(this, 0, intent,
                                PendingIntent.FLAG_CANCEL_CURRENT);    
                // Aggiorniamo il contatore
                notificationNumber++;
                notification.number=notificationNumber;
                notification.setLatestEventInfo(this, "Simple Notification1",
                                "Simple Notification Extended", pIntent);
                // La lanciamo attraverso il Notification Manager
                notificationManager.notify(1, notification);
        }
       
        public void sendNotification2(){
                // Creiamo la Notification
                notification = new Notification(R.drawable.icon,
                                "Simple Notification2", System.currentTimeMillis());           
                notification.flags |= Notification.FLAG_AUTO_CANCEL;
                // Impostiamo le altre informazioni tra cui l'Intent
                Intent intent = new Intent(this, NotificationActivity.class);
                intent.putExtra("notificationType", "Simple Notification2");
                pIntent = PendingIntent.getActivity(this, 0, intent,
                                PendingIntent.FLAG_CANCEL_CURRENT);    
                // Aggiorniamo il contatore
                notificationNumber++;
                notification.number=notificationNumber;
                notification.setLatestEventInfo(this, "Simple Notification2",
                                "Simple Notification Extended", pIntent);
                // La lanciamo attraverso il Notification Manager
                notificationManager.notify(2, notification);
        }

        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
                // Solo per debugging
                Log.i(LOG_TAG, "Service Started");
                // Inizializziamo il numero di notifiche inviate
                notificationNumber = 0;
                return super.onStartCommand(intent, flags, startId);
        }



        @Override
        public void onDestroy() {
                backgroundThread.running = false;
                super.onDestroy();
                Log.i(LOG_TAG, "Service Destroyed");
        }

        /* (non-Javadoc)
         * @see android.app.Service#onBind(android.content.Intent)
         */

        @Override
        public IBinder onBind(Intent arg0) {
                // Ritorniamo null in quanto non si vuole permettere
                // l'accesso al servizio da una applicazione diversa
                return null;
        }
               
       
        private final class BackgroundThread extends Thread {
                /*
                 * Parte fissa del delay
                 */

                private final static long MIN_DELAY = 2000L;           
                /*
                 * Ampiezza massima della parte casuale del delay
                 */

                private final static long MAX_RANDOM_DELAY = 10000L;

                public boolean running= true;

                public void run() {
                        Log.i(LOG_TAG, "BackgroundThread Started");                    
                        Random random = new Random();
                        while(running && notificationNumber<MAX_NOTIFICATION_NUMBER){
                                long randomDelay = MIN_DELAY + Math.abs(random.nextInt() %MAX_RANDOM_DELAY);
                                Log.i(LOG_TAG, "Delay is (ms) "+randomDelay);
                                try{
                                        Thread.sleep(randomDelay);
                                        }
                                catch(InterruptedException ie){
                                       
                                }
                                sendNotification1();
                                sendNotification2();
                        }
                        // Al termine del metodo run terminiamo il servizio
                        stopSelf();
                }

        }
       

}

e va bè la classica activity dove spedisco l'intent questa:

Codice (Java): [Seleziona]
public class NotificationActivity extends Activity {

        @Override
        protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.notification_activity);
                // Otteniamo le informazioni associate all'Intent
                Bundle extras = getIntent().getExtras();
                if (extras != null) {
                        TextView textView = (TextView) findViewById(R.id.outputView);
                        textView.setText(extras.getString("notificationType"));
                }
        }

}
È stata trovata una soluzione al tuo problema?Evidenzia il post più utile premendo . È un ottimo modo per ringraziare chi ti ha aiutato ;-)

Offline teskio

  • Moderatore globale
  • Utente normale
  • *****
  • Post: 387
  • Respect: +118
    • Github
    • Google+
    • Mostra profilo
    • Skullab
  • Dispositivo Android:
    Cubot GT99 / SurfTab Ventos 10.1
  • Play Store ID:
    Skullab Software
  • Sistema operativo:
    windows 7 / ubuntu 12.04
Re:Mantenere le vecchie notifiche
« Risposta #8 il: 25 Gennaio 2012, 23:43:35 CET »
0
Perchè usi PendingIntent.FLAG_CANCEL_CURRENT ?
Rileggi la documentazione e capirai perchè si apre solo la seconda notifica. Prova a invertire l'invio delle notifiche, prima la seconda e dopo la prima
Codice (Java): [Seleziona]
sendNotification2();
sendNotification1();
E guarda cosa succede.

Offline Auron

  • Utente junior
  • **
  • Post: 104
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    Motorola Milestone Android 2.2.1
  • Sistema operativo:
    Windows
Re:Mantenere le vecchie notifiche
« Risposta #9 il: 26 Gennaio 2012, 00:16:44 CET »
0
Già hai ragione....infatti ho sbagliato a semplificarti il codice da quello originale :-P

Provo a postarti quello incasinato che non mi funziona... O meglio...l'activity di destinazione prende come intent sempre lo stesso pur essendo le notifiche di ID diversi e con dati di Intent diversi e con pendingIntent diversi.

Ora ti mostro il codice.... (le variabili che non sai da dove arrivano son corrette ci ho fatto il debug, son quelle del parsing col server).

Codice (Java): [Seleziona]
public class GestioneAllarmi extends Service {

        private final static String LOG_TAG = "MyLocalService";
        private final static String TAG = "GestioneAllarmi";

        //Identifciatori delle notifiche:
        //Notifica di Prossimità
        private final static int PROXIMITY_NOTIFICATION_ID = 1;
        //Notifica di Intrusione
        private final static int INTRUSION_NOTIFICATION_ID = 1;
        //Riferimento al NotificationManager
        private NotificationManager notificationManager;       
        //Riferimento al Thread in background
        private BackgroundThread backgroundThread;
        //Notifica da inviare piu' volte
        private Notification notificationProximity;
        //Notifica da inviare piu' volte
        private Notification notificationIntrusion;
       
        //Intent della Notification
        private PendingIntent pIntentProximity;
       
        //Intent della Notification
        private PendingIntent pIntentIntrusion;
       
        //Numero di notifiche inviate
        private int notificationNumber;
       
       
       
        // ********************************************************
        @Override
        public void onCreate() {
                super.onCreate();
               
                // Otteniamo il riferimento al NotificationManager
                notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
               
               
                // Facciamo partire il BackgroundThread
                backgroundThread = new BackgroundThread();
                backgroundThread.Set_Millisecondi_Pausa(1000);
                backgroundThread.start();
               
        }
       
        // ********************************************************
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
                // Solo per debugging
                Log.i(LOG_TAG, "Service Started");
                // Inizializziamo il numero di notifiche inviate
                notificationNumber = 0;
                return super.onStartCommand(intent, flags, startId);
        }

        // ********************************************************
        @Override
        public void onDestroy() {
                backgroundThread.running = false;
                super.onDestroy();
                Log.i(LOG_TAG, "Service Destroyed");
        }

        // ********************************************************
        @Override
        public IBinder onBind(Intent arg0) {
                // Ritorniamo null in quanto non si vuole permettere
                // l'accesso al servizio da una applicazione diversa
                return null;
        }
       
       
        // ********************************************************
        public void checkAlarms() {
                Log.i(LOG_TAG, "CheckAlarms");
               
               
                //Controllo Allarme Intrusione
                for (int i = 0; i < arrayPatientLenght; i++) {
                        for (int j = 0; j < arrayIntrusionLenght; j++) {
                                if (patientId[i] == intrusionPatientId[j]){
                                        if (intrusionAlarm[j] == 1) {
                                                patientIsInIntrusionAlarm[i] = true;
                                                // alarmType[1]=true;
                                                // patient2Proximity[i]=proximityPatientId_2[j];
                                                //Log.e("INTRUSION", "INUTRUSION");
                                                sendIntrusionNotification(j);
                                        }
                                }
                        }
                }
               
               
                //Controllo Allarme Prossimità
                for (int i = 0; i < arrayPatientLenght; i++) {
                        for (int j = 0; j < arrayProximityLenght; j++) {
                                if (patientId[i] == proximityPatientId_1[j]) {
                                        if (proximityAlarm[j] == 1) {
                                                patientIsInProximityAlarm[i] = true;
                                                patient2ProximityId[i] = proximityPatientId_2[j];
                                                sendProximityNotification(i, patient2ProximityId[i], j);
                                        }
                                }
                        }
                }

        }      
       
        private void sendProximityNotification(int id_patient_1, int id_patient_2, int k) {
                //notificationProximity.defaults |= Notification.DEFAULT_ALL;
               
                notificationProximity = new Notification(R.drawable.allarme_icona, "Allarme Prossimità", System.currentTimeMillis());
               
                Log.i(LOG_TAG, "sendNotification");
               
                // Impostiamo le altre informazioni tra cui l'Intent
               
                notificationProximity.flags |= Notification.FLAG_AUTO_CANCEL;
                notificationProximity.defaults |= Notification.DEFAULT_SOUND;
               
               
                Intent intent = new Intent(this, AlarmDialog.class);

                intent.putExtra("notificationType", "Proximity_Alarm");
               
                pIntentProximity = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
               
                notificationProximity.setLatestEventInfo(this, "Allarme di Prossimità",        "Area: "+patientAreaAttuale[id_patient_1], pIntentProximity);
                // La lanciamo attraverso il Notification Manager
                notificationManager.notify(id_patient_1, notificationProximity);
                proximity=false;
        }

        private void sendIntrusionNotification(int id_patient) {
                //notificationIntrusion.defaults |= Notification.DEFAULT_ALL;
               
                notificationIntrusion = new Notification(R.drawable.allarme_icona, "Allarme Intrusione", System.currentTimeMillis());
               
                notificationIntrusion.flags |= Notification.FLAG_AUTO_CANCEL;
                notificationIntrusion.defaults |= Notification.DEFAULT_VIBRATE;
               
                // Impostiamo le altre informazioni tra cui l'Intent
                Intent intent = new Intent(this, AlarmDialog.class);

                intent.putExtra("notificationType", "Intrusion_Alarm");
               
                pIntentIntrusion = PendingIntent.getActivity(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
                //String [] area  = new String[whoIntrusionAlarm.size()];
                /*for (int i=0; i<whoIntrusionAlarm.size(); i++)
                        area[i]=*/

                notificationIntrusion.setLatestEventInfo(this, "Allarme di Intrusione", "Area: "+intrusionTitleArea[id_patient], pIntentIntrusion);
                // La lanciamo attraverso il Notification Manager
                notificationManager.notify(intrusionPatientId[id_patient], notificationIntrusion);
        }

        public final class BackgroundThread extends Thread {
                //Settaggio delay
                private int delay = 1000;

                public boolean running= true;

                // ********************************************************
                public void Set_Millisecondi_Pausa(int millisecondi) {
                        delay = millisecondi;
                }
               
                // ********************************************************            
                public void run() {
                        Log.i(LOG_TAG, "BackgroundThread Started");                    
                        while(running && count <=30){
                                Log.i(LOG_TAG, "Delay is (ms) "+delay);
                                try{
                                        //Alternativa: Thread.sleep(delay);
                                        TimeUnit.MILLISECONDS.sleep(delay);
                                        //Controllo tipo di allarme
                                        checkAlarms();
                                        count++;
                                        }
                                catch(InterruptedException ie){
                                        Log.i(LOG_TAG, "Blocco thread");
                                }
                        }
                        // Al termine del metodo run terminiamo il servizio
                        stopSelf();
                }

        }
       

}


Pur avendo le notifiche separate, quando clicco su di esse che apro l'activity AlarmDialog (Classe di destinazione) succede che l'intent che ricevo è sempre lo stesso....

Riesci a trovare l'intoppo? :-(
È stata trovata una soluzione al tuo problema?Evidenzia il post più utile premendo . È un ottimo modo per ringraziare chi ti ha aiutato ;-)

Offline teskio

  • Moderatore globale
  • Utente normale
  • *****
  • Post: 387
  • Respect: +118
    • Github
    • Google+
    • Mostra profilo
    • Skullab
  • Dispositivo Android:
    Cubot GT99 / SurfTab Ventos 10.1
  • Play Store ID:
    Skullab Software
  • Sistema operativo:
    windows 7 / ubuntu 12.04
Re:Mantenere le vecchie notifiche
« Risposta #10 il: 26 Gennaio 2012, 23:10:46 CET »
0
Bhe...così ad occhio direi che se tu lanci le notifiche all'interno di due cicli for e setti l'id delle notifiche attraverso l'incrementatore dei cicli stessi, c'è la possibilità che le due notifiche, seppur diverse, abbiano lo stesso id e di conseguenza si sovrascriva l'intent associato.
Usa due variabili dedicate che andrai ad incrementare di volta in volta.

per esempio :
Codice (Java): [Seleziona]
// Inizializza gli id
intrusionNotificationId = 1000 ;
proximityNotificationId = 0 ;
.
.
.
for(...){
   sendIntrusionNotification(intrusionNotificationId++);
}

for(...){
   sendProximityNotification(proximityNotificationId++, patient2ProximityId[i], j);
}

Adattalo alle tue esigenze  ;-)

EDIT: eh la stanchezza  :-P l'esempio che ho fatto non va bene ! il problema rimane...gli id devono essere sempre diversi...sorry ! ho modificato l'inizializzazione....alla meglio
« Ultima modifica: 27 Gennaio 2012, 00:01:55 CET da teskio »

Offline Auron

  • Utente junior
  • **
  • Post: 104
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    Motorola Milestone Android 2.2.1
  • Sistema operativo:
    Windows
Re:Mantenere le vecchie notifiche
« Risposta #11 il: 26 Gennaio 2012, 23:37:09 CET »
0
Eh no se faccio così succede che mi partono 6 notifiche (di sendProximityNotification o dell'altra uguale..). E' un problema abbastanza grosso che devo assolutamente risolvere e non riesco dato che devo consegnare il lavoro per la tesi di laurea....e non riesco a risolvere questo problema....Posso inviarti via mail o qualcosa tutta la classe e spiegarti meglio cosa fa questo Service? Perchè sono abbastanza disperato  :-( e ho pochissimo tempo per la consegna...Dimmi tu...Mi faresti davvero un grosso piacere e favore. Grazie
« Ultima modifica: 27 Gennaio 2012, 00:05:40 CET da Auron »
È stata trovata una soluzione al tuo problema?Evidenzia il post più utile premendo . È un ottimo modo per ringraziare chi ti ha aiutato ;-)

Offline Auron

  • Utente junior
  • **
  • Post: 104
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    Motorola Milestone Android 2.2.1
  • Sistema operativo:
    Windows
Re:Mantenere le vecchie notifiche
« Risposta #12 il: 28 Gennaio 2012, 14:55:43 CET »
0
Ok ho trovato un modo creando delle variabili temporanee. Ora ho un altro problema, ma provo a sbrigarmela da solo  ;-)
« Ultima modifica: 28 Gennaio 2012, 16:35:09 CET da Auron »
È stata trovata una soluzione al tuo problema?Evidenzia il post più utile premendo . È un ottimo modo per ringraziare chi ti ha aiutato ;-)