typedef calculator_func = Int32 Function(Int32 a, Int32 b);

typedef Calculator = int Function(int a, int b);

final dylib = ffi.DynamicLibrary.open(...);
final Calculator function = dylib
    .lookup<NativeFunction<calculator_func>>(...)
    .asFunction();

print(function(7, 3));

final channelName = ‘sample.example.com/my_method_channel’;

Future<int> nativeSum(int a, int b) async {
  await platfom.invokeMethod<int>(‘nativeSum’,{‘a’: a, ‘b’: b});
}

private val CHANNEL = “sample.example.com/my_method_channel”

MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler(this)

when (call.method) {
  “nativeSum” -> {
    val a = call.argument<Int>(“a”) ?: 0
    val b = call.argument<Int>(“b”) ?: 0
    result.success(a + b)
  }
  else -> result.notImplemented()
}

let myChannel = FlutterMethodChannel(name: “sample.example.com/my_method_channel”, binaryMessenger: controller.binaryMessenger)

myChannel.setMethodCallHandler({
  [weak self] (call: FlutterMethodCall, result: FlutterResult) -> Void in
  
  switch call.method:
    case “nativeSum”:
      let args = call.arguments as? [String, Any]
      let a = args[“a”] as? Int
      let b = args[“b”] as? Int
      result(a + b)
    default:
      result(FlutterMethodNotImplemented)
})

part "my_service.chopper.dart";

@ChopperApi(baseUrl: "/todos")
abstract class MyService extends ChopperService {

    static MyService create([ChopperClient? client]) => 
        _$MyServiceService(client);

  @Get()
  Future<List<Todo>> getTodos();

  @Post()
  Future<void> addTodo({
    @Body Map<String,dynamic> body,
  });
}

final chopper = ChopperClient(
      baseUrl: "https://example.com/api",
      services: [
        MyService .service,
      ],
      interceptor: [
        MyInterceptor(),
      ],
);

class HeaderInterceptor extends RequestInterceptor{
@override
FutureOr<Request> onRequest(Request request)async {
      return request.copyWith(
            headers: {
            …request.headers,
           ‘my_header’: ‘abc’
           },
      );
      }
}

part "my_service.g.dart";

@RestApi()
abstract class MyService {
  factory MyService (Dio dio) = _MyService;

  @GET('/todos')
  Future<List<Todo>> getTodos();

  @Post(‘/todos’)
  Future<void> addTodo({
    @Body required CreateTodoBody body,
  });
}

return handler.reject(MyException(),requestOptions: options);

 Dio dio = Dio();
 dio.options.baseUrl = ‘https://example.com/api’;
 final client = MyService(dio);

 await client.getTodos();