.net - microsoft - net framework windows 7 64 bits

Cómo saber cuándo Windows está inactivo

Question

Varios programas pueden hacer cosas solo cuando no has usado 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

Los ganchos de teclado y mouse son 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á enganchando. 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.

Answer 2

Google es tu amigo

Básicamente usa esto.
no olvide completar la documentación antes de usarla.

Answer 3

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.

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

Pegado aquí desde P / Invoke

Esta función recupera el tiempo transcurrido desde la última entrada del 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: Implementé un gancho global para teclado y mouse 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]