Cómo saber cuándo Windows está inactivo

Question

Varios programas pueden hacer cosas solo cuando no ha utilizado la computadora por un tiempo (por ejemplo, protector de pantalla, indexación de Google Desktop, etc.).

¿Cómo saben cuándo ha estado inactivo? ¿Hay alguna función en Windows que le diga cuánto tiempo ha estado inactiva, o tiene que utilizar algún tipo de gancho de teclado/mouse para realizar un seguimiento de la actividad usted mismo?

Estoy usando C#, pero estoy interesado en cualquier método para determinar la inactividad.

Answer 1

EDITAR: respuesta modificada, proporcionando texto y detalles detrás de la respuesta de Shy (que debe ser y fue aceptado). Siéntase libre de combinar y eliminar este.

GetLastInputInfo Función La función GetLastInputInfo recupera la hora del último evento de entrada.

pegado aquí de P/Invoke

Esta función recupera el tiempo desde la última entrada de usuario

[DllImport("user32.dll")] 
static extern bool GetLastInputInfo(ref LASTINPUTINFO plii); 

static int GetLastInputTime() 
{ 
    int idleTime = 0; 
    LASTINPUTINFO lastInputInfo = new LASTINPUTINFO(); 
    lastInputInfo.cbSize = Marshal.SizeOf(lastInputInfo); 
    lastInputInfo.dwTime = 0; 

    int envTicks = Environment.TickCount; 

    if(GetLastInputInfo(ref lastInputInfo)) 
    { 
    int lastInputTick = lastInputInfo.dwTime; 

    idleTime = envTicks - lastInputTick; 
    } 

    return ((idleTime > 0) ? (idleTime/1000) : idleTime); 
} 

[StructLayout(LayoutKind.Sequential)] 
struct LASTINPUTINFO 
{ 
    public static readonly int SizeOf = Marshal.SizeOf(typeof(LASTINPUTINFO)); 

    [MarshalAs(UnmanagedType.U4)] 
    public int cbSize;  
    [MarshalAs(UnmanagedType.U4)] 
    public UInt32 dwTime; 
} 

Fwiw: he implementado un gancho de teclado y ratón global durante AnAppADay. Vea esta aplicación para la fuente, está muy cerca de lo que quiere. Las clases que deseará están en el espacio de nombres AnAppADay.Utils. [rayado debido a linkrot]

Answer 2

Google is your friend

utiliza Básicamente this.
no se olvide de la documentación totalmente listo antes de usar.

Answer 3

El gancho del teclado y el mouse es lo que considero más valioso. La clase a continuación se puede insertar y solo tiene que averiguar qué desea hacer con la información sobre las actualizaciones de teclas y mouse.

using System; 
using System.Runtime.InteropServices; 
using System.Threading; 
using System.Windows.Forms; 

namespace Example { 

    public class Hook { 

     delegate int HookProc(int nCode, IntPtr wParam, IntPtr lParam); 

     [FlagsAttribute] 
      public enum WindowMessage { 
      WM_KEYDOWN =  0x0000000000000100, // &H100 
      WM_MOUSEMOVE =  0x0000000000000200, // &H200 
      WM_LBUTTONDOWN = 0x0000000000000201, // &H201 
      WM_RBUTTONDOWN = 0x0000000000000204, // &H204 
      WH_KEYBOARD = 2, 
      WH_MOUSE = 7, 
      HC_ACTION = 0 
     } 

     [DllImport("user32.dll",CharSet=CharSet.Auto, CallingConvention=CallingConvention.StdCall)] 
     private static extern int CallNextHookEx(int idHook, int nCode, IntPtr wParam, IntPtr lParam); 

     [DllImport("user32.dll",CharSet=CharSet.Auto, CallingConvention=CallingConvention.StdCall)] 
     private static extern bool UnhookWindowsHookEx(int idHook); 

     [DllImport("user32.dll",CharSet=CharSet.Auto, CallingConvention=CallingConvention.StdCall)] 
     private static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId); 

     //Declare MouseHookProcedure as a HookProc type. 
     static HookProc MouseHookProcedure; 
     static HookProc KeyboardHookProcedure; 

     private static int mhMouseHook = 0; 
     private static int mhKeyboardHook = 0; 

     public Hook() {} 

     public static void Init() { 
      MouseHookProcedure = new HookProc(MouseHookProc); 
      KeyboardHookProcedure = new HookProc(KeyboardHookProc); 
      mhMouseHook = SetWindowsHookEx((int)WindowMessage.WH_MOUSE, MouseHookProcedure, (IntPtr)0, AppDomain.GetCurrentThreadId()); 
      mhKeyboardHook = SetWindowsHookEx((int)WindowMessage.WH_KEYBOARD, KeyboardHookProcedure, (IntPtr)0, AppDomain.GetCurrentThreadId()); 
     } 

     public static void Terminate() { 
      UnhookWindowsHookEx(mhMouseHook); 
      UnhookWindowsHookEx(mhKeyboardHook); 
     } 

     private static int MouseHookProc(int nCode, IntPtr wParam, IntPtr lParam) { 
      if (nCode >= 0) { 
       //do something here to update the last activity point, i.e. a keystroke was detected so reset our idle timer. 
      } 
      return CallNextHookEx(mhMouseHook, nCode, wParam, lParam); 
     } 

     private static int KeyboardHookProc(int nCode, IntPtr wParam, IntPtr lParam) { 
      if (nCode >= 0) { 
       //do something here to update the last activity point, i.e. a mouse action was detected so reset our idle timer. 
      } 
      return CallNextHookEx(mhKeyboardHook, nCode, wParam, lParam); 
     } 

    } 
} 

Por supuesto, esto solo funciona dentro de la aplicación que está conectando. Si necesita rastrear la inactividad en todo el sistema, debe crear una DLL que pueda cargarse en los espacios de direcciones de todas las demás ventanas. Lamentablemente, no he oído hablar de ningún hack que permita un .dll compilado en .net que funcione en este escenario; tenemos una DLL de C++ que se engancha con este propósito.