node-native-win-utils 1.4.0 → 2.1.0

package/src/cpp/keyboard.cpp

@@ -2,166 +2,167 @@
 #include <Windows.h>
 #include <thread>
 #include <iostream>
+#include <unordered_set>
+#include <mutex>
+#include <atomic>
 
-// Global variable to store the JavaScript callback function
+// Global variables for JavaScript callback functions
 Napi::ThreadSafeFunction globalJsCallbackKeyDown;
 Napi::ThreadSafeFunction globalJsCallbackKeyUp;
 
-// Global variable to store the previous key state
-bool isKeyPressed = false;
-bool handleKeyUp = false;
-bool handleKeyDown = false;
-bool monitorThreadRunning = false;
-int previousKeyState;
-LRESULT CALLBACK KeyboardHookProc(int nCode, WPARAM wParam, LPARAM lParam)
-{
-  if (nCode >= 0)
-  {
-    if (wParam == WM_KEYDOWN)
-    {
-      KBDLLHOOKSTRUCT *kbdStruct = (KBDLLHOOKSTRUCT *)lParam;
-      int keyCode = kbdStruct->vkCode;
-
-      // Handle the keyCode here or call your JavaScript callback
-      // std::cout << "Key Code: " << keyCode << std::endl;
-
-      if (keyCode != previousKeyState || !isKeyPressed)
-      {
-        isKeyPressed = true;
-        previousKeyState = keyCode;
-        if (handleKeyDown)
-        {
-          int *keyCodeCopy = new int(keyCode); // Create a copy of the keyCode value
-
-          napi_status status = globalJsCallbackKeyDown.BlockingCall(
-              keyCodeCopy,
-              [](Napi::Env env, Napi::Function jsCallback, int *keyCodePtr)
-              {
-                Napi::HandleScope scope(env);
-                int keyCode = *keyCodePtr;
-                jsCallback.Call({Napi::Number::New(env, keyCode)});
-                delete keyCodePtr; // Clean up the dynamically allocated keyCode copy
-              });
-
-          if (status != napi_ok)
-          {
-            // Handle the error
-          }
-        }
-      }
+// Thread-safe tracking of pressed keys
+std::mutex pressedKeysMutex;
+std::unordered_set<int> pressedKeys;
+
+// Thread management
+std::atomic<bool> handleKeyDown(false);
+std::atomic<bool> handleKeyUp(false);
+std::atomic<bool> monitorThreadRunning(false);
+DWORD monitorThreadId = 0;
+
+
+// Environment Cleanup Hook
+void CleanupHook() {
+    handleKeyDown = false;
+    handleKeyUp = false;
+    if(globalJsCallbackKeyDown) {
+        globalJsCallbackKeyDown.Release();
     }
-    else if (wParam == WM_KEYUP)
-    {
-      KBDLLHOOKSTRUCT *kbdStruct = (KBDLLHOOKSTRUCT *)lParam;
-      int keyCode = kbdStruct->vkCode;
-
-      if (keyCode == previousKeyState)
-      {
-        isKeyPressed = false;
-        if (handleKeyUp)
-        {
-          int *keyCodeCopy = new int(keyCode); // Create a copy of the keyCode value
-          napi_status status = globalJsCallbackKeyUp.BlockingCall(
-              keyCodeCopy,
-              [](Napi::Env env, Napi::Function jsCallback, int *keyCodePtr)
-              {
-                Napi::HandleScope scope(env);
-                int keyCode = *keyCodePtr;
-                jsCallback.Call({Napi::Number::New(env, keyCode)});
-                delete keyCodePtr; // Clean up the dynamically allocated keyCode copy
-              });
-
-          if (status != napi_ok)
-          {
-            // Handle the error
-          }
+    if(globalJsCallbackKeyUp) {
+        globalJsCallbackKeyUp.Release();
+    }
+    if (monitorThreadRunning) {
+        PostThreadMessage(monitorThreadId, WM_QUIT, 0, 0);
+        
+    }
+}
+
+
+LRESULT CALLBACK KeyboardHookProc(int nCode, WPARAM wParam, LPARAM lParam) {
+    if (nCode >= 0) {
+        KBDLLHOOKSTRUCT* kbdStruct = reinterpret_cast<KBDLLHOOKSTRUCT*>(lParam);
+        int keyCode = kbdStruct->vkCode;
+
+        if (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) {
+            std::lock_guard<std::mutex> lock(pressedKeysMutex);
+            if (pressedKeys.insert(keyCode).second) {
+                if (handleKeyDown) {
+                    // Allocate copy on heap for thread-safe transfer
+                    int* keyCopy = new int(keyCode);
+                    globalJsCallbackKeyDown.BlockingCall(keyCopy,
+                        [](Napi::Env env, Napi::Function jsCallback, int* keyCode) {
+                            jsCallback.Call({Napi::Number::New(env, *keyCode)});
+                            delete keyCode; // Clean up allocated memory
+                        });
+                }
+            }
+        } 
+        else if (wParam == WM_KEYUP || wParam == WM_SYSKEYUP) {
+            std::lock_guard<std::mutex> lock(pressedKeysMutex);
+            if (pressedKeys.erase(keyCode)) {
+                if (handleKeyUp) {
+                    // Allocate copy on heap for thread-safe transfer
+                    int* keyCopy = new int(keyCode);
+                    globalJsCallbackKeyUp.BlockingCall(keyCopy,
+                        [](Napi::Env env, Napi::Function jsCallback, int* keyCode) {
+                            jsCallback.Call({Napi::Number::New(env, *keyCode)});
+                            delete keyCode; // Clean up allocated memory
+                        });
+                }
+            }
         }
-      }
     }
-  }
+    return CallNextHookEx(NULL, nCode, wParam, lParam);
+}
+
+void MonitorKeyboardEvents() {
+    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
+
+    HHOOK keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProc, NULL, 0);
+    if (!keyboardHook) {
+        CoUninitialize();
+        monitorThreadRunning = false;
+        return;
+    }
+
+    MSG msg;
+    while (GetMessage(&msg, NULL, 0, 0) > 0) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
 
-  return CallNextHookEx(NULL, nCode, wParam, lParam);
+    UnhookWindowsHookEx(keyboardHook);
+    CoUninitialize();
+    monitorThreadRunning = false;
+    monitorThreadId = 0;
 }
 
-// Function to monitor keyboard events
-void MonitorKeyboardEvents()
-{
-  HHOOK keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProc, NULL, 0);
-  if (keyboardHook == NULL)
-  {
-    // Error setting hook
-    return;
-  }
+Napi::Value SetKeyDownCallback(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::Function jsCallback = info[0].As<Napi::Function>();
 
-  // Main loop to process keyboard events
-  MSG message;
-  while (GetMessage(&message, NULL, 0, 0) > 0)
-  {
-    TranslateMessage(&message);
-    DispatchMessage(&message);
-  }
+       // Release existing callback
+    if (globalJsCallbackKeyDown) {
+        globalJsCallbackKeyDown.Release();
+    }
+    globalJsCallbackKeyDown = Napi::ThreadSafeFunction::New(
+        env, jsCallback, "KeyDownCallback", 0, 1);
+    handleKeyDown = true;
+
+    if (!monitorThreadRunning.exchange(true)) {
+        std::thread monitorThread(MonitorKeyboardEvents);
+        monitorThreadId = GetThreadId(monitorThread.native_handle());
+        monitorThread.detach();
+    }
 
-  UnhookWindowsHookEx(keyboardHook);
+    return env.Undefined();
 }
 
-// Function called from JavaScript to set the callback function
-Napi::Value SetKeyDownCallback(const Napi::CallbackInfo &info)
-{
-  Napi::Env env = info.Env();
+Napi::Value SetKeyUpCallback(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::Function jsCallback = info[0].As<Napi::Function>();
+    
 
-  // Get the callback function from the arguments
-  Napi::Function jsCallback = info[0].As<Napi::Function>();
-
-  // Create a ThreadSafeFunction with the JavaScript callback
-  globalJsCallbackKeyDown = Napi::ThreadSafeFunction::New(
-      env,
-      jsCallback,
-      "KeyDownCallback",
-      0,
-      1,
-      [](Napi::Env)
-      {
-        // Finalizer callback (optional)
-      });
-  handleKeyDown = true;
-  if (!monitorThreadRunning)
-  {
-    std::thread monitorThread(MonitorKeyboardEvents);
-    monitorThread.detach();
+       // Release existing callback
+    if (globalJsCallbackKeyUp) {
+        globalJsCallbackKeyUp.Release();
+    }
 
-    monitorThreadRunning = true;
-  }
+    globalJsCallbackKeyUp = Napi::ThreadSafeFunction::New(
+        env, jsCallback, "KeyUpCallback", 0, 1);
+    handleKeyUp = true;
+
+    if (!monitorThreadRunning.exchange(true)) {
+        std::thread monitorThread(MonitorKeyboardEvents);
+        monitorThreadId = GetThreadId(monitorThread.native_handle());
+        monitorThread.detach();
+    }
 
-  return env.Undefined();
+    return env.Undefined();
 }
 
-// Function called from JavaScript to set the callback function
-Napi::Value SetKeyUpCallback(const Napi::CallbackInfo &info)
-{
-  Napi::Env env = info.Env();
+Napi::Value UnsetKeyDownCallback(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    handleKeyDown = false;
+    globalJsCallbackKeyDown.Release();
 
-  // Get the callback function from the arguments
-  Napi::Function jsCallback = info[0].As<Napi::Function>();
-
-  // Create a ThreadSafeFunction with the JavaScript callback
-  globalJsCallbackKeyUp = Napi::ThreadSafeFunction::New(
-      env,
-      jsCallback,
-      "KeyUpCallback",
-      0,
-      1,
-      [](Napi::Env)
-      {
-        // Finalizer callback (optional)
-      });
-  handleKeyUp = true;
-  if (!monitorThreadRunning)
-  {
-    std::thread monitorThread(MonitorKeyboardEvents);
-    monitorThread.detach();
-    monitorThreadRunning = true;
-  }
-  return env.Undefined();
+    if (!handleKeyUp && monitorThreadRunning) {
+        PostThreadMessage(monitorThreadId, WM_QUIT, 0, 0);
+    }
+
+    return env.Undefined();
+}
+
+Napi::Value UnsetKeyUpCallback(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    handleKeyUp = false;
+    globalJsCallbackKeyUp.Release();
+
+    if (!handleKeyDown && monitorThreadRunning) {
+        PostThreadMessage(monitorThreadId, WM_QUIT, 0, 0);
+    }
+
+    return env.Undefined();
 }
 
 Napi::Value TypeString(const Napi::CallbackInfo &info) {

package/src/cpp/main.cpp

@@ -1,6 +1,6 @@
 #include <napi.h>
 #include <helpers.cpp>
-#include <captureWindow.cpp>
+#include <screenshot.cpp>
 #include <getWindowData.cpp>
 #include <keyboard.cpp>
 #include <mouse.cpp>
@@ -11,8 +11,11 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
 {
     exports.Set("getWindowData", Napi::Function::New(env, GetWindowData));
     exports.Set("captureWindowN", Napi::Function::New(env, CaptureWindow));
-    exports.Set("keyDownHandler", Napi::Function::New(env, SetKeyDownCallback));
-    exports.Set("keyUpHandler", Napi::Function::New(env, SetKeyUpCallback));
+    exports.Set("captureScreenAsync", Napi::Function::New(env, CaptureScreenAsync));
+    exports.Set("setKeyDownCallback", Napi::Function::New(env, SetKeyDownCallback));
+    exports.Set("setKeyUpCallback", Napi::Function::New(env, SetKeyUpCallback));
+    exports.Set("unsetKeyUpCallback", Napi::Function::New(env, UnsetKeyUpCallback));
+    exports.Set("unsetKeyDownCallback", Napi::Function::New(env, UnsetKeyDownCallback));
     exports.Set("mouseMove", Napi::Function::New(env, MoveMouse));
     exports.Set("mouseClick", Napi::Function::New(env, ClickMouse));
     exports.Set("mouseDrag", Napi::Function::New(env, DragMouse));
@@ -26,6 +29,9 @@ Napi::Object Init(Napi::Env env, Napi::Object exports)
     exports.Set("drawRectangle", Napi::Function::New(env, DrawRectangle));
     exports.Set("getRegion", Napi::Function::New(env, GetRegion));
     exports.Set("textRecognition", Napi::Function::New(env, TextRecognition));
+    static GdiPlusInitializer gdiplusInitializer;
+     // Register cleanup hook
+    env.AddCleanupHook(CleanupHook);
     return exports;
 }
 

package/src/cpp/{capturewindow.cpp → screenshot.cpp}

@@ -15,9 +15,34 @@
 #include <dwmapi.h>
 #include <opencv2/core.hpp>
 #include <opencv2/imgcodecs.hpp>
+#include <vector>
+#include <stdexcept>
+#include <gdiplus.h>
+#include <cstdlib>
+
+#pragma comment (lib, "Gdiplus.lib")
+
+using namespace Gdiplus;
+using namespace Napi;
+// Global GDI+ initialization token
+ULONG_PTR gdiplusToken = 0;
+
+// RAII wrapper for GDI+ initialization
+class GdiPlusInitializer {
+public:
+    GdiPlusInitializer() {
+        GdiplusStartupInput startupInput;
+        GdiplusStartup(&gdiplusToken, &startupInput, NULL);
+    }
+
+    ~GdiPlusInitializer() {
+        GdiplusShutdown(gdiplusToken);
+    }
+};
+
+
+
 
-#pragma comment(lib, "Dwmapi.lib")
-#pragma comment(lib, "windowsapp.lib")
 
 Napi::Value CaptureWindow(const Napi::CallbackInfo &info)
 {
@@ -171,3 +196,150 @@ Napi::Value CaptureWindow(const Napi::CallbackInfo &info)
 
     return resultBuffer;
 }
+
+
+
+class ScreenCaptureWorker : public AsyncWorker {
+  public:
+      ScreenCaptureWorker(Napi::Env env, Promise::Deferred deferred)
+          : AsyncWorker(env), deferred(deferred), buffer(nullptr), bufferSize(0) {}
+  
+      ~ScreenCaptureWorker() {
+          if (buffer) delete[] buffer;
+      }
+  
+      void Execute() override {
+        HDC hdcScreen = NULL;
+        HDC hdcMem = NULL;
+        HBITMAP hBitmap = NULL;
+        IStream* stream = NULL;
+
+        try {
+            // Step 1: Capture screen using GDI
+            hdcScreen = GetDC(NULL);
+            if (!hdcScreen) throw "Failed to get screen DC";
+
+            int width = GetSystemMetrics(SM_CXSCREEN);
+            int height = GetSystemMetrics(SM_CYSCREEN);
+
+            hdcMem = CreateCompatibleDC(hdcScreen);
+            if (!hdcMem) throw "Failed to create compatible DC";
+
+            hBitmap = CreateCompatibleBitmap(hdcScreen, width, height);
+            if (!hBitmap) throw "Failed to create bitmap";
+
+            SelectObject(hdcMem, hBitmap);
+            if (!BitBlt(hdcMem, 0, 0, width, height, hdcScreen, 0, 0, SRCCOPY)) {
+                throw "Failed to copy screen content";
+            }
+
+            // Step 2: Convert bitmap to PNG using GDI+
+            Bitmap bitmap(hBitmap, NULL);
+            if (bitmap.GetLastStatus() != Ok) {
+                throw "Failed to create GDI+ bitmap";
+            }
+
+            // Create in-memory stream to store PNG
+            if (CreateStreamOnHGlobal(NULL, TRUE, &stream) != S_OK) {
+                throw "Failed to create stream";
+            }
+
+            CLSID pngClsid;
+            if (GetEncoderClsid(L"image/png", &pngClsid) == -1) {
+                throw "Failed to get PNG encoder";
+            }
+
+            if (bitmap.Save(stream, &pngClsid, NULL) != Ok) {
+                throw "Failed to save PNG to stream";
+            }
+
+            // Get PNG data from stream
+            STATSTG stat;
+            stream->Stat(&stat, STATFLAG_NONAME);
+            bufferSize = static_cast<DWORD>(stat.cbSize.QuadPart);
+            
+            HGLOBAL hGlobal = NULL;
+            GetHGlobalFromStream(stream, &hGlobal);
+            buffer = static_cast<BYTE*>(GlobalLock(hGlobal));
+            if (!buffer) throw "Failed to lock stream memory";
+
+            // Copy to local buffer as stream will be released
+            BYTE* tempBuffer = new BYTE[bufferSize];
+            memcpy(tempBuffer, buffer, bufferSize);
+            buffer = tempBuffer;
+
+            // Cleanup
+            GlobalUnlock(hGlobal);
+            stream->Release();
+            DeleteObject(hBitmap);
+            DeleteDC(hdcMem);
+            ReleaseDC(NULL, hdcScreen);
+        }
+        catch (const char* error) {
+            SetError(error);
+        }
+        catch (...) {
+            SetError("Unknown error occurred during screen capture");
+        }
+
+        // Cleanup in case of exceptions
+        if (stream) stream->Release();
+        if (hBitmap) DeleteObject(hBitmap);
+        if (hdcMem) DeleteDC(hdcMem);
+        if (hdcScreen) ReleaseDC(NULL, hdcScreen);
+      }
+  
+      void OnOK() override {
+          Buffer<BYTE> result = Buffer<BYTE>::Copy(Env(), buffer, bufferSize);
+          deferred.Resolve(result);
+      }
+  
+      void OnError(const Napi::Error& e) override {
+          deferred.Reject(e.Value());
+      }
+  
+  private:
+      Promise::Deferred deferred;
+      BYTE* buffer;
+      DWORD bufferSize;
+  
+      int GetEncoderClsid(const WCHAR* format, CLSID* pClsid) {
+          UINT numEncoders = 0;
+          UINT size = 0;
+  
+          if (GetImageEncodersSize(&numEncoders, &size) != Ok || size == 0)
+              return -1;
+  
+          ImageCodecInfo* pImageCodecInfo = (ImageCodecInfo*)malloc(size);
+          if (!pImageCodecInfo) return -1;
+  
+          if (GetImageEncoders(numEncoders, size, pImageCodecInfo) != Ok) {
+              free(pImageCodecInfo);
+              return -1;
+          }
+  
+          for (UINT i = 0; i < numEncoders; i++) {
+              if (wcscmp(pImageCodecInfo[i].MimeType, format) == 0) {
+                  *pClsid = pImageCodecInfo[i].Clsid;
+                  free(pImageCodecInfo);
+                  return i;
+              }
+          }
+  
+          free(pImageCodecInfo);
+          return -1;
+      }
+  };
+  
+  Value CaptureScreenAsync(const CallbackInfo& info) {
+    Env env = info.Env();
+    Promise::Deferred deferred = Promise::Deferred::New(env);
+    ScreenCaptureWorker* worker = new ScreenCaptureWorker(env, deferred);
+    worker->Queue();
+    return deferred.Promise();
+}
+
+
+
+
+

package/src/dirnameLocal.mts

@@ -0,0 +1,3 @@
+import * as url from 'url';
+export const __dirnameLocal = url.fileURLToPath(new URL('.', import.meta.url));
+