Délai entre méthodes

Version imprimable

Bonjour j'ai un petit soucis je cherche a appeler des méthodes les unes après les autres avec un certain délai entre elle pour leur laisser le temps de s’exécuter.

Voici mon code :

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
public void uptadeGUI (){
 
// Lancement de ma première méthode
 
        dNetworkName = sendCommand("./readData 0");
 
// Aprés x sec - lancement d'une seconde méthode
 
        dState = sendCommand("./readData 1");
 
// Aprés x sec - lancement d'une troisième méthode
 
        dIPv6 = sendCommand("./readData 2");
 
 
 
        /* DISPLAY BORDER ROUTER NAME */
        mBorderRouterName.setText("Border Router Name : " + System.getProperty("line.separator") +  "   " + DEVICE_NAAME);
 
 
 
        /* DISPLAY BORDER ROUTER STATE */
        mBorderRouterState.setText("State : " + System.getProperty("line.separator") +  "   " + STATE +  "  -  " + dState);
 
 
 
        /* DISPLAY NETWORK NAME */
        mNetworkName.setText("Current Network : " + System.getProperty("line.separator") +  "   " + dNetworkName);
 
 
 
        /* DISPLAY IPv6 */
        mNetworkIPv6.setText("Network IPv6 : " + System.getProperty("line.separator") +  "   " + dIPv6);
 
    }

Ensuite le updateGUI est appelé dans un Thread pour être mis à jours :

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
@Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        mBorderRouterName = (TextView) view.findViewById(R.id.textView6);
        mBorderRouterState = (TextView) view.findViewById(R.id.textView2);
        mNetworkName = (TextView) view.findViewById(R.id.textView3);
        mNetworkIPv6 = (TextView) view.findViewById(R.id.textView4);
 
        sendCommand("./writeData");
 
 
        /* Display to refresh all the informations */
        Thread t=new Thread(){
            @Override
            public void run(){
                while(!isInterrupted()){
                    try {
                        Thread.sleep(1000);  //1000ms = 1 sec
                        if(getActivity() == null)
                            return;
                            getActivity().runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                /* Appel de updateGUI() pour rafraichir les informations */
                                uptadeGUI ();
                            }
                        });
 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
 
                }
            }
        };t.start();
    }

Si vous avez une petite idée de comment je pourrais y arriver je suis preneur !

Merci d'avance

08/08/2018, 11h47
grunk
Tu ne peux pas faire comme tu le souhaites puisque tu ne sais jamais combien de temps une commande va mettre de temps à s'executer.
Si tu attends 1 sec et que finalement l'execution dure 2s ?

Une solution à ton problème consiste à faire en sorte de passer un callback à ta fonction sendCommand(). De cette manière quand ta fonction se termine elle appel un callback particulier. Dans ce callback tu lance la seconde commande et ainsi de suite.

En gros ca se résume à faire une interface et l'implémenter :

INterface définissant le callback
Code:

1 2 3 public interface CommandListener { public abstract void onCommandSent(); }
Appel de la fonction en ajoutant le callback
Code:

1 2 3 4 5 6 7 sendCommand("./readData 0", new CommandListener () { @Override public void onCommandSent() { //Lancer 2ème commande } });
Ajout du callback en paramètre de la fonction
Code:

1 2 3 4 5 sendCommand(String txt, CommandListener event) { //Une fois la commande terminé on déclenche le callback event.onCommandSent(); }

Citation:

Tu ne peux pas faire comme tu le souhaites puisque tu ne sais jamais combien de temps une commande va mettre de temps à s'executer.
Si tu attends 1 sec et que finalement l'execution dure 2s ?

Oui, c'est vrai mais je pensais mettre une valeur élevée histoire d'être assez large.

J'ai donc effectué les modifications comme tu m'as expliqué mais les deux sendCommand se font toujours en même temps.

Voilà mon code :

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
72
73
74
75
76
77
78
79
 
// Interface définissant le callback
 
public interface CommandListener {
        public abstract void onCommandSent();
    }
 
 
    public void uptadeGUI (){
 
//        dRSSI = sendCommand("hcitool rssi EC:10:7B:BA:C5:D3");
//
//        dNetworkName = sendCommand("./readData 0");
//
//        dState = sendCommand("./readData 1");
//
//        dIPv6 = sendCommand("./readData 2");
 
// Appel de la fonction en ajoutant les callback
 
         dNetworkName = sendCommand("./readData 0", new CommandListener () {
            @Override
            public void onCommandSent()
            {
                dNetworkName = sendCommand("./readData 1", new CommandListener () {
                    @Override
                    public void onCommandSent()
                    {
 
 
                    }
                });
 
            }
        });
 
 
        /* DISPLAY BORDER ROUTER NAME */
        mBorderRouterName.setText("Border Router Name : " + System.getProperty("line.separator") +  "   " + DEVICE_NAAME);
 
 
 
        /* DISPLAY BORDER ROUTER STATE */
        mBorderRouterState.setText("State : " + System.getProperty("line.separator") +  "   " + STATE +  "  -  " + dState);
 
 
 
        /* DISPLAY NETWORK NAME */
        mNetworkName.setText("Current Network : " + System.getProperty("line.separator") +  "   " + dNetworkName);
 
 
 
        /* DISPLAY IPv6 */
        mNetworkIPv6.setText("Network IPv6 : " + System.getProperty("line.separator") +  "   " + dIPv6);
 
 
        /* DISPLAY RSSI */
//        mRSSI.setText("Signal Strength : " + System.getProperty("line.separator") +  "   RSSI Value : " + dRSSI.substring(18));
 
 
 
    }
 
 
// Fonction sendCommand avec son callback rajouté
 
    public String sendCommand(String command, CommandListener event) {
        String returnMsg;
        sendMessage(command);
 
        returnMsg = READ_MESSAGE;
 
        Log.d(TAG, "READ_MESSAGE : " + READ_MESSAGE);
        Log.d(TAG, "returnMsg : " + returnMsg);
 
        event.onCommandSent();
 
        return returnMsg;
    }

Merci en tous cas de ton aide. Après je me dis que je n'identifie pas dès le départ le bon problème.

Avec ton code actuel elle s'execute forcément l'une après l'autre. Si tu met un Sleep de 2 sec avant d'appeler la seconde commande tu verras qu'elle patiente bien.
En revanche ce qui est possible c'est que ta fonction sendMessage() soit asynchrone ce qui te fait passer très rapidement dans les dans sendCommand.

Ce qui est également sur , c'est que tout tes setText seront fait avant que tes commandes soient finies, c'est peut être un problème pour toi.

Idéalement , il ne faut pas que sendCommand retourne de valeur. Tu devrais plutôt passer la valeur au callback pour l'utiliser ensuite. Quelque chose comme :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public interface CommandListener { public abstract void onCommandSent(String result); } public void sendCommand(String command, CommandListener event) { String returnMsg; sendMessage(command); returnMsg = READ_MESSAGE; event.onCommandSent(returnMsg); } dNetworkName = sendCommand("./readData 0", new CommandListener () { @Override public void onCommandSent(String result) { //Faire quelque chose avec result } });