22325004088

Committed 23 Feb 2026 09:11PM UTC coverage: 32.847% (-0.2%) from 33.028%

Build # 22325004088

Build Type

push

github

Committed by

Lakritzator

Commit Message

Merge branch 'master' of https://github.com/dapplo/Dapplo.Windows

Coverage Stats

619 of 2002 branches covered (30.92%)

Branch coverage included in aggregate %.

1702 of 5064 relevant lines covered (33.61%)

29.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/Dapplo.Windows.Messages/WindowsSessionListener.cs

// Copyright (c) Dapplo and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.

#if !NETSTANDARD2_0
using System;
using System.Runtime.InteropServices;
using Dapplo.Windows.Messages.Enumerations;

namespace Dapplo.Windows.Messages;

/// <summary>
///     A listener for Windows session change events.
///     Currently handles lock/unlock and logon/logoff events.
///     Other session change events (console connect/disconnect, remote connect/disconnect, etc.) are not exposed but can be added in the future.
/// </summary>
public class WindowsSessionListener : IDisposable
{
    private IDisposable _subscription;
    private volatile bool _isPaused;
    private volatile bool _isDisposed;
    private readonly object _lock = new object();

    /// <summary>
    ///     Flags for WtsRegisterSessionNotification
    /// </summary>
    private const int NOTIFY_FOR_THIS_SESSION = 0;

    /// <summary>
    /// See <a href="https://learn.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsregistersessionnotification">WTSRegisterSessionNotification function</a>
    /// Registers the specified window to receive session change notifications.
    /// </summary>
    /// <param name="hWnd">Handle to the window to receive session change notifications</param>
    /// <param name="dwFlags">Specifies which session notifications to receive</param>
    /// <returns>Returns true if successful</returns>
    [DllImport("wtsapi32.dll", SetLastError = true)]
    private static extern bool WTSRegisterSessionNotification(IntPtr hWnd, int dwFlags);

    /// <summary>
    /// See <a href="https://learn.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsunregistersessionnotification">WTSUnRegisterSessionNotification function</a>
    /// Unregisters the specified window so that it receives no further session change notifications.
    /// </summary>
    /// <param name="hWnd">Handle to the window to stop receiving session change notifications</param>
    /// <returns>Returns true if successful</returns>
    [DllImport("wtsapi32.dll", SetLastError = true)]
    private static extern bool WTSUnRegisterSessionNotification(IntPtr hWnd);

    /// <summary>
    ///     Event fired when a session lock or unlock occurs
    /// </summary>
    public event EventHandler<SessionChangeEventArgs> SessionLockChange;

    /// <summary>
    ///     Event fired when a session logon or logoff occurs
    /// </summary>
    public event EventHandler<SessionChangeEventArgs> SessionLogonChange;

    /// <summary>
    ///     Starts listening for session change events
    /// </summary>
    public void Start()
    {
        if (_isDisposed)
        {
            throw new ObjectDisposedException(nameof(WindowsSessionListener));
        }

        lock (_lock)
        {
            if (_subscription != null)
            {
                return; // Already started
            }

            if (_isDisposed)
            {
                throw new ObjectDisposedException(nameof(WindowsSessionListener));
            }

            _isPaused = false;

            _subscription = SharedMessageWindow.Listen(
                onSetup: hwnd =>
                {
                    if (!WTSRegisterSessionNotification(hwnd, NOTIFY_FOR_THIS_SESSION))
                    {
                        throw new InvalidOperationException("Failed to register for session notifications");
                    }
                },
                onTeardown: hwnd => WTSUnRegisterSessionNotification(hwnd)
            )
            .Subscribe(m =>
            {
                if (_isPaused || m.Msg != WindowsMessages.WM_WTSSESSION_CHANGE)
                {
                    return;
                }

                var eventType = (WtsSessionChangeEvents)(int)m.WParam;
                var sessionId = (int)m.LParam;

                var args = new SessionChangeEventArgs(eventType, sessionId);

                switch (eventType)
                {
                    case WtsSessionChangeEvents.WTS_SESSION_LOCK:
                    case WtsSessionChangeEvents.WTS_SESSION_UNLOCK:
                        SessionLockChange?.Invoke(this, args);
                        break;

                    case WtsSessionChangeEvents.WTS_SESSION_LOGON:
                    case WtsSessionChangeEvents.WTS_SESSION_LOGOFF:
                        SessionLogonChange?.Invoke(this, args);
                        break;
                }
            });
        }
    }

    /// <summary>
    ///     Pauses listening for session change events
    /// </summary>
    public void Pause()
    {
        _isPaused = true;
    }

    /// <summary>
    ///     Resumes listening for session change events after being paused
    /// </summary>
    public void Resume()
    {
        _isPaused = false;
    }

    /// <summary>
    ///     Stops listening for session change events
    /// </summary>
    public void Stop()
    {
        lock (_lock)
        {
            if (_subscription != null)
            {
                _subscription.Dispose();
                _subscription = null;
            }
            _isPaused = false;
        }
    }

    /// <summary>
    ///     Disposes the listener and stops listening for events
    /// </summary>
    public void Dispose()
    {
        if (_isDisposed)
        {
            return;
        }

        _isDisposed = true;
        Stop();
        GC.SuppressFinalize(this);
    }
}
#endif

