Surveiller une application externe

Version imprimable

08/02/2017, 12h17
Kinesra

Surveiller une application externe
Bonjour à tous.
Le bout de code que j'ai écrit me permet d'arrêter une application externe qui est en train de tourner grâce à
Code:

1 2 H := FindWindow(nil, 'la fenetre de mon appli'); if H <> 0 then PostMessage(H, WM_CLOSE, 0, 0);
Le problème, c'est qu'il faut que cette application soit lancée et que je connaisse le nom exact de la fenêtre ouverte, ce qui est parfois difficile. Par exemple, le programme 'Photoshop.exe' ouvre une fenêtre qui s'appelle 'Adobe Photoshop CC 2015'.
Mon appli Delphi doit 'surveiller' plusieurs applications dont le nom de l'exe fait partie d'une ListBox et lancer ou arrêter certains d'entre eux en fonction de critères bien définis.
Bref, comment expliquer que si 'MonAppli.exe' est lancée, je dois la fermer. ("MonAppli.exe" étant le nom de l'executable tel qu'il apparaît dans le dossier d'installation de cette appli et qui, souvent, n'est pas celui de la fenêtre ouverte)
Suis-je clair ?

Merci de me donner une piste.

a+

J'ai déjà fait la correspondance entre un processus et ses fenêtres.
Voici un bout de code bricolé pour te donner une piste (pas testé):

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
uses ShellAPI
 
// Pour chercher un processus par le nom de l'exe.
 
procedure TFormProcessus.EnumProcessus;
var
   nSnapShot: Integer;
   ProcessEntry: TProcessEntry32;
begin
   nSnapShot := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 
   // Si erreur.
   if nSnapShot = -1 then
      Exit;
   try
      ProcessEntry.dwSize := SizeOf(ProcessEntry);
 
      // Lecture du premier processus de la liste.
      if Process32First(nSnapShot, ProcessEntry) then
      begin
         if ProcessEntry.szExeFile = 'le fichier exe que je cherche' then
         begin
            // Trouvé :  recherche des fenêtres avec le ProcessEntry.th32ProcessID ...
 
 
            Exit;
         end;
 
         // Tant qu'il reste un processus.
         while Process32Next(nSnapShot, ProcessEntry) do
         begin
            if ProcessEntry.szExeFile = 'le fichier exe que je cherche' then
            begin
               // Trouvé :  recherche des fenêtres avec le ProcessEntry.th32ProcessID ...
 
 
               Exit;
            end;
         end;
      end;
   finally
      CloseHandle(nSnapShot);
   end;
end;

Pour chercher les fenêtres par le Pid du processus :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function EnumWindowsProc(Wnd: HWND; lParam: lParam): BOOL;   stdcall;
var
   Param: Integer;
   cPid: Cardinal;
begin
   Result := True;
 
   // Recherche.
   GetWindowThreadProcessID(Wnd, @cPid);
   if MonPID = cPid then
   begin
      // Plus qu'à envoyer le message à la fenêtre ...
 
      Param := 0;
   end;
end;
 
// Appel.
nParam := 0;
EnumWindows(@EnumWindowsProc, nParam);

Pour faire ce que tu veux, moi j'utilise cette procédure qui fonctionne bien.
Ce n'est pas moi qui l'ai écrite, mais je ne sais plus exactement où je l'ai trouvée.
Il y a une référence à son auteur dans les commentaires.

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
 
function ExeRunning(NomApplication : string; StopProcess:Boolean):Boolean;
//Test si une application est en cours d'exécution
// StopProcess indique si on termine l'application 'NomApplication'
 
// Code proposé par Thunder_nico
 
var
   ProcListExec : TProcessentry32;
   PrhListExec : Thandle;
   Continu : Boolean;
   isStarted : Boolean;
   HandleProcessCourant : Cardinal;
   PathProcessCourant : string;
   ProcessCourant :String;
 
