Low level keyboard hook on a timer

I have a keyboard hook that intercepts the keys and outputs a random letter. What I want to do is set up a timer and have the keyboard unhook after one minute then in another minute hook itself back up. So the first part works, it hooks up on start and after one minute it unhooks, but then never hooks up again. How could I get it to re-hook after being unhooked?

Here's is the hook code:

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace Utilities {
/// <summary>
/// A class that manages a global low level keyboard hook
/// </summary>
class globalKeyboardHook {
    #region Constant, Structure and Delegate Definitions
    /// <summary>
    /// defines the callback type for the hook
    /// </summary>
    public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);

    public struct keyboardHookStruct {
        public int vkCode;
        public int scanCode;
        public int flags;
        public int time;
        public int dwExtraInfo;
    }

    const int WH_KEYBOARD_LL = 13;
    const int WM_KEYDOWN = 0x100;
    const int WM_KEYUP = 0x101;
    const int WM_SYSKEYDOWN = 0x104;
    const int WM_SYSKEYUP = 0x105;

    #endregion

    #region Instance Variables
    /// <summary>
    /// The collections of keys to watch for
    /// </summary>
    public List<Keys> HookedKeys = new List<Keys>();
    /// <summary>
    /// Handle to the hook, need this to unhook and call the next hook
    /// </summary>
    IntPtr hhook = IntPtr.Zero;
    #endregion

    #region Events
    /// <summary>
    /// Occurs when one of the hooked keys is pressed
    /// </summary>
    public event KeyEventHandler KeyDown;
    /// <summary>
    /// Occurs when one of the hooked keys is released
    /// </summary>
    public event KeyEventHandler KeyUp;
    #endregion

    #region Constructors and Destructors
    /// <summary>
    /// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
    /// </summary>
    public globalKeyboardHook() {

    }



    /// <summary>
    /// Releases unmanaged resources and performs other cleanup operations before the
    /// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
    /// </summary>
    ~globalKeyboardHook() {
        unhook();
    }
    #endregion

    #region Public Methods
    /// <summary>
    /// Installs the global hook
    /// </summary>
    public void hook() {
        _hookProc = new keyboardHookProc(hookProc);
        IntPtr hInstance = LoadLibrary("User32");
        hhook = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0);
    }

    /// <summary>
    /// Uninstalls the global hook
    /// </summary>
    public void unhook() {
        UnhookWindowsHookEx(hhook);
        hhook = IntPtr.Zero;
    }

    /// <summary>
    /// The callback for the keyboard hook
    /// </summary>
    /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
    /// <param name="wParam">The event type</param>
    /// <param name="lParam">The keyhook event information</param>
    /// <returns></returns>
    public int hookProc(int code, int wParam, ref keyboardHookStruct lParam) {
        if (code >= 0) {
            Keys key = (Keys)lParam.vkCode;
            if (HookedKeys.Contains(key)) {
                KeyEventArgs kea = new KeyEventArgs(key);
                if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null)) {
                    KeyDown(this, kea) ;
                } else if ((wParam == WM_KEYUP || wParam == WM_SYSKEYUP) && (KeyUp != null)) {
                    KeyUp(this, kea);
                }
                if (kea.Handled)
                    return 1;
            }
        }
        return CallNextHookEx(hhook, code, wParam, ref lParam);
    }
    #endregion

    #region DLL imports
    /// <summary>
    /// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
    /// </summary>
    /// <param name="idHook">The id of the event you want to hook</param>
    /// <param name="callback">The callback.</param>
    /// <param name="hInstance">The handle you want to attach the event to, can be null</param>
    /// <param name="threadId">The thread you want to attach the event to, can be null</param>
    /// <returns>a handle to the desired hook</returns>
    [DllImport("user32.dll")]
    static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);

    /// <summary>
    /// Unhooks the windows hook.
    /// </summary>
    /// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
    /// <returns>True if successful, false otherwise</returns>
    [DllImport("user32.dll")]
    static extern bool UnhookWindowsHookEx(IntPtr hInstance);

    /// <summary>
    /// Calls the next hook.
    /// </summary>
    /// <param name="idHook">The hook id</param>
    /// <param name="nCode">The hook code</param>
    /// <param name="wParam">The wparam.</param>
    /// <param name="lParam">The lparam.</param>
    /// <returns></returns>
    [DllImport("user32.dll")]
    static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);

    /// <summary>
    /// Loads the library.
    /// </summary>
    /// <param name="lpFileName">Name of the library</param>
    /// <returns>A handle to the library</returns>
    [DllImport("kernel32.dll")]
    static extern IntPtr LoadLibrary(string lpFileName);

    keyboardHookProc _hookProc;

    #endregion
}
}

