How to. listen power setting notification using this package

[alihassan143]

power_notification_handle_ = RegisterPowerSettingNotification(GetHandle(), &GUID_CONSOLE_DISPLAY_STATE, DEVICE_NOTIFY_WINDOW_HANDLE);
WTSRegisterSessionNotification(GetHandle(),NOTIFY_FOR_THIS_SESSION);

these are two notifications I want to listen to so I can set the user states
currently, I can listen to them using the Flutter method channel but I want to convert them using win32 API how do I do that?

[alihassan143]

@halildurmus any idea?

[halildurmus]

It's possible to listen to these notifications in Dart, but it requires a bit of setup.

To achieve this, you need to create an invisible Win32 window and run a message loop, which is a blocking operation. Therefore, this must be done in a separate isolate to avoid blocking the main isolate.

Here's an example that listens for GUID_CONSOLE_DISPLAY_STATE and session notifications:

import 'dart:async';
import 'dart:ffi';
import 'dart:isolate';

import 'package:ffi/ffi.dart';
import 'package:win32/win32.dart';

void main() async {
  final subscription = onNotification.listen((state) {
    print('Received notification: $state');
  });

  print('Listening notifications for 30 seconds...');

  await Future.delayed(const Duration(seconds: 30), () async {
    await subscription.cancel();
    print('Stopped listening.');
  });
}

Stream<String> get onNotification {
  ReceivePort? receivePort; // To hold the isolate's message port
  SendPort? isolateStopPort; // To hold the isolate's stop port
  StreamSubscription<dynamic>? subscription;

  return Stream<String>.multi((controller) async {
    // Create a ReceivePort to listen for messages from the isolate.
    receivePort = ReceivePort();

    // Start the isolate and pass the message port.
    await Isolate.spawn(runWin32MessageLoop, receivePort!.sendPort);

    subscription = receivePort!.listen((message) {
      if (message is SendPort) {
        isolateStopPort = message;
      } else if (message is String) {
        controller.add(message);
      }
    });

    controller.onCancel = () async {
      // Stop the isolate and close ports when the subscription is cancelled.
      isolateStopPort!.send('stop');
      // Give isolate a chance to process the stop signal properly.
      await Future.delayed(const Duration(milliseconds: 10));
      await subscription!.cancel();
      receivePort!.close();
    };
  });
}

void runWin32MessageLoop(SendPort mainSendPort) {
  // Create a ReceivePort for stopping the isolate.
  final stopPort = ReceivePort();

  // Send the SendPort of stopPort back to the main isolate.
  mainSendPort.send(stopPort.sendPort);

  // Flag to indicate whether the isolate is running.
  bool running = true;

  // Listen for the stop signal.
  stopPort.listen((message) {
    if (message == 'stop') {
      print('Received stop signal, shutting down...');
      stopPort.close();
      running = false;
    }
  });

  // Initialize and create a window to receive notifications.
  final hInstance = GetModuleHandle(nullptr);
  final className = 'NotificationWindowClass'.toNativeUtf16();

  final nativeCallable = NativeCallable<WNDPROC>.isolateLocal(
    (int hwnd, int msg, int wParam, int lParam) {
      switch (msg) {
        case WM_POWERBROADCAST:
          if (wParam == PBT_POWERSETTINGCHANGE) {
            final ppsc = Pointer<POWERBROADCAST_SETTING>.fromAddress(lParam);
            if (ppsc.ref.PowerSetting.toString() ==
                GUID_CONSOLE_DISPLAY_STATE) {
              // https://learn.microsoft.com/en-us/windows/win32/power/power-setting-guids
              final state = switch (ppsc.ref.Data[0]) {
                0 => 'off',
                1 => 'on',
                2 => 'dimmed',
                _ => 'unknown',
              };
              mainSendPort.send('Console display state changed: $state');
            }
          }

        case WM_WTSSESSION_CHANGE:
          switch (wParam) {
            case WTS_CONSOLE_CONNECT:
              mainSendPort.send('Console connected');
            case WTS_CONSOLE_DISCONNECT:
              mainSendPort.send('Console disconnected');
            case WTS_REMOTE_CONNECT:
              mainSendPort.send('Remote session connected');
            case WTS_REMOTE_DISCONNECT:
              mainSendPort.send('Remote session disconnected');
            case WTS_SESSION_LOGON:
              mainSendPort.send('User logged on');
            case WTS_SESSION_LOGOFF:
              mainSendPort.send('User logged off');
            case WTS_SESSION_LOCK:
              mainSendPort.send('Session locked');
            case WTS_SESSION_UNLOCK:
              mainSendPort.send('Session unlocked');
            case WTS_SESSION_REMOTE_CONTROL:
              mainSendPort.send('Remote control session');
          }
      }

      return DefWindowProc(hwnd, msg, wParam, lParam);
    },
    exceptionalReturn: 0,
  );

  final wndClass = calloc<WNDCLASS>()
    ..ref.lpfnWndProc = nativeCallable.nativeFunction
    ..ref.hInstance = hInstance
    ..ref.lpszClassName = className;

  RegisterClass(wndClass);

  // Create a window (invisible).
  final hWnd = CreateWindowEx(
    0,
    className,
    className,
    0,
    0,
    0,
    0,
    0,
    HWND_MESSAGE, // Message-only window.
    0,
    hInstance,
    nullptr,
  );

  final powerSettingGuid = GUIDFromString(GUID_CONSOLE_DISPLAY_STATE);

  // Register for power setting notifications.
  final hDeviceNotify = RegisterPowerSettingNotification(
    hWnd,
    powerSettingGuid,
    REGISTER_NOTIFICATION_FLAGS.DEVICE_NOTIFY_WINDOW_HANDLE,
  );
  // Register for session notifications.
  WTSRegisterSessionNotification(hWnd, NOTIFY_FOR_THIS_SESSION);

  final msg = calloc<MSG>();

  // Message loop to keep the isolate running and handle notifications.
  Future.doWhile(() async {
    // Process Windows messages without blocking.
    while (PeekMessage(msg, 0, 0, 0, PEEK_MESSAGE_REMOVE_TYPE.PM_REMOVE) != 0) {
      TranslateMessage(msg);
      DispatchMessage(msg);
    }

    // Yield to Dart's event loop. This allows the isolate to process messages
    // from the main isolate, such as the stop signal.
    await Future.delayed(Duration.zero);

    return running; // Continue looping while running is true.
  }).whenComplete(() {
    print('Message loop ended. Cleaning up...');
    // Cleanup after the message loop ends.
    nativeCallable.close();
    UnregisterPowerSettingNotification(hDeviceNotify);
    WTSUnRegisterSessionNotification(hWnd);
    free(msg);
    free(powerSettingGuid);
    free(wndClass);
    free(className);
    PostQuitMessage(0);
    print('Cleanup complete.');
  });
}

The sample is not fully polished and may have some bugs, but it should give you a solid starting point. I hope it helps!

Edit: Forgot to mention, WTSRegisterSessionNotification is not available yet in package:win32 but I may add it soon.

[alihassan143]

ok thanks for the answer i will try this code once WTSRegisterSessionNotification because i need both notification message so i can manage state accordingly

[halildurmus]

Just published v5.6.1, which includes the WTSRegisterSessionNotification API and related constants. I also updated the example above accordingly.

[alihassan143]

@halildurmus thanks for the quickest response and modification