Visual Studio Code – Flutter platform channels pass "multi-data" to windows function

I am testing the Platform-Channels with the windows visual studio 2022.

I can pass the single value from the flutter UI while I get the battery value, but I want to send multi-data from flutter to the windows code.
Here is mine test code which I follow the flutter tutorial:

class _MyHomePageState extends State<MyHomePage> {
  static const MethodChannel platform =
      MethodChannel('samples.flutter.dev/battery');

  String _batteryLevel = 'Unknown battery level.';
  int value = 100;
  Future<void> _getBatteryLevel(int fluval) async {
    String batteryLevel;
    try {
      final int result = await platform.invokeMethod('getBatteryLevel', fluval);
      batteryLevel = 'Battery level at $result % .';
    } on PlatformException catch (e) {
      batteryLevel = "Failed to get battery level: '${e.message}'.";
    }
    setState(() {
      _batteryLevel = batteryLevel;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Material(
      child: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.spaceEvenly,
          children: [
            ElevatedButton(
              onPressed: () {
                _getBatteryLevel(100);
              },
              child: const Text('Get Battery Level'),
            ),
            Text(_batteryLevel),
          ],
        ),
      ),
    );
  }
}

and the windows side:

void initMethodChannel(flutter::FlutterEngine* flutter_instance) {
    const static std::string channel_name("samples.flutter.dev/battery");
    auto channel =
        std::make_unique<flutter::MethodChannel<>>(
            flutter_instance->messenger(), channel_name,
            &flutter::StandardMethodCodec::GetInstance());
    channel->SetMethodCallHandler(
        [](const flutter::MethodCall<>& call,
            std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {

                // cheack method name called from dart
                if (call.method_name().compare("getBatteryLevel") == 0) {
                    int battery_level = GetBatteryLevel();
                    const auto* flu_value = std::get_if<int>(call.arguments());
                    std::cout << typeid(flu_value).name() << std::endl;

                    if (!flu_value) {
                        result->Error("Missing required type parameter","Expected int");
                    }
                    std::cout << "From Flutter: " << *flu_value << std::endl;

                    if (battery_level != -1) {
                        result->Success(battery_level);
                    }
                    else {
                        result->Error("UNAVAILABLE", "Battery level not available.");
                    }
                }
                else {
                    result->NotImplemented();
                }
        });
}

if I want to send multi-data like this:

Future<void> _getBatteryLevel(int fluval, int data2,...,...) ...

How should I do or parse these two values fluval and data2 when call once invokeMethod?

Any examples that I can reference? or tips for the Windows UI design?

I try to search but the most answer is for the Android or IOS app, and the android answer is using call.argument("value") which you can choose specific data value to use but the windows only has call.arguments(); function call, I don’t know how to get the specific data I want.

============================================================
[Update] From the @Richard tips and example,
I made a test and it works, thanks @Richard!

Here is the Flutter UI example code: (inside the Stateful Widget State class), fluval= 100, fluval2 = 87

  String _getBackV1 = 'Unknown Value 1.';
  String _getBackV2 = 'Unknown Value 2.';
  int value = 100;
  Future<void> _testMapPassValue(int fluval, int fluval2) async {
    String backValue1, backValue2;
    try {
      final Map<String, dynamic>? getReply = await platform
          .invokeMapMethod<String, dynamic>('testPass',
              <String, dynamic>{"fluval": fluval, "fluval2": fluval2});
      backValue1 = "Get Back Value 1 from windows: ${getReply!["fluval"]}";
      backValue2 = "Get Back Value 2 from windows: ${getReply!["fluval2"]}";
    } on PlatformException catch (e) {
      backValue1 = "Failed to get Value 1: '${e.message}'.";
      backValue2 = "Failed to get Value 2: '${e.message}'.";
    }
    setState(() {
      _getBackV1 = backValue1;
      _getBackV2 = backValue2;
    });
  }

At the Windows side example code:

using flutter::EncodableList;
using flutter::EncodableMap;
using flutter::EncodableValue;
constexpr char testMapPassValue[] = "testPass";

constexpr char passKey1[] = "fluval";
constexpr char passKey2[] = "fluval2";

The method call handler:

if (call.method_name().compare(testMapPassValue) == 0) {
  const auto* getArguments_flu = std::get_if<flutter::EncodableMap>(call.arguments());
  assert(getArguments_flu);
  return Flu_2_Win_MethodHandler(*getArguments_flu, std::move(result));
}

void Flu_2_Win_MethodHandler(
    const EncodableMap& args, std::unique_ptr<flutter::MethodResult<>> result) {
    int wins2fluValue1;
    int wins2fluValue2;
    EncodableMap win2fluMap;

    const auto* flu2winsValue1 =
        std::get_if<int>(ValueOrNull(args, passKey1));
    if (!flu2winsValue1) {
        return result->Error("argument_error",
            std::string(passKey1) + " argument missing");
    }
    wins2fluValue1 = *flu2winsValue1;
    std::cout << "From Flutter value1: " << *flu2winsValue1 << std::endl;
    wins2fluValue1 = wins2fluValue1 + 10;
    std::cout << "After calculate value1: " << wins2fluValue1 << std::endl;

    const auto* flu2winsValue2 =
        std::get_if<int>(ValueOrNull(args, passKey2));
    if (!flu2winsValue2) {
        return result->Error("argument_error",
            std::string(passKey2) + " argument missing");
    }
    wins2fluValue2 = *flu2winsValue2;
    std::cout << "From Flutter value1: " << *flu2winsValue2 << std::endl;
    wins2fluValue2 = wins2fluValue2 + 20;
    std::cout << "After calculate value2: " << wins2fluValue2 << std::endl;

    win2fluMap.insert(std::pair<std::string, int>("fluval", wins2fluValue1));
    win2fluMap.insert(std::pair<std::string, int>("fluval2", wins2fluValue2));
    
    return result->Success(std::move(EncodableValue(win2fluMap)));
}

and the final result:

Thank you!