Here is the entry point to the application:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using Utilities;
using System.Timers;

namespace KeyRemapWindowsForm
{
static class Program
{
    static bool _isHookActive = true;
    static globalKeyboardHook gkh  = new globalKeyboardHook();
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        System.Timers.Timer HookTimer = new System.Timers.Timer(60000);
        HookTimer.Elapsed += new ElapsedEventHandler(HookTimer_Elapsed);
        HookTimer.Start();

        Begin();
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run();
        GC.KeepAlive(HookTimer);
    }

    // Sp开发者_如何转开发ecify what you want to happen when the Elapsed event is 
    // raised.
    static void HookTimer_Elapsed(object source, ElapsedEventArgs e)
    {
        if (_isHookActive)
        {
            End();
        }
        else
        {
            Begin();
        }
    }

    static void Begin()
    {
        gkh = new globalKeyboardHook();
        gkh.hook();
        gkh.HookedKeys.Add(Keys.A);
        gkh.HookedKeys.Add(Keys.B);
        gkh.KeyDown += new KeyEventHandler(gkh_KeyDown);
        gkh.KeyUp += new KeyEventHandler(gkh_KeyUp);
        _isHookActive = true;
    }

    static void End()
    {
        gkh.HookedKeys.Clear();
        gkh.KeyDown -= new KeyEventHandler(gkh_KeyDown);
        gkh.KeyUp -= new KeyEventHandler(gkh_KeyUp);
        gkh.unhook();
        _isHookActive = false;
    }

    static void gkh_KeyUp(object sender, KeyEventArgs e)
    {
        SendKeys.Send(((KeyboardKeys)GetRandomKeyCode()).ToString());
        e.Handled = true;
    }

    static void gkh_KeyDown(object sender, KeyEventArgs e)
    {            
        e.Handled = true;
    } 

    static int GetRandomKeyCode()
    {
        int RandomNum = 0;
        while(RandomNum == 0)
        {
            Random RanNum = new Random();
            RandomNum = RanNum.Next(65, 90);

            switch(RandomNum)
            {
                case 68:
                case 69:
                case 86:
                RandomNum = 0;
                    break;
                default:
                    break;
            }

        }

        return RandomNum;
    }
}

public enum KeyboardKeys
{
    /// <summary>
    /// The A key.
    /// </summary>
    A = 65,
    /// <summary>
    /// The B key.
    /// </summary>
    B = 66,
    /// <summary>
    /// The C key.
    /// </summary>
    C = 67,
    /// <summary>
    /// The D key.
    /// </summary>
    D = 68,
    /// <summary>
    /// The E key.
    /// </summary>
    E = 69,
    /// <summary>
    /// The F key.
    /// </summary>
    F = 70,
    /// <summary>
    /// The G key.
    /// </summary>
    G = 71,
    /// <summary>
    /// The H key.
    /// </summary>
    H = 72,
    /// <summary>
    /// The I key.
    /// </summary>
    I = 73,
    /// <summary>
    /// The J key.
    /// </summary>
    J = 74,
    /// <summary>
    /// The K key.
    /// </summary>
    K = 75,
    /// <summary>
    /// The L key.
    /// </summary>
    L = 76,
    /// <summary>
    /// The M key.
    /// </summary>
    M = 77,
    /// <summary>
    /// The N key.
    /// </summary>
    N = 78,
    /// <summary>
    /// The O key.
    /// </summary>
    O = 79,
    /// <summary>
    /// The P key.
    /// </summary>
    P = 80,
    /// <summary>
    /// The Q key.
    /// </summary>
    Q = 81,
    /// <summary>
    /// The R key.
    /// </summary>
    R = 82,
    /// <summary>
    /// The S key.
    /// </summary>
    S = 83,
    /// <summary>
    /// The T key.
    /// </summary>
    T = 84,
    /// <summary>
    /// The U key.
    /// </summary>
    U = 85,
    /// <summary>
    /// The V key.
    /// </summary>
    V = 86,
    /// <summary>
    /// The W key.
    /// </summary>
    W = 87,
    /// <summary>
    /// The X key.
    /// </summary>
    X = 88,
    /// <summary>
    /// The Y key.
    /// </summary>
    Y = 89,
    /// <summary>
    /// The Z key.
    /// </summary>
    Z = 90
}
}