1	// Copyright (c) Dapplo and contributors. All rights reserved.
2	// Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
4	#if !NETSTANDARD2_0
5	using System;
6	using System.Runtime.InteropServices;
7	using Dapplo.Windows.Messages.Enumerations;
8
9	namespace Dapplo.Windows.Messages;
10
11	/// <summary>
12	/// A listener for Windows session change events.
13	/// Currently handles lock/unlock and logon/logoff events.
14	/// Other session change events (console connect/disconnect, remote connect/disconnect, etc.) are not exposed but can be added in the future.
15	/// </summary>
16	public class WindowsSessionListener : IDisposable
17	{
18	private IDisposable _subscription;
19	private volatile bool _isPaused;
20	private volatile bool _isDisposed;
21	private readonly object _lock = new object();	×
22
23	/// <summary>
24	/// Flags for WtsRegisterSessionNotification
25	/// </summary>
26	private const int NOTIFY_FOR_THIS_SESSION = 0;
27
28	/// <summary>
29	/// See <a href="https://learn.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsregistersessionnotification">WTSRegisterSessionNotification function</a>
30	/// Registers the specified window to receive session change notifications.
31	/// </summary>
32	/// <param name="hWnd">Handle to the window to receive session change notifications</param>
33	/// <param name="dwFlags">Specifies which session notifications to receive</param>
34	/// <returns>Returns true if successful</returns>
35	[DllImport("wtsapi32.dll", SetLastError = true)]
36	private static extern bool WTSRegisterSessionNotification(IntPtr hWnd, int dwFlags);
37
38	/// <summary>
39	/// See <a href="https://learn.microsoft.com/en-us/windows/win32/api/wtsapi32/nf-wtsapi32-wtsunregistersessionnotification">WTSUnRegisterSessionNotification function</a>
40	/// Unregisters the specified window so that it receives no further session change notifications.
41	/// </summary>
42	/// <param name="hWnd">Handle to the window to stop receiving session change notifications</param>
43	/// <returns>Returns true if successful</returns>
44	[DllImport("wtsapi32.dll", SetLastError = true)]
45	private static extern bool WTSUnRegisterSessionNotification(IntPtr hWnd);
46
47	/// <summary>
48	/// Event fired when a session lock or unlock occurs
49	/// </summary>
50	public event EventHandler<SessionChangeEventArgs> SessionLockChange;
51
52	/// <summary>
53	/// Event fired when a session logon or logoff occurs
54	/// </summary>
55	public event EventHandler<SessionChangeEventArgs> SessionLogonChange;
56
57	/// <summary>
58	/// Starts listening for session change events
59	/// </summary>
60	public void Start()
61	{
62	if (_isDisposed)	×
63	{
64	throw new ObjectDisposedException(nameof(WindowsSessionListener));	×
65	}
66
67	lock (_lock)	×
68	{
69	if (_subscription != null)	×
70	{
71	return; // Already started	×
72	}
73
74	if (_isDisposed)	×
75	{
76	throw new ObjectDisposedException(nameof(WindowsSessionListener));	×
77	}
78
79	_isPaused = false;	×
80
81	_subscription = SharedMessageWindow.Listen(	×
82	onSetup: hwnd =>	×
83	{	×
84	if (!WTSRegisterSessionNotification(hwnd, NOTIFY_FOR_THIS_SESSION))	×
85	{	×
86	throw new InvalidOperationException("Failed to register for session notifications");	×
87	}	×
88	},	×
89	onTeardown: hwnd => WTSUnRegisterSessionNotification(hwnd)	×
90	)	×
91	.Subscribe(m =>	×
92	{	×
93	if (_isPaused \|\| m.Msg != WindowsMessages.WM_WTSSESSION_CHANGE)	×
94	{	×
95	return;	×
96	}	×
97		×
98	var eventType = (WtsSessionChangeEvents)(int)m.WParam;	×
99	var sessionId = (int)m.LParam;	×
100		×
101	var args = new SessionChangeEventArgs(eventType, sessionId);	×
102		×
103	switch (eventType)	×
104	{	×
105	case WtsSessionChangeEvents.WTS_SESSION_LOCK:	×
106	case WtsSessionChangeEvents.WTS_SESSION_UNLOCK:	×
107	SessionLockChange?.Invoke(this, args);	×
108	break;	×
109		×
110	case WtsSessionChangeEvents.WTS_SESSION_LOGON:	×
111	case WtsSessionChangeEvents.WTS_SESSION_LOGOFF:	×
112	SessionLogonChange?.Invoke(this, args);	×
113	break;	×
114	}	×
115	});	×
116	}	×
117	}	×
118
119	/// <summary>
120	/// Pauses listening for session change events
121	/// </summary>
122	public void Pause()
123	{
124	_isPaused = true;	×
125	}	×
126
127	/// <summary>
128	/// Resumes listening for session change events after being paused
129	/// </summary>
130	public void Resume()
131	{
132	_isPaused = false;	×
133	}	×
134
135	/// <summary>
136	/// Stops listening for session change events
137	/// </summary>
138	public void Stop()
139	{
140	lock (_lock)	×
141	{
142	if (_subscription != null)	×
143	{
144	_subscription.Dispose();	×
145	_subscription = null;	×
146	}
147	_isPaused = false;	×
148	}	×
149	}	×
150
151	/// <summary>
152	/// Disposes the listener and stops listening for events
153	/// </summary>
154	public void Dispose()
155	{
156	if (_isDisposed)	×
157	{
158	return;	×
159	}
160
161	_isDisposed = true;	×
162	Stop();	×
163	GC.SuppressFinalize(this);	×
164	}	×
165	}
166	#endif

dapplo / Dapplo.Windows / 22325004088

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous