ChickenFarm/UI/CF.APP/chicken_farm/windows/runner/reader/reader_method_call.cpp

#include "reader_method_call.h"
#include "reader_service.h"

#include <flutter/flutter_engine.h>
#include <flutter/method_channel.h>
#include <flutter/standard_method_codec.h>
#include <flutter/event_channel.h>
#include <flutter/event_stream_handler_functions.h>

#include <memory>
#include <string>
#include <vector>
#include <functional>
#include <map>

static std::unique_ptr<flutter::EventChannel<flutter::EncodableValue>> g_event_channel = nullptr;
static std::unique_ptr<flutter::StreamHandler<flutter::EncodableValue>> g_stream_handler = nullptr;

void ReaderMethodCall::RegisterWindowsAPI(flutter::FlutterEngine *engine)
{
  auto channel = std::make_unique<flutter::MethodChannel<flutter::EncodableValue>>(
      engine->messenger(), "com.vber.chicken_farm/win_reader",
      &flutter::StandardMethodCodec::GetInstance());
  channel->SetMethodCallHandler([](const auto &call, auto result)
                                { HandleMethodCall(call, std::move(result)); });

  g_event_channel = std::make_unique<flutter::EventChannel<flutter::EncodableValue>>(
      engine->messenger(), "com.vber.chicken_farm/win_reader_events",
      &flutter::StandardMethodCodec::GetInstance());

  g_stream_handler =
      std::make_unique<flutter::StreamHandlerFunctions<flutter::EncodableValue>>(
          [](const flutter::EncodableValue *arguments,
             std::unique_ptr<flutter::EventSink<flutter::EncodableValue>> &&events)
              -> std::unique_ptr<flutter::StreamHandlerError<flutter::EncodableValue>>
          {
            auto events_ptr = std::shared_ptr<flutter::EventSink<flutter::EncodableValue>>(std::move(events));
            ReaderService::GetInstance()->SetDataCallback([events_ptr](const std::string &data)
                                                          { events_ptr->Success(flutter::EncodableValue(data)); });
            return nullptr;
          },
          [](const flutter::EncodableValue *arguments)
              -> std::unique_ptr<flutter::StreamHandlerError<flutter::EncodableValue>>
          {
            ReaderService::GetInstance()->SetDataCallback(nullptr);
            return nullptr;
          });

  g_event_channel->SetStreamHandler(std::move(g_stream_handler));
}

void ReaderMethodCall::HandleMethodCall(
    const flutter::MethodCall<flutter::EncodableValue> &method_call,
    std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result)
{
  // Use a map to handle different method calls
  static std::map<std::string, std::function<void(const flutter::MethodCall<flutter::EncodableValue> &method_call, std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result)>> handlers = {
      {"scanUsb", [](const flutter::MethodCall<flutter::EncodableValue> &method_call, std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result)
       {
         // Call the scan USB method of the reader service
         std::vector<std::string> usb = ReaderService::GetInstance()->ScanUsb();

         // Create a list to store USB device names
         flutter::EncodableList device_list;
         for (const auto &device : usb)
         {
           device_list.push_back(flutter::EncodableValue(device));
         }

         // Return the list of USB devices to Flutter (empty if no devices found)
         result->Success(flutter::EncodableValue(device_list));
       }},
      {"connect", [](const flutter::MethodCall<flutter::EncodableValue> &method_call, std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result)
       {
         const auto *args = std::get_if<flutter::EncodableMap>(method_call.arguments());
         if (args)
         {
           auto deviceIndexIt = args->find(flutter::EncodableValue("deviceIndex"));
           if (deviceIndexIt != args->end())
           {
             int deviceIndex = std::get<int>(deviceIndexIt->second);
             bool success = ReaderService::GetInstance()->Connect(deviceIndex);
             result->Success(flutter::EncodableValue(success));
             return;
           }
         }
         result->Success(flutter::EncodableValue(false));
       }},
      {"disconnect", [](const flutter::MethodCall<flutter::EncodableValue> &method_call, std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result)
       {
         ReaderService::GetInstance()->Disconnect();
         result->Success();
       }},
      {"startRead", [](const flutter::MethodCall<flutter::EncodableValue> &method_call, std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result)
       {
         bool success = ReaderService::GetInstance()->StartRead();
         result->Success(flutter::EncodableValue(success));
       }},
      {"stopRead", [](const flutter::MethodCall<flutter::EncodableValue> &method_call, std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result)
       {
         ReaderService::GetInstance()->StopRead();
         result->Success();
       }},
      {"getDeviceInfo", [](const flutter::MethodCall<flutter::EncodableValue> &method_call, std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result)
       {
         std::string deviceInfo = ReaderService::GetInstance()->GetDeviceInfo();
         result->Success(flutter::EncodableValue(deviceInfo));
       }},
      {"getPower", [](const flutter::MethodCall<flutter::EncodableValue> &method_call, std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result)
       {
         unsigned char power = 0;
         bool success = ReaderService::GetInstance()->GetPower(power);
         if (success)
         {
           result->Success(flutter::EncodableValue(static_cast<int>(power)));
         }
         else
         {
           result->Success(flutter::EncodableValue());
         }
       }},
      {"setPower", [](const flutter::MethodCall<flutter::EncodableValue> &method_call, std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result)
       {
         const auto *args = std::get_if<flutter::EncodableMap>(method_call.arguments());
         if (args)
         {
           auto powerIt = args->find(flutter::EncodableValue("power"));
           if (powerIt != args->end())
           {
             int power = std::get<int>(powerIt->second);
             bool success = ReaderService::GetInstance()->SetPower(static_cast<unsigned char>(power));
             result->Success(flutter::EncodableValue(success));
             return;
           }
         }
         result->Success(flutter::EncodableValue(false));
       }}
      // More method handlers can be added here
      // {"methodName", [](auto result) { /* Handle method */ }}
  };

  // Find and execute the corresponding method handler
  auto handler = handlers.find(method_call.method_name());
  if (handler != handlers.end())
  {
    handler->second(method_call, std::move(result));
  }
  else
  {
    result->NotImplemented();
  }
}