Calcul de messages en attente d'envoi

Version imprimable

Bonjour,

J'essaye de créer une petite fonction qui me permet de calculer le nombre de message en attente d'envoi de mon application.

Je doit stocker des données sur ma tablette et ensuite les envoyer sur un serveur en ligne. J'utilise l'accuse de réception pour confirmer la bonne réception de mon message.

Voici mon code pour le calcul des messages en attentes:
Code:

1 2 3 4 5 6 7 8 public static int Counter(int message){ int PendingMessages= 0; PendingMessages = PendingMessages + CounterMessage; Log.d(CLASS_TAG + "Counter", " Pending messages : "+ PendingMessages +" "); return PendingMessages; }
Et ma déclaration lors du stockage sur ma tablette et lors de la bonne réception de mon message:
Code:

1 2 3 4 5 // Stockage sur tablette PendingMessagesCounter.Counter(1); // Message recu grace a un accuse de reception PendingMessagesCounter.Counter(-1);
Bon j'avoue, j'ai un peu séché les cours de maths a l’école... :mouarf:
L’idée c'est d’implémenté a +1 ma variable PendingMessages et a la réception BIM -1... logiquement résultat 0 message en attente d'envoi.

Le problème c'est que mes résultats sont 1 ou -1 tout le temps, j'aimerai que si mon envoie échoue ma variable PendingMessages prenne la valeur du nombre de messages non reçus.

Merci de votre aide

23/04/2014, 13h31
Nico02

La variable int PendingMessages= 0; est une variable locale à la méthode Counter(), du-coup elle vaut zéro à chaque fois que tu va rentrer dans ta méthode. Et 0 -1, bah ça fait bien -1 :)

Il faut la mettre en attribut de la classe si tu veux garder cette valeur

Citation:

Envoyé par Nico02

La variable int PendingMessages= 0; est une variable locale à la méthode Counter(), du-coup elle vaut zéro à chaque fois que tu va rentrer dans ta méthode. Et 0 -1, bah ça fait bien -1 :)

Il faut la mettre en attribut de la classe si tu veux garder cette valeur

Merci Nico, alors j'ai déjà essaye et les valeurs deviennes encore plus "folles" genres elles descendent a -3 -7 +24 +48 bref c'est le bordel!
En plus je viens de me rendre compte avoir fait une erreur dans le code de mon énoncé.
Je remet le code:
Code:

1 2 3 4 5 6 7 8 public static int Counter(int message){ int PendingMessages= 0; PendingMessages = PendingMessages + message; Log.d(CLASS_TAG + "Counter", " Pending messages : "+ PendingMessages +" "); return PendingMessages; }
J'avais mis une variable "counterMessage" a la place de "message".
Sorry, j'essaye avec plusieurs solutions, et je m’emmêle un peu les pinceaux :)
Merci de ton aide Nico, je suis sur que je capte pas un truc avec les variables.. je continue en attendant

23/04/2014, 14h21
Nico02

Dans tous les cas, si tu veux garder cette valeur, tu dois utiliser un attribut de classe.

Une variable déclaré à l'intérieur d'une méthode n'existe plus lorsque la méthode à finit de s’exécuter. Donc aucune chance de conserver ta valeur.

Après si cette valeur devient "folle" comme tu dis, c'est que tu dois certainement faire des trucs un peu "fou" aussi ;)

Par contre il va falloir nous montrer un peu plus de code car là ça va être difficile d'en dire plus.

Du coup j'ai bien mis la valeur en static et en dehors de la fonction, je te met tout:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
package com.isansys.patientgateway;
 
import android.util.Log;
 
public class PendingMessagesCounter {
 
    private static final String CLASS_TAG = "";
 
	static int PendingMessages = 0;
 
    public static int Counter(int message){
 
        	PendingMessages = PendingMessages + message;
        	Log.d(CLASS_TAG + "Counter", " Pending messages : "+ PendingMessages +" ");
 
        	return PendingMessages;
 
    }
}

