Dans le cadre d’un PPE (Projet Pluridisciplinaire Encadré) en Terminale, nous nous sommes proposés d’étudier les solutions au problème de l’oubli de sa clé USB (ou un autre periphérique USB) sur son unité centrale. Parmis ces solutions il y a des choses très faciles à réaliser comme par exemple relier sa clé USB à son poignet avec une ficelle. Cependant cette solution est peu pratique bien qu’elle soit un moyen sûr de ne pas oublier sa clé USB.
Nous avons pensé à une autre solution qui consisterait à ce qu’un programme affiche un message avertissant l’utilisateur que sa clé usb est branchée quand celui-ci éteint son PC. Il nous faudrait un programme sous windows si cela est possible.
En vous remerciant…Bonne chance
Pou moi, le plus dur, c’est de détecter l’arrêt de windows. Je ferais bien un programme qui reste actif dès le démarrage de windows, et qui détecte un évènement “onQuit” normalement lancé par Windows à tous les prog pour qu’ils s’arrête.
et là, tu fait le test sur la clef USB: pour moi la solution la plus simple, c’est de détecter si le lecteur réseau associé existe, c’est un peu bidulique parce qu’il faut paramétrer sur chaque poste à quel lecteur ça va correspondre, mais pour un simple projet de terminale, ça devrait être suffisant. 
En Java, je vois à peut près comment on pourrait faire, alors je peut t’aider, sinon, en visual studio ou dot net, il doit y avoir moyen, mais là, je n’en sais pas plus.
Donc choisi ton langage (si tu veut faire de la prog), indique le dans le titre.
Je pense qu’un prog en Java conviendrait à notre étude. Merci pour ton aide deltree 
deltree> peut-être atexit pour le C ? (vu comme le programme est quitté?) ou via un signal
Sans-Nom> oui, je ne suis pas anti-C, mais comme j’ai arrêté le C depuis longtemps, j’ai tout oublié.
gros_looser_de_la_prog> c’est cool si tu as choisi ton langage, il va falloir faire des essais pour capturer l’évènement de fin de programme: faire une programme qui boucle que un sleep, et qui récupère l’exception la terminaison: j’ai fait plusieurs essai, mais il faut regarder avec ça:
http://www-128.ibm.com/developerworks/ibm/…signalhandling/
le plus simple est de poser un shutdownHook, j’essais de faire quelques essais, et on en reparle.
essaie de couper le prog avec ctrl-C pour simuler la terminaison de windows.
Est-ce que tu est au point pour la prog Java, avec eclipse ou même Notepad+jdk?
Sinon, avec la solution de Sans-Nom, il faut un compilo C, peut-être dev-C++ (que je n’est malheureusement pas testé).
Voilà le code qui marhce avec Ctrl-C:
import sun.misc.Signal;
import sun.misc.SignalHandler;
/**
* @author deltree
*/
public class Test implements Runnable{
public void run(){
while(true){
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
System.out.println("bye 1");
}
}
}
public void finalize(){
System.out.println("bye 2");
}
public static void main(String[] argv){
// hook the jvm termination
Runtime.getRuntime().addShutdownHook(new MyShutdown());
// loop forever
new Thread(new Test()).start();
}
}
// Example shutdown hook class
class MyShutdown extends Thread {
public void run() {
System.out.println("MyShutdown hook called");
}
}
ça affiche un message quand la JVM termine, mais il ne faut pas forcer la terminaison par un kill…
Je ne m’y connais vraiment pas en prog (que ce soit du java du C du C++ etc… c’est pareil pour moi).
Sinon je comprend a peu près ce programme avec l’aide de mon professeur mais je ne vois pas comment on détecte que windows va fermer. J’ai cherché sur Internet mais en vain.
Etant donné que lorsque je ferme une session sur mon ordinateur, il quitte comme un sauvage tous les programmes, je dirais que ça ne semble pas être possible…
sinon c’est sûrement un signal qui est envoyé (SIGEXIT ?)
// Code par KarLKoX
#include <windows.h>
#ifndef WM_DEVICECHANGE
#define WM_DEVICECHANGE 0x219
#endif
#ifndef DBT_DEVICEARRIVAL
#define DBT_DEVICEARRIVAL 0x8000
#endif
#ifndef DBT_DEVICEREMOVECOMPLETE
#define DBT_DEVICEREMOVECOMPLETE 0x8004
#endif
/* Declare Windows procedure */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
/* Make the class name into a global variable */
char szClassName[ ] = "WindowsApp";
int WINAPI WinMain (HINSTANCE hThisInstance,
HINSTANCE hPrevInstance,
LPSTR lpszArgument,
int nFunsterStil)
{
HWND hwnd; /* This is the handle for our window */
MSG messages; /* Here messages to the application are saved */
WNDCLASSEX wincl; /* Data structure for the windowclass */
/* The Window structure */
wincl.hInstance = hThisInstance;
wincl.lpszClassName = szClassName;
wincl.lpfnWndProc = WindowProcedure; /* This function is called by windows */
wincl.style = CS_DBLCLKS; /* Catch double-clicks */
wincl.cbSize = sizeof (WNDCLASSEX);
/* Use default icon and mouse-pointer */
wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
wincl.lpszMenuName = NULL; /* No menu */
wincl.cbClsExtra = 0; /* No extra bytes after the window class */
wincl.cbWndExtra = 0; /* structure or the window instance */
/* Use Windows's default color as the background of the window */
wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;
/* Register the window class, and if it fails quit the program */
if (!RegisterClassEx (&wincl))
return 0;
/* The class is registered, let's create the program*/
hwnd = CreateWindowEx (
0, /* Extended possibilites for variation */
szClassName, /* Classname */
"Windows App", /* Title Text */
WS_OVERLAPPEDWINDOW, /* default window */
CW_USEDEFAULT, /* Windows decides the position */
CW_USEDEFAULT, /* where the window ends up on the screen */
544, /* The programs width */
375, /* and height in pixels */
HWND_DESKTOP, /* The window is a child-window to desktop */
NULL, /* No menu */
hThisInstance, /* Program Instance handler */
NULL /* No Window Creation data */
);
/* Make the window visible on the screen */
ShowWindow (hwnd, nFunsterStil);
/* Run the message loop. It will run until GetMessage() returns 0 */
while (GetMessage (&messages, NULL, 0, 0))
{
/* Translate virtual-key messages into character messages */
TranslateMessage(&messages);
/* Send message to WindowProcedure */
DispatchMessage(&messages);
}
/* The program return-value is 0 - The value that PostQuitMessage() gave */
return messages.wParam;
}
/* This function is called by the Windows function DispatchMessage() */
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) /* handle the messages */
{
// Bonus :)
case WM_DEVICECHANGE:
if (wParam == DBT_DEVICEARRIVAL)
MessageBox(hwnd, "Une clé USB vient d'être connectée.", "Info", MB_OK);
else if (wParam == DBT_DEVICEREMOVECOMPLETE)
MessageBox(hwnd, "Une clé USB vient d'être déconnectée.", "Info", MB_OK);
break;
/* Le fameux message envoyé à tous les programmes par windows;)
case WM_QUERYENDSESSION: <-- si tu souhaites que l'utilisateur choisis de ferme la sessions ou pas
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/shutdown/base/wm_queryendsession.asp
*/
case WM_ENDSESSION:
MessageBox(hwnd, "Windows va se fermer.", "Info", MB_OK);
return 0;
case WM_DESTROY:
PostQuitMessage (0); /* send a WM_QUIT to the message queue */
break;
default: /* for messages that we don't deal with */
return DefWindowProc (hwnd, message, wParam, lParam);
}
return 0;
}
voilà avec des zolis signaux