Discussion :

[Benmaster1]

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 :

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

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 :

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

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...
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

[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

[Benmaster1]

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 :

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

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

[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.

[Benmaster1]

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

Code :

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
 
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?

[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 ??) ?

[Benmaster1]

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

Code :

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

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

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
 
    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é

[Nico02]

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 :

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
 
 
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 Fais comme dans l’exemple et crées toi 2 méthodes

[Benmaster1]

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

[thelvin]

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 :

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

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