Fix Windows crash: marshal InvokeMethod calls to platform thread via TaskDispatcher

Author: hugocornellier

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 1.1.7
+
+* Fix Windows crash: platform channel messages (cameraClosing, cameraError, imageStreamFrame) are now marshalled to the platform thread via a Win32 message-only window, resolving the non-platform-thread violation after camera dispose (#4)
+
 ## 1.1.6
 
 * Fix Swift compiler warnings: remove unused variables in DeviceEnumerator, PhotoHandler, RecordHandler, and CameraSession

pubspec.yaml

@@ -3,7 +3,7 @@ description: >-
   A Flutter camera plugin for desktop platforms (Linux, macOS, Windows).
   Implements camera_platform_interface for easy integration
   with the standard camera package.
-version: 1.1.6
+version: 1.1.7
 homepage: https://github.com/hugocornellier/camera_desktop
 repository: https://github.com/hugocornellier/camera_desktop
 issue_tracker: https://github.com/hugocornellier/camera_desktop/issues

windows/camera.cpp

@@ -196,10 +196,12 @@ std::string CameraStateStr(CameraState s) {
 
 Camera::Camera(int camera_id, flutter::TextureRegistrar* texture_registrar,
                flutter::MethodChannel<flutter::EncodableValue>* channel,
-               CameraConfig config)
+               CameraConfig config,
+               PlatformTaskPoster platform_task_poster)
     : camera_id_(camera_id),
       texture_registrar_(texture_registrar),
       channel_(channel),
+      platform_task_poster_(std::move(platform_task_poster)),
       config_(std::move(config)) {}
 
 Camera::~Camera() {
@@ -1188,6 +1190,8 @@ void Camera::PostImageStreamFrame(const uint8_t* data, int width, int height) {
 
 void Camera::ImageStreamLoop() {
   CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+  auto* channel = channel_;
+  const int camera_id = camera_id_;
 
   while (image_stream_running_.load()) {
     ImageStreamSlot local;
@@ -1201,18 +1205,21 @@ void Camera::ImageStreamLoop() {
       image_stream_slot_.dirty = false;
     }
 
-    channel_->InvokeMethod(
-        "imageStreamFrame",
-        std::make_unique<flutter::EncodableValue>(flutter::EncodableMap{
-            {flutter::EncodableValue("cameraId"),
-             flutter::EncodableValue(camera_id_)},
-            {flutter::EncodableValue("width"),
-             flutter::EncodableValue(local.width)},
-            {flutter::EncodableValue("height"),
-             flutter::EncodableValue(local.height)},
-            {flutter::EncodableValue("bytes"),
-             flutter::EncodableValue(local.data)},
-        }));
+    platform_task_poster_(
+        [channel, camera_id, local = std::move(local)]() mutable {
+          channel->InvokeMethod(
+              "imageStreamFrame",
+              std::make_unique<flutter::EncodableValue>(flutter::EncodableMap{
+                  {flutter::EncodableValue("cameraId"),
+                   flutter::EncodableValue(camera_id)},
+                  {flutter::EncodableValue("width"),
+                   flutter::EncodableValue(local.width)},
+                  {flutter::EncodableValue("height"),
+                   flutter::EncodableValue(local.height)},
+                  {flutter::EncodableValue("bytes"),
+                   flutter::EncodableValue(local.data)},
+              }));
+        });
   }
 
   CoUninitialize();
@@ -1241,14 +1248,18 @@ void Camera::ResumePreview() {
 // ============================================================================
 
 void Camera::SendError(const std::string& description) {
-  channel_->InvokeMethod(
-      "cameraError",
-      std::make_unique<flutter::EncodableValue>(flutter::EncodableMap{
-          {flutter::EncodableValue("cameraId"),
-           flutter::EncodableValue(camera_id_)},
-          {flutter::EncodableValue("description"),
-           flutter::EncodableValue(description)},
-      }));
+  auto* channel = channel_;
+  int camera_id = camera_id_;
+  platform_task_poster_([channel, camera_id, description]() {
+    channel->InvokeMethod(
+        "cameraError",
+        std::make_unique<flutter::EncodableValue>(flutter::EncodableMap{
+            {flutter::EncodableValue("cameraId"),
+             flutter::EncodableValue(camera_id)},
+            {flutter::EncodableValue("description"),
+             flutter::EncodableValue(description)},
+        }));
+  });
 }
 
 // ============================================================================
@@ -1373,12 +1384,18 @@ void Camera::DisposeInternal() {
     texture_.reset();
   }
 
-  channel_->InvokeMethod(
-      "cameraClosing",
-      std::make_unique<flutter::EncodableValue>(flutter::EncodableMap{
-          {flutter::EncodableValue("cameraId"),
-           flutter::EncodableValue(camera_id_)},
-      }));
+  {
+    auto* channel = channel_;
+    int camera_id = camera_id_;
+    platform_task_poster_([channel, camera_id]() {
+      channel->InvokeMethod(
+          "cameraClosing",
+          std::make_unique<flutter::EncodableValue>(flutter::EncodableMap{
+              {flutter::EncodableValue("cameraId"),
+               flutter::EncodableValue(camera_id)},
+          }));
+    });
+  }
 
   {
     std::lock_guard<std::mutex> lk(state_mutex_);

windows/camera.h

@@ -44,9 +44,12 @@ struct CameraConfig {
 
 class Camera : public std::enable_shared_from_this<Camera> {
  public:
+  using PlatformTaskPoster = std::function<void(std::function<void()>)>;
+
   Camera(int camera_id, flutter::TextureRegistrar* texture_registrar,
          flutter::MethodChannel<flutter::EncodableValue>* channel,
-         CameraConfig config);
+         CameraConfig config,
+         PlatformTaskPoster platform_task_poster);
   ~Camera();
 
   int64_t RegisterTexture();
@@ -109,6 +112,7 @@ class Camera : public std::enable_shared_from_this<Camera> {
 
   flutter::TextureRegistrar*                           texture_registrar_;
   flutter::MethodChannel<flutter::EncodableValue>*     channel_;
+  PlatformTaskPoster                                   platform_task_poster_;
   std::unique_ptr<CameraTexture>                       texture_;
 
   // ── Capture engine + D3D11 ─────────────────────────────────────────────

windows/camera_desktop_plugin.cpp

@@ -18,6 +18,50 @@
 
 CameraDesktopPlugin* CameraDesktopPlugin::instance_ = nullptr;
 
+// ---------------------------------------------------------------------------
+// TaskDispatcher
+// ---------------------------------------------------------------------------
+
+static const UINT kWmTask = WM_APP + 100;
+static const wchar_t kTaskWndClass[] = L"CameraDesktopTaskDispatcher";
+
+TaskDispatcher::TaskDispatcher() {
+  WNDCLASSEX wc = {};
+  wc.cbSize        = sizeof(wc);
+  wc.lpfnWndProc   = &TaskDispatcher::WndProc;
+  wc.hInstance     = GetModuleHandle(nullptr);
+  wc.lpszClassName = kTaskWndClass;
+  RegisterClassEx(&wc);  // Ignore failure; already-registered is fine.
+
+  hwnd_ = CreateWindowEx(0, kTaskWndClass, nullptr, 0,
+                         0, 0, 0, 0, HWND_MESSAGE, nullptr,
+                         GetModuleHandle(nullptr), nullptr);
+}
+
+TaskDispatcher::~TaskDispatcher() {
+  if (hwnd_) {
+    DestroyWindow(hwnd_);
+    hwnd_ = nullptr;
+  }
+}
+
+void TaskDispatcher::Post(std::function<void()> task) {
+  if (!hwnd_) return;
+  PostMessage(hwnd_, kWmTask, 0,
+              reinterpret_cast<LPARAM>(new std::function<void()>(std::move(task))));
+}
+
+LRESULT CALLBACK TaskDispatcher::WndProc(HWND hwnd, UINT msg,
+                                          WPARAM wparam, LPARAM lparam) {
+  if (msg == kWmTask) {
+    auto* task = reinterpret_cast<std::function<void()>*>(lparam);
+    (*task)();
+    delete task;
+    return 0;
+  }
+  return DefWindowProc(hwnd, msg, wparam, lparam);
+}
+
 int64_t camera_desktop_ffi_register_stream_handle(Camera* camera);
 void camera_desktop_ffi_release_stream_handle(int64_t stream_handle);
 void camera_desktop_ffi_release_handles_for_camera(Camera* camera);
@@ -64,7 +108,9 @@ void CameraDesktopPlugin::RegisterWithRegistrar(
 CameraDesktopPlugin::CameraDesktopPlugin(
     flutter::PluginRegistrarWindows* registrar,
     std::unique_ptr<flutter::MethodChannel<flutter::EncodableValue>> channel)
-    : registrar_(registrar), channel_(std::move(channel)) {}
+    : registrar_(registrar),
+      channel_(std::move(channel)),
+      task_dispatcher_(std::make_unique<TaskDispatcher>()) {}
 
 CameraDesktopPlugin::~CameraDesktopPlugin() {
   shutting_down_ = true;
@@ -273,11 +319,16 @@ void CameraDesktopPlugin::HandleCreate(
 
   int camera_id = next_camera_id_++;
   DebugLog("HandleCreate: assigning camera_id=" + std::to_string(camera_id));
+  TaskDispatcher* dispatcher = task_dispatcher_.get();
+  Camera::PlatformTaskPoster poster = [dispatcher](std::function<void()> task) {
+    dispatcher->Post(std::move(task));
+  };
   auto camera = std::make_shared<Camera>(
       camera_id,
       registrar_->texture_registrar(),
       channel_.get(),
-      config);
+      config,
+      std::move(poster));
 
   int64_t texture_id = camera->RegisterTexture();
   if (texture_id < 0) {

windows/camera_desktop_plugin.h

@@ -2,13 +2,30 @@
 
 #include <flutter/method_channel.h>
 #include <flutter/plugin_registrar_windows.h>
+#include <windows.h>
 
+#include <functional>
 #include <map>
 #include <memory>
 #include <mutex>
 
 #include "camera.h"
 
+// Marshals arbitrary work to the Win32 message-loop thread (the Flutter
+// platform thread) via a hidden message-only HWND.  Must be constructed on
+// the platform thread; Post() is thread-safe.
+class TaskDispatcher {
+ public:
+  TaskDispatcher();
+  ~TaskDispatcher();
+  void Post(std::function<void()> task);
+
+ private:
+  static LRESULT CALLBACK WndProc(HWND hwnd, UINT msg,
+                                   WPARAM wparam, LPARAM lparam);
+  HWND hwnd_ = nullptr;
+};
+
 class CameraDesktopPlugin : public flutter::Plugin {
  public:
   static void RegisterWithRegistrar(flutter::PluginRegistrarWindows* registrar);
@@ -75,6 +92,7 @@ class CameraDesktopPlugin : public flutter::Plugin {
 
   flutter::PluginRegistrarWindows* registrar_;
   std::unique_ptr<flutter::MethodChannel<flutter::EncodableValue>> channel_;
+  std::unique_ptr<TaskDispatcher> task_dispatcher_;
   mutable std::mutex cameras_mutex_;
   std::map<int, std::shared_ptr<Camera>> cameras_;
   int next_camera_id_ = 1;