EDIT: So I took Jonathan.Peppers advice and put the check for isActive in the keydown event and that worked as far as faking like it was on and off. Now I have run into a new problem. After I have typed for awhile I get an InvalidOperationException with the reason being "Queue Empty" and not sure why it gets emptied when it's running just fine while I'm typing. I left the keyboard hook code alone but updated the application entry point code to the following:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using Utilities;
using System.Timers;

namespace KeyRemapWindowsForm
{
static class Program
{
    static bool _isHookActive = true;
    static globalKeyboardHook gkh  = new globalKeyboardHook();

    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {
        System.Timers.Timer HookTimer = new System.Timers.Timer(10000);
        HookTimer.Elapsed += new ElapsedEventHandler(HookTimer_Elapsed);
        HookTimer.Start();

        Application.ApplicationExit += new EventHandler(OnApplicationExit);

        gkh.hook();

        gkh.HookedKeys.Add(Keys.S);
        gkh.HookedKeys.Add(Keys.E);

        gkh.KeyDown += new KeyEventHandler(gkh_KeyDown);
        gkh.KeyUp += new KeyEventHandler(gkh_KeyUp);
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run();
        GC.KeepAlive(HookTimer);
    }

    static void OnApplicationExit(object sender, EventArgs e)
    {
        gkh.unhook();
    }

    static void HookTimer_Elapsed(object source, ElapsedEventArgs e)
    {
        if (_isHookActive)
        {
            _isHookActive = false;
        }
        else
        {
            _isHookActive = true;
        }
    }        

    static void gkh_KeyUp(object sender, KeyEventArgs e)
    {
        try
        {
            if (_isHookActive)
            {
                e.Handled = true;
            }
        }
        catch 
        {
            gkh.unhook();
            Application.Exit();
        }
    }

    static void gkh_KeyDown(object sender, KeyEventArgs e)
    {
        try
        {
            if (_isHookActive)
            {
                SendKeys.Send(((Keys)new Random().Next(65, 90)).ToString());
                e.Handled = true;
            }
        }
        catch
        {
            gkh.unhook();
            Application.Exit();
        }
    } 
}
}

EDIT: Stack trace I get from the above code after typing for awhile.

at System.Collections.Queue.Dequeue() at System.Windows.Forms.SendKeys.SendInput(Byte[] oldKeyboardState, Queue previousEvents) at System.Windows.Forms.SendKeys.Send(String keys, Control control, Boolean wait) at System.Windows.Forms.SendKeys.Send(String keys) at KeyRemapWindowsForm.Program.gkh_KeyDown(Object sender, KeyEventArgs e) in C:\Demos\KeyRemapWindowsForm\Program.cs:line 79

I've just been wrangling a very similar issue so I'm adding what I have found out to help anyone else having the problem.

The problem is the thread the hook is created on. The System.Timers.Timer class will by default create a thread on the thread pool, not the main UI thread. If this thread goes, so does your hook.

You need to ensure the timer event it called on a thread that doesn't disappear. You can either: use the .SynchronizingObject property to ensure the call is made in the same thread as the object you specify.

Or you can marshal it yourself if you put something like this at top of your timer event:

this.InvokeCatchDisposedException(new MethodInvoker(() => HookTimer_Elapsed(sender, e)));
            return;

Here's a link to describe the differences between the .net timers I found helpful. https://msdn.microsoft.com/en-us/magazine/cc164015.aspx

Why don't you leave the hook in place continuously?

You can toggle your hook to not modify the keypress with your timer. Put an if (_hookEnabled) in your gkh_KeyUp and gkh_KeyDown methods.

I would think that setting up the hook would be an expensive operation anyways.