Tu vois ce que je veux faire?

23/04/2014, 15h15
Nico02

Je pense comprendre le concept d'un compteur oui..

Mais si tu nous dis qu'il n'affiche pas la bonne valeur mais que tu ne nous montres pas comment tu l'exploites, on va pas beaucoup avancer ;)

Qui fait appel à cette méthode ? Dans quel contexte ( multi-thread ??) ?

J'envoi le même message avec un timer pour mes tests:

Code:

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
 
        patient_gateway_send_to_server.scheduleAtFixedRate(new TimerTask()
        { 
        	public void run() 
        	{
 
                // Record something
				int Last_insert = 0;
				int lifetouch_id = 5;
				double respiration_rate = 5.5;
				long timestamp_in_ms = System.currentTimeMillis();
				boolean acknowledgment_message = false;
 
				// Store on tablet
				Last_insert = MeasurementStorage.storeRespirationMeasurement(lifetouch_id, respiration_rate, timestamp_in_ms, acknowledgment_message);
 
				String last_insert = Integer.toString(Last_insert);
 
				// Send to server
				String adress = "http://192.168.1.147/HealthDataServer/json/reply/LifeTouch_RespRate";
            	// Gateway_Acknowledgement message
            	String message = "{\"id\":0," +
            			"\"gatewayinfoLocalid\":" + lifetouch_id + "," +
            			"\"gatewayinfoSoftwareversion\":" + respiration_rate + "," +
            			"\"gatewayinfoTimestamp\":\"{timestamp_in_ms}\"," +
            			"\"gatewayinfoSessionid\":\"String\",\"acknowledgementFilename\":\"{}\"," +
            			"\"acknowledgementSequenceid\":\"{timestamp_in_ms}\"}";
 
            	new MyAsyncTask().execute(adress, message, last_insert);
 
        	}
        }, 0, 3000L);

Lorsque le message est stocke sur la tablet j'incremente mon compteur +1

Code:

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
 
	public static int storeOximeterMeasurement(int id_oximeter, int pulse, int spo2, long timestamp_in_ms, int sequence_id, boolean acknowledgment_message)
    {
        //TODO This should run as a runnable so not on the main thread.
        ContentValues oximeter_measurement_values = new ContentValues();
        oximeter_measurement_values.put(TableOximeterMeasurement.COLUMN_ID_OXIMETER, id_oximeter);
        oximeter_measurement_values.put(TableOximeterMeasurement.COLUMN_PULSE, pulse);
        oximeter_measurement_values.put(TableOximeterMeasurement.COLUMN_SPO2, spo2);
        oximeter_measurement_values.put(TableOximeterMeasurement.COLUMN_TIMESTAMP, timestamp_in_ms);
        oximeter_measurement_values.put(TableOximeterMeasurement.COLUMN_SEQUENCE_ID, sequence_id);
        oximeter_measurement_values.put(TableOximeterMeasurement.COLUMN_SESSION_NUMBER, session_number);
        oximeter_measurement_values.put(TableOximeterMeasurement.COLUMN_ACKNOWLEDGMENT_MESSAGE, acknowledgment_message);
 
        try
        {
            oximeterMeasurementUri = parent_context.getContentResolver().insert(IsansysPatientGatewayContentProvider.CONTENT_URI_OXIMETER_MEASUREMENTS, oximeter_measurement_values);
            Log.d("saveState : New", oximeterMeasurementUri.toString());
 
            // Counter Message
            PendingMessagesCounter.Counter(1);
 
            String database_row_id_as_string = oximeterMeasurementUri.toString().substring(oximeterMeasurementUri.toString().lastIndexOf('/') + 1);
            int database_row_id = Integer.parseInt(database_row_id_as_string);
            return database_row_id;
        }
        catch (Exception e)
        {
            Log.d("storeOximeterMeasurement Exception", e.toString());
            return 0;
        }
    }

Lorsque je reçois mon accusé de réception via la méthode de postData, -1 :