begin
     result:=False;
     if NomApplication='' then Exit;
     // Liste des applications en cours d'exécution
     // Initialisation des variables et récuperation de la liste des process
     ProcListExec.dwSize:=sizeof(ProcListExec);
     Continu := True;
     isStarted := False;
 
     Try
         // Récupére la liste des process en cours d'éxécution au moment de l'appel
        PrhListExec:=CreateToolhelp32Snapshot(TH32CS_SNAPALL,0);
        if (PrhListExec <> INVALID_HANDLE_VALUE)
         then
         begin
          //On se place sur le premier process
          Process32First(PrhListExec,ProcListExec);
 
            // Tant que le process recherché n'est pas trouvé et qu'il reste
            // des process dans la liste, on parcourt et analyse la liste
          while Continu do
          begin
            ProcessCourant := Uppercase(ProcListExec.szExeFile);
            isStarted := (ProcessCourant = Uppercase(ExtractFileName(NomApplication)));
            if isStarted then
             begin
              HandleProcessCourant := ProcListExec.th32ProcessID;
              PathProcessCourant := ExtractFilepath(ProcListExec.szExeFile);
              Continu := False;
             end
            else // Recherche le process suivant dans la liste
              Continu := Process32Next(PrhListExec,ProcListExec);
          end;
 
          if StopProcess
           then
            if isStarted then
             begin  // Termine le process en indiquant le code de sortie zéro
              TerminateProcess(OpenProcess(PROCESS_TERMINATE,False,HandleProcessCourant),0);
              Sleep(500); // Laisse le temps au process en cours de suppression de s'arrêter
             end;
        end;
     Finally
        CloseHandle(PrhListExec); // Libére les ressources
        Result := isStarted;
     end;
end;

08/02/2017, 13h45
Kinesra

Citation:

Envoyé par Bernard B

Pour faire ce que tu veux, moi j'utilise cette procédure qui fonctionne bien.

:D

Génial ! Un bout de code qui fait parfaitement le job !!

Merci à toi et à Thunder_nico.

Merci Lung, ton code est très intéressant et je le garde sous le coude ...
08/02/2017, 14h11
Andnotor
Attention à cette ligne TerminateProcess(OpenProcess(PROCESS_TERMINATE,False,HandleProcessCourant),0), le handle retourné par OpenProcess doit être libéré par CloseHandle. De plus, WaitForSingleObject sur ce handle remplacerait avantageusement ce Sleep(500) qui ne garantit en tout cas pas que le processus est bien arrêté à la sortie de la fonction (si tel est le souhait) ;)

A noter aussi que ExtractFilepath(ProcListExec.szExeFile) renverra toujours une chaîne vide, szExeFile ne contient que le nom de l'exe.

Et comme pour toute les fonctions First/Next, on écrirait plutôt la boucle ainsi :
Code:

1 2 3 4 if Process32First(...) then repeat ... until not Process32Next(...);

Eureka !

Avec votre aide, voila la solution (qui marche nickel pour moi)

Pour trouver l'ID du process en fonction du nom de l'exe :

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
//------- Entree : Nom de l'executable : Sortie : ID du process, 0 si non trouvé  ---------------------
Function GetProcessID(NomExe : String) : Cardinal;
var
   ProcListExec : TProcessentry32;
   PrhListExec : Thandle;
 
Begin
    ProcListExec.dwSize := sizeof(ProcListExec);
    PrhListExec := 0;
    Result := 0;
 
    Try
        PrhListExec := CreateToolhelp32Snapshot(TH32CS_SNAPALL,0);
        if (PrhListExec <> INVALID_HANDLE_VALUE) then
        begin
            // Parcourt la liste des process à la recherche de 'NomExe'
            if Process32First(PrhListExec, ProcListExec) then
            Repeat
                If Uppercase(ProcListExec.szExeFile) = Uppercase(NomExe) then // trouvé !
                Begin
                    Result := ProcListExec.th32ProcessID; // Retourne le process ID
                    break;
                End;
            Until not (Process32Next(PrhListExec,ProcListExec));
        end;
    Finally
        CloseHandle(PrhListExec);
    end;
End;

Ensuite, pour terminer proprement le process :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
[...]
Var
  HProcess : THandle;
  Process : cardinal;
 
[...]
 
Process := GetProcessID('Notepad++.exe'); // ... par exemple
if Process > 0 then
try
	HProcess := OpenProcess(PROCESS_TERMINATE, False, Process); // Demande d'accés à la propriété TERMINATE du process
	TerminateProcess(HProcess,0);                               // Termine le process
	WaitForSingleObject(HProcess, INFINITE);                    // Attend (infiniment !) que le process se termine proprement
Finally
	CloseHandle(HProcess);
end;

La vie est belle ! :D