Programme Java pour surveiller l'ouverture fermeture d'un programme sous Windows

Version imprimable

15/05/2015, 07h38
luckyalan

Programme Java pour surveiller l'ouverture fermeture d'un programme sous Windows

bonjour,
je voudrais faire une petite appli qui surveille mon activité et me dit combien de temps j'ai utilisé un programme (par exemple le jeu "spider solitaire")
il me faut donc lancer le prog à l'ouverture de l'ordi puis qu'il guette
ensuite il me suffira de faire le calcul de la durée d'utilisation
voici ma question :
comment faire pour qu'il détecte que j'ouvre le programme et que je le ferme ?
merci

Salut avec TaskManager tu peux récupérer les process ou par exemple

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
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
 
class WindowsUtils {
    private WindowsUtils() {
    }
 
    public static String listOfProcesses()
            throws IOException {
        InputStream is = null;
        InputStreamReader isr = null;
        BufferedReader br = null;
 
        List<String> command = new ArrayList<String>();
        command.add("WMIC");
        command.add("process");
        try {
            ProcessBuilder builder = new ProcessBuilder(command);
            Process process = builder.start();
            is = process.getInputStream();
            isr = new InputStreamReader(is);
            br = new BufferedReader(isr);
            StringBuilder sw = new StringBuilder();
 
            String line;
            while ((line = br.readLine()) != null) {
                sw.append(line.trim());
                sw.append(System.lineSeparator());
            }
            return sw.toString();
        } finally {
            if (br != null)
                br.close();
            if (isr != null)
                isr.close();
            if (is != null)
                is.close();
        }
    }
}
 
public class WmicExample {
 
    public static void main(String[] args) throws Exception {
        System.out.println(WindowsUtils.listOfProcesses());
    }
}

te permet de récuperer les process

16/05/2015, 20h22
luckyalan

bonjour Hugoclo,
merci pour ta réponse
malheureusement j'avoue que je n'y comprends pas grand chose.
j'ai copié ton programme et effectivement il me donne la liste des processus en cours. Ca c'est bien, mais moi je n'ai fait que copier sans comprendre
pour info, il ne m'a pas donné "SpiderSolitaire.exe" comme en cours, mais je pense que c'est parce que ce n'est pas un exe indépendant, mais un élément de Vista. j'ai lancé un autre jeu, tetris et effectivement il me l'a donné dans sa liste
comment je fais pour que mon programme détecte l'ouverture du programme au moment ou elle se fait et sa fermeture au moment ou elle a lieu pour que je puisse en déduire l'heure ?

Désolé, je suis débutant de chez débutant et j'avoue que je ne comprends pas tout non plus à la classe "public static String listOfProcesses()" que tu m'as transmise, sauf qu'elle fonctionne impeccablement et que les 2 commandes WMIC suivi de process sous windows déclenchent la liste des process en cours...
17/05/2015, 13h54
hugoclo

Salut,

Regarde ce code il permet de détecter quand un process s’arrête.

bonsoir,
merci hugoclo pour ta suggestion,
comme d'hab je ne comprends pas tout le fonctionnement du code que tu m'indiques par le lien.
supposons que je veuilles surveiller "toto.exe"
dans les lignes de code que tu m'as suggérées et que j'ai recopié ci dessous, où et comment dois je mettre "toto.exe" pour qu'il détecte la fermeture ?

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
80
81
82
83
84
85
/**
 * Detects when a process is finished and invokes the associated listeners.
 */
public class ProcessExitDetector extends Thread {
 
    /** The process for which we have to detect the end. */
    private Process process;
    /** The associated listeners to be invoked at the end of the process. */
    private List&lt;ProcessListener&gt; listeners = new ArrayList&lt;ProcessListener&gt;();
 
    /**
     * Starts the detection for the given process
     * @param process the process for which we have to detect when it is finished
     */
    public ProcessExitDetector(Process process) {
        try {
            // test if the process is finished
            process.exitValue();
            throw new IllegalArgumentException("The process is already ended");
        } catch (IllegalThreadStateException exc) {
            this.process = process;
        }
    }
 
    /** @return the process that it is watched by this detector. */
    public Process getProcess() {
        return process;
    }
 
    public void run() {
        try {
            // wait for the process to finish
            process.waitFor();
            // invokes the listeners
            for (ProcessListener listener : listeners) {
                listener.processFinished(process);
            }
        } catch (InterruptedException e) {
        }
    }
 
    /** Adds a process listener.
     * @param listener the listener to be added
     */
    public void addProcessListener(ProcessListener listener) {
        listeners.add(listener);
    }
 
    /** Removes a process listener.
     * @param listener the listener to be removed
     */
    public void removeProcessListener(ProcessListener listener) {
        listeners.remove(listener);
    }
}
The code is very easy to understand. It creates a class as the detector for the process exit. It has a process to watch for passed in as a constructor argument. The entire thread does nothing else than wait for the given process to finish and then invokes the listeners.
The code for the ProcessListener is as easy:
 
1
2
3
public interface ProcessListener extends EventListener {
    void processFinished(Process process);
}
Now you have a very easy way to detect when a subprocess is finished, and as proof, here is a code sample:
 
1
2
3
4
5
6
7
8
9
// ...
processExitDetector = new ProcessExitDetector(subprocess);
processExitDetector .addProcessListener(new ProcessListener() {
    public void processFinished(Process process) {
        System.out.println("The subprocess has finished.");
    }
});
processExitDetector.start();
// ...
.

d'autre part, j'ai prévu de faire un petit bout de prog qui éditera les exe ouverts avec command.add("WMIC"); et command.add("process") comme tu me l'as indiqué dans ton premier post et qui lancera la commande et son analyse toutes les 2 minutes, est-ce que ce ne sera pas trop énergivore ?
merci