Best practice for dart to call a rust function and get a return value?

[VictorieeMan]

What is the best practice for creating functions with return values in rust, that dart can call like if it was a normal function? I'm talking about backend code here that asks rust to preform tasks, not the UI triggering rust messages.

[temeddix]

The current way to do that is written here:

• https://rinf.cunarist.com/frequently-asked-questions/#how-can-i-await-a-response

However, maybe that could be more easy in the future.

• Providing a utility class from Dart Rinf package (The easy way)
• Supporting 'Protobuf service' syntax (Harder way)

We might be able to talk about those implementation details here, if anyone is interested :)

[VictorieeMan]

Thank you very much! I somehow glossed over this part of the FAQ.

The dream would be to be able to call rust functions directly in dart and get return values as if they were dart native functions. I think rinf is best in class at coming as close as possible to this ideal, of the solutions I have seen. And it would indeed be interesting to explore ideas moving us even closer to that ideal! :)

I'll study up a bit more on how the inner workings of rinf operates and see if that can help me engage more in this problem-solving.

[temeddix]

Thank you for your participation :) Indeed, it would be nice to support the thing that you've mentioned. If you suggest any design ideas or PR, I would be happy to make a review and talk about it together. Please let us know if you have anything new :)

P.S. I don't have any preference for the design choice, so your decision might be able pave the way straight

[rohitsangwan01]

I tried something similar, with Flutter's method channels kind of approach

Message proto

// [RINF:DART-SIGNAL]
message RustMethodChannel {
  int32 id = 1;
  string method = 2;
  string data = 3;
}

// [RINF:RUST-SIGNAL]
message RustMethodReciever {
  int32 id = 1;
  string response = 2;
}

Rust File for Communication, import serde for Json parsing in cargo : serde_json = "1.0.117"

use crate::messages::rust_channel::{RustMethodChannel, RustMethodReciever};
use serde_json::{json, Value};

pub fn setup_rust_method_channel_handler() {
    tokio::spawn(async move {
        let mut receiver = RustMethodChannel::get_dart_signal_receiver();
        while let Some(dart_signal) = receiver.recv().await {
            let message: RustMethodChannel = dart_signal.message;
            let mut data: Option<Value> = None;
            if message.data != "" {
                data = serde_json::from_str(&message.data).expect("Failed to parse JSON");
            }
            handle(message.id, message.method, data);
        }
    });
}

fn handle(id: i32, method: String, data: Option<Value>) {
    let mut data: Value = json!({
        "error":"not_implemented"
    });

    if method == "test" {
        data = json!({
            "result": "success",
        });
    }

    // send result back to flutter
    RustMethodReciever { id,  response: data.to_string() }.send_signal_to_dart();
}

Setup Dart side

class RustChannel {
  static int _methodId = 0;

 static final Stream<RustMethodReciever> _rustMethodStream =
      RustMethodReciever.rustSignalStream.map((event) => event.message);

  static Future<Map<String, dynamic>?> call(
    String method, {
    Map<String, dynamic>? data,
    Duration? timeout,
  }) async {
    _methodId++;

    RustMethodChannel(
      id: _methodId,
      method: method,
      data: data != null ? json.encode(data) : "",
    ).sendSignalToRust();

    RustMethodReciever reciever = await _rustMethodStream
        .firstWhere((e) => e.id == _methodId)
        .timeout(timeout ?? const Duration(seconds: 2));

    var response = json.decode(reciever.response);
    String? error = response["error"];

    if (error != null) throw error;
    return response;
  }

Now we can call methods, and get back result

var response = RustChannel.call("test")

[ALEZ-DEV]

Little suggestion here :
Dart 3.4 is adding dart macro (Experimental), I think there will be a way with that to give the impression to directly call the rust function from dart and vice versa.
This is a good idea to experiment, because the features is still in experiment.