Code:

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
 
    public class MyAsyncTask extends AsyncTask<String, Integer, Double>{
 
		@Override
		protected Double doInBackground(String... params) {
			// TODO Auto-generated method stub
			postData(params[0], params[1], params[2]);
			return null;
		}
 
		protected void onPostExecute(Double result){
			//pb.setVisibility(View.GONE);
			Toast.makeText(getApplicationContext(), "Command sent!", Toast.LENGTH_SHORT).show();
		}
 
		public void postData(String address, String message, String id_to_update) {
 
			int ID_to_update = Integer.parseInt(id_to_update);
 
			// Create a new HttpClient and Post Header
			HttpClient httpclient = new DefaultHttpClient();
			HttpPost httppost = new HttpPost(address);
 
			try {
				// Add your data
				httppost.setEntity(new StringEntity(message.toString()));
 
				// Execute HTTP Post Request, send message
				try{
					HttpResponse response = httpclient.execute(httppost);
 
					// Get the response : if response == 201, the message has be received, Set True to acknowledgment_message 
					if (response.getStatusLine().getStatusCode() == HttpStatus.SC_CREATED){
 
						Log.d(CLASS_TAG + "showOnScreenMessage", "Got to Server! ");
 
						// Update acknowledgment_message to true
						if(address == "http://192.168.1.147/HealthDataServer/json/reply/LifeTouch_PeakData"){
							MeasurementStorage.updateHeartBeatMeasurement(ID_to_update, true);
							PendingMessagesCounter.Counter(-1);
 
						}
						else if(address == "http://192.168.1.147/HealthDataServer/json/reply/LifeTouch_HeartRate"){
							MeasurementStorage.updateHeartRateMeasurement(ID_to_update, true);
							PendingMessagesCounter.Counter(-1);
							sendMessageStatus(true);
						}
						else if(address == "http://192.168.1.147/HealthDataServer/json/reply/Oximeter_RawDataDataPoint"){
							MeasurementStorage.updateOximeterMeasurement(ID_to_update, true);
							PendingMessagesCounter.Counter(-1);
						}
						else if(address == "http://192.168.1.147/HealthDataServer/json/reply/LifeTouch_RespRate"){
							MeasurementStorage.updateRespirationMeasurement(ID_to_update, true);
							PendingMessagesCounter.Counter(-1);
						}
						else{
							Log.d(CLASS_TAG + "Error Update", "Bad address");
						}
					}
				}
				catch(Exception ex){
					Log.d(CLASS_TAG + "showOnScreenMessage", "Server not responding - or server rejecting! ");
				}
 
 
			} catch (IOException e) {
				// TODO Auto-generated catch block
				Log.d(CLASS_TAG + "Error Sending data", ""+e);
			}
		}
	}

J'ai un peu chargé la désolé

Le problème vient probablement du fait que tu utilises plusieurs threads pour envoyer des messages, mais qu'il n'y a pas de synchronisation entre eux pour accéder au compteur.

Essais de faire comme ça
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 private static int PendingMessages = 0; private static Object lock = new Object(); public void incrementCounter() { synchronized (lock) { PendingMessages++; } } public void decrementCounter() { synchronized (lock) { PendingMessages--; } }
Ah et évite les Counter(1) et Counter(-1) c'est vraiment pas propre :aie::aie: Fais comme dans l’exemple et crées toi 2 méthodes

23/04/2014, 17h32
Benmaster1

MerciiiiiIIIIIIiiiiiIIIII!
Je n'aurai jamais trouve cette histoire de synchro tout seul.
T'assure grave, je t'ai mis des pouces verts!

Pour information, dans ce cas précis un AtomicInteger serait plus adapté. Ça fait la même chose en plus simple et potentiellement plus efficace.
Code:

1 2 3 4 5 6 7 8 9 private static final AtomicInteger pendingMessages = new AtomicInteger(0); public void incrementCounter() { pendingMessages.incrementAndGet(); } public void decrementCounter() { pendingMessages.decrementAndGet(); }