2130 lines
82 KiB
Rust
2130 lines
82 KiB
Rust
// This file is automatically generated, so please do not edit it.
|
|
// @generated by `flutter_rust_bridge`@ 2.12.0.
|
|
|
|
#![allow(
|
|
non_camel_case_types,
|
|
unused,
|
|
non_snake_case,
|
|
clippy::needless_return,
|
|
clippy::redundant_closure_call,
|
|
clippy::redundant_closure,
|
|
clippy::useless_conversion,
|
|
clippy::unit_arg,
|
|
clippy::unused_unit,
|
|
clippy::double_parens,
|
|
clippy::let_and_return,
|
|
clippy::too_many_arguments,
|
|
clippy::match_single_binding,
|
|
clippy::clone_on_copy,
|
|
clippy::let_unit_value,
|
|
clippy::deref_addrof,
|
|
clippy::explicit_auto_deref,
|
|
clippy::borrow_deref_ref,
|
|
clippy::uninlined_format_args,
|
|
clippy::needless_borrow
|
|
)]
|
|
|
|
// Section: imports
|
|
|
|
use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
|
|
use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
|
|
use flutter_rust_bridge::{Handler, IntoIntoDart};
|
|
|
|
// Section: boilerplate
|
|
|
|
flutter_rust_bridge::frb_generated_boilerplate!(
|
|
default_stream_sink_codec = SseCodec,
|
|
default_rust_opaque = RustOpaqueMoi,
|
|
default_rust_auto_opaque = RustAutoOpaqueMoi,
|
|
);
|
|
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.12.0";
|
|
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 651188866;
|
|
|
|
// Section: executor
|
|
|
|
flutter_rust_bridge::frb_generated_default_handler!();
|
|
|
|
// Section: wire_funcs
|
|
|
|
fn wire__crate__api__add_bookmark_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "add_bookmark",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_b = <crate::api::BridgeBookmark>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::add_bookmark(api_b).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__audio_stats_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "audio_stats",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::audio_stats().await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__bridge_init_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::SseCodec, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "bridge_init",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
move |context| {
|
|
transform_result_sse::<_, ()>((move || {
|
|
let output_ok = Result::<_, ()>::Ok({
|
|
crate::api::bridge_init();
|
|
})?;
|
|
Ok(output_ok)
|
|
})())
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__connect_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "connect",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_host = <String>::sse_decode(&mut deserializer);
|
|
let api_nickname = <String>::sse_decode(&mut deserializer);
|
|
let api_password = <String>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok =
|
|
crate::api::connect(api_host, api_nickname, api_password).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__delete_bookmark_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "delete_bookmark",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_id = <i64>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::delete_bookmark(api_id).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__disconnect_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "disconnect",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::disconnect().await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__events_stream_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::SseCodec, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "events_stream",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_sink = <StreamSink<
|
|
crate::api::BridgeEvent,
|
|
flutter_rust_bridge::for_generated::SseCodec,
|
|
>>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| {
|
|
transform_result_sse::<_, crate::BridgeError>((move || {
|
|
let output_ok = crate::api::events_stream(api_sink)?;
|
|
Ok(output_ok)
|
|
})())
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__export_diagnostics_impl(
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "export_diagnostics",
|
|
port: None,
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
transform_result_sse::<_, ()>((move || {
|
|
let output_ok = Result::<_, ()>::Ok(crate::api::export_diagnostics())?;
|
|
Ok(output_ok)
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__get_release_tail_ms_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "get_release_tail_ms",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, ()>(
|
|
(move || async move {
|
|
let output_ok =
|
|
Result::<_, ()>::Ok(crate::api::get_release_tail_ms().await)?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__get_transmit_mode_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "get_transmit_mode",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, ()>(
|
|
(move || async move {
|
|
let output_ok = Result::<_, ()>::Ok(crate::api::get_transmit_mode().await)?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__init_storage_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "init_storage",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_dir = <String>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::init_storage(api_dir).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__is_connected_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "is_connected",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, ()>(
|
|
(move || async move {
|
|
let output_ok = Result::<_, ()>::Ok(crate::api::is_connected().await)?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__list_bookmarks_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "list_bookmarks",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::list_bookmarks().await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__log_file_path_str_impl(
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "log_file_path_str",
|
|
port: None,
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
transform_result_sse::<_, ()>((move || {
|
|
let output_ok = Result::<_, ()>::Ok(crate::api::log_file_path_str())?;
|
|
Ok(output_ok)
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__move_to_channel_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "move_to_channel",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_channel_id = <u64>::sse_decode(&mut deserializer);
|
|
let api_password = <String>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok =
|
|
crate::api::move_to_channel(api_channel_id, api_password).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__ptt_descriptor_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "ptt_descriptor",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, ()>(
|
|
(move || async move {
|
|
let output_ok = Result::<_, ()>::Ok(crate::api::ptt_descriptor().await)?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__set_hard_mute_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "set_hard_mute",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_muted = <bool>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::set_hard_mute(api_muted).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__set_input_muted_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "set_input_muted",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_muted = <bool>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::set_input_muted(api_muted).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__set_network_state_impl(
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "set_network_state",
|
|
port: None,
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_state = <crate::api::BridgeNetworkState>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
transform_result_sse::<_, ()>((move || {
|
|
let output_ok = Result::<_, ()>::Ok({
|
|
crate::api::set_network_state(api_state);
|
|
})?;
|
|
Ok(output_ok)
|
|
})())
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__set_output_gain_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "set_output_gain",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_gain = <f32>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::set_output_gain(api_gain).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__set_output_muted_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "set_output_muted",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_muted = <bool>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::set_output_muted(api_muted).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__set_ptt_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "set_ptt",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_active = <bool>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::set_ptt(api_active).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__set_ptt_binding_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "set_ptt_binding",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_input_class = <crate::api::BridgePttInputClass>::sse_decode(&mut deserializer);
|
|
let api_platform_key = <String>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok =
|
|
crate::api::set_ptt_binding(api_input_class, api_platform_key).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__set_release_tail_ms_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "set_release_tail_ms",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_ms = <u32>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::set_release_tail_ms(api_ms).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__set_transmit_mode_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "set_transmit_mode",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_mode = <crate::api::BridgeTransmitMode>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::set_transmit_mode(api_mode).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__snapshot_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "snapshot",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::snapshot().await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__update_bookmark_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "update_bookmark",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_b = <crate::api::BridgeBookmark>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::update_bookmark(api_b).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__voice_join_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "voice_join",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
let api_channel_id = <u64>::sse_decode(&mut deserializer);
|
|
let api_password = <String>::sse_decode(&mut deserializer);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok =
|
|
crate::api::voice_join(api_channel_id, api_password).await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
fn wire__crate__api__voice_leave_impl(
|
|
port_: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len_: i32,
|
|
data_len_: i32,
|
|
) {
|
|
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
|
|
flutter_rust_bridge::for_generated::TaskInfo {
|
|
debug_name: "voice_leave",
|
|
port: Some(port_),
|
|
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
|
|
},
|
|
move || {
|
|
let message = unsafe {
|
|
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
|
|
ptr_,
|
|
rust_vec_len_,
|
|
data_len_,
|
|
)
|
|
};
|
|
let mut deserializer =
|
|
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
|
|
deserializer.end();
|
|
move |context| async move {
|
|
transform_result_sse::<_, crate::BridgeError>(
|
|
(move || async move {
|
|
let output_ok = crate::api::voice_leave().await?;
|
|
Ok(output_ok)
|
|
})()
|
|
.await,
|
|
)
|
|
}
|
|
},
|
|
)
|
|
}
|
|
|
|
// Section: dart2rust
|
|
|
|
impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <String>::sse_decode(deserializer);
|
|
return flutter_rust_bridge::for_generated::anyhow::anyhow!("{}", inner);
|
|
}
|
|
}
|
|
|
|
impl SseDecode
|
|
for StreamSink<crate::api::BridgeEvent, flutter_rust_bridge::for_generated::SseCodec>
|
|
{
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <String>::sse_decode(deserializer);
|
|
return StreamSink::deserialize(inner);
|
|
}
|
|
}
|
|
|
|
impl SseDecode for String {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <Vec<u8>>::sse_decode(deserializer);
|
|
return String::from_utf8(inner).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseDecode for bool {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_u8().unwrap() != 0
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::BridgeAudioStats {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_framesSent = <u32>::sse_decode(deserializer);
|
|
let mut var_framesReceived = <u32>::sse_decode(deserializer);
|
|
let mut var_pttActive = <bool>::sse_decode(deserializer);
|
|
return crate::api::BridgeAudioStats {
|
|
frames_sent: var_framesSent,
|
|
frames_received: var_framesReceived,
|
|
ptt_active: var_pttActive,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::BridgeBookmark {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_id = <i64>::sse_decode(deserializer);
|
|
let mut var_displayName = <String>::sse_decode(deserializer);
|
|
let mut var_host = <String>::sse_decode(deserializer);
|
|
let mut var_nickname = <String>::sse_decode(deserializer);
|
|
let mut var_password = <String>::sse_decode(deserializer);
|
|
return crate::api::BridgeBookmark {
|
|
id: var_id,
|
|
display_name: var_displayName,
|
|
host: var_host,
|
|
nickname: var_nickname,
|
|
password: var_password,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::BridgeChannel {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_id = <u64>::sse_decode(deserializer);
|
|
let mut var_parent = <u64>::sse_decode(deserializer);
|
|
let mut var_name = <String>::sse_decode(deserializer);
|
|
let mut var_order = <i64>::sse_decode(deserializer);
|
|
return crate::api::BridgeChannel {
|
|
id: var_id,
|
|
parent: var_parent,
|
|
name: var_name,
|
|
order: var_order,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::BridgeClient {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_id = <u64>::sse_decode(deserializer);
|
|
let mut var_channel = <u64>::sse_decode(deserializer);
|
|
let mut var_name = <String>::sse_decode(deserializer);
|
|
return crate::api::BridgeClient {
|
|
id: var_id,
|
|
channel: var_channel,
|
|
name: var_name,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::BridgeError {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut tag_ = <i32>::sse_decode(deserializer);
|
|
match tag_ {
|
|
0 => {
|
|
let mut var_field0 = <String>::sse_decode(deserializer);
|
|
return crate::BridgeError::InvalidCommand(var_field0);
|
|
}
|
|
1 => {
|
|
let mut var_host = <String>::sse_decode(deserializer);
|
|
let mut var_reason = <String>::sse_decode(deserializer);
|
|
return crate::BridgeError::DnsFailed {
|
|
host: var_host,
|
|
reason: var_reason,
|
|
};
|
|
}
|
|
2 => {
|
|
let mut var_field0 = <String>::sse_decode(deserializer);
|
|
return crate::BridgeError::Connection(var_field0);
|
|
}
|
|
3 => {
|
|
return crate::BridgeError::NotConnected;
|
|
}
|
|
4 => {
|
|
return crate::BridgeError::AlreadyConnected;
|
|
}
|
|
5 => {
|
|
let mut var_field0 = <String>::sse_decode(deserializer);
|
|
return crate::BridgeError::Unmapped(var_field0);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::BridgeEvent {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut tag_ = <i32>::sse_decode(deserializer);
|
|
match tag_ {
|
|
0 => {
|
|
let mut var_serverName = <String>::sse_decode(deserializer);
|
|
return crate::api::BridgeEvent::Connected {
|
|
server_name: var_serverName,
|
|
};
|
|
}
|
|
1 => {
|
|
let mut var_reason = <String>::sse_decode(deserializer);
|
|
return crate::api::BridgeEvent::Lost { reason: var_reason };
|
|
}
|
|
2 => {
|
|
let mut var_attempt = <u32>::sse_decode(deserializer);
|
|
let mut var_delaySecs = <u32>::sse_decode(deserializer);
|
|
return crate::api::BridgeEvent::Reconnecting {
|
|
attempt: var_attempt,
|
|
delay_secs: var_delaySecs,
|
|
};
|
|
}
|
|
3 => {
|
|
let mut var_reason = <String>::sse_decode(deserializer);
|
|
return crate::api::BridgeEvent::Disconnected { reason: var_reason };
|
|
}
|
|
4 => {
|
|
return crate::api::BridgeEvent::AudioStarted;
|
|
}
|
|
5 => {
|
|
return crate::api::BridgeEvent::AudioStopped;
|
|
}
|
|
6 => {
|
|
let mut var_channels = <u32>::sse_decode(deserializer);
|
|
let mut var_clients = <u32>::sse_decode(deserializer);
|
|
return crate::api::BridgeEvent::SnapshotChanged {
|
|
channels: var_channels,
|
|
clients: var_clients,
|
|
};
|
|
}
|
|
7 => {
|
|
let mut var_level = <String>::sse_decode(deserializer);
|
|
let mut var_backendId = <String>::sse_decode(deserializer);
|
|
let mut var_boundInputClass = <String>::sse_decode(deserializer);
|
|
return crate::api::BridgeEvent::PttCapability {
|
|
level: var_level,
|
|
backend_id: var_backendId,
|
|
bound_input_class: var_boundInputClass,
|
|
};
|
|
}
|
|
8 => {
|
|
let mut var_inChannel = <bool>::sse_decode(deserializer);
|
|
let mut var_transmitMode =
|
|
<crate::api::BridgeTransmitMode>::sse_decode(deserializer);
|
|
let mut var_mute = <bool>::sse_decode(deserializer);
|
|
let mut var_releaseTailMs = <u32>::sse_decode(deserializer);
|
|
return crate::api::BridgeEvent::VoiceState {
|
|
in_channel: var_inChannel,
|
|
transmit_mode: var_transmitMode,
|
|
mute: var_mute,
|
|
release_tail_ms: var_releaseTailMs,
|
|
};
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::BridgeNetworkState {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <i32>::sse_decode(deserializer);
|
|
return match inner {
|
|
0 => crate::api::BridgeNetworkState::Unknown,
|
|
1 => crate::api::BridgeNetworkState::Online,
|
|
2 => crate::api::BridgeNetworkState::Offline,
|
|
_ => unreachable!("Invalid variant for BridgeNetworkState: {}", inner),
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::BridgePttInputClass {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <i32>::sse_decode(deserializer);
|
|
return match inner {
|
|
0 => crate::api::BridgePttInputClass::None,
|
|
1 => crate::api::BridgePttInputClass::Keyboard,
|
|
2 => crate::api::BridgePttInputClass::MouseSideButton,
|
|
_ => unreachable!("Invalid variant for BridgePttInputClass: {}", inner),
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::BridgeSnapshot {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_serverName = <String>::sse_decode(deserializer);
|
|
let mut var_welcomeMessage = <String>::sse_decode(deserializer);
|
|
let mut var_platform = <String>::sse_decode(deserializer);
|
|
let mut var_version = <String>::sse_decode(deserializer);
|
|
let mut var_channels = <Vec<crate::api::BridgeChannel>>::sse_decode(deserializer);
|
|
let mut var_clients = <Vec<crate::api::BridgeClient>>::sse_decode(deserializer);
|
|
return crate::api::BridgeSnapshot {
|
|
server_name: var_serverName,
|
|
welcome_message: var_welcomeMessage,
|
|
platform: var_platform,
|
|
version: var_version,
|
|
channels: var_channels,
|
|
clients: var_clients,
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for crate::api::BridgeTransmitMode {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut inner = <i32>::sse_decode(deserializer);
|
|
return match inner {
|
|
0 => crate::api::BridgeTransmitMode::Ptt,
|
|
1 => crate::api::BridgeTransmitMode::Continuous,
|
|
2 => crate::api::BridgeTransmitMode::VoiceActivity,
|
|
_ => unreachable!("Invalid variant for BridgeTransmitMode: {}", inner),
|
|
};
|
|
}
|
|
}
|
|
|
|
impl SseDecode for f32 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_f32::<NativeEndian>().unwrap()
|
|
}
|
|
}
|
|
|
|
impl SseDecode for i32 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_i32::<NativeEndian>().unwrap()
|
|
}
|
|
}
|
|
|
|
impl SseDecode for i64 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_i64::<NativeEndian>().unwrap()
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<crate::api::BridgeBookmark> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut len_ = <i32>::sse_decode(deserializer);
|
|
let mut ans_ = Vec::with_capacity(len_ as usize);
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<crate::api::BridgeBookmark>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<crate::api::BridgeChannel> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut len_ = <i32>::sse_decode(deserializer);
|
|
let mut ans_ = Vec::with_capacity(len_ as usize);
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<crate::api::BridgeChannel>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<crate::api::BridgeClient> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut len_ = <i32>::sse_decode(deserializer);
|
|
let mut ans_ = Vec::with_capacity(len_ as usize);
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<crate::api::BridgeClient>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for Vec<u8> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut len_ = <i32>::sse_decode(deserializer);
|
|
let mut ans_ = Vec::with_capacity(len_ as usize);
|
|
for idx_ in 0..len_ {
|
|
ans_.push(<u8>::sse_decode(deserializer));
|
|
}
|
|
return ans_;
|
|
}
|
|
}
|
|
|
|
impl SseDecode for (String, String, String) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
let mut var_field0 = <String>::sse_decode(deserializer);
|
|
let mut var_field1 = <String>::sse_decode(deserializer);
|
|
let mut var_field2 = <String>::sse_decode(deserializer);
|
|
return (var_field0, var_field1, var_field2);
|
|
}
|
|
}
|
|
|
|
impl SseDecode for u32 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_u32::<NativeEndian>().unwrap()
|
|
}
|
|
}
|
|
|
|
impl SseDecode for u64 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_u64::<NativeEndian>().unwrap()
|
|
}
|
|
}
|
|
|
|
impl SseDecode for u8 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
|
|
deserializer.cursor.read_u8().unwrap()
|
|
}
|
|
}
|
|
|
|
impl SseDecode for () {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
|
|
}
|
|
|
|
fn pde_ffi_dispatcher_primary_impl(
|
|
func_id: i32,
|
|
port: flutter_rust_bridge::for_generated::MessagePort,
|
|
ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len: i32,
|
|
data_len: i32,
|
|
) {
|
|
// Codec=Pde (Serialization + dispatch), see doc to use other codecs
|
|
match func_id {
|
|
1 => wire__crate__api__add_bookmark_impl(port, ptr, rust_vec_len, data_len),
|
|
2 => wire__crate__api__audio_stats_impl(port, ptr, rust_vec_len, data_len),
|
|
3 => wire__crate__api__bridge_init_impl(port, ptr, rust_vec_len, data_len),
|
|
4 => wire__crate__api__connect_impl(port, ptr, rust_vec_len, data_len),
|
|
5 => wire__crate__api__delete_bookmark_impl(port, ptr, rust_vec_len, data_len),
|
|
6 => wire__crate__api__disconnect_impl(port, ptr, rust_vec_len, data_len),
|
|
7 => wire__crate__api__events_stream_impl(port, ptr, rust_vec_len, data_len),
|
|
9 => wire__crate__api__get_release_tail_ms_impl(port, ptr, rust_vec_len, data_len),
|
|
10 => wire__crate__api__get_transmit_mode_impl(port, ptr, rust_vec_len, data_len),
|
|
11 => wire__crate__api__init_storage_impl(port, ptr, rust_vec_len, data_len),
|
|
12 => wire__crate__api__is_connected_impl(port, ptr, rust_vec_len, data_len),
|
|
13 => wire__crate__api__list_bookmarks_impl(port, ptr, rust_vec_len, data_len),
|
|
15 => wire__crate__api__move_to_channel_impl(port, ptr, rust_vec_len, data_len),
|
|
16 => wire__crate__api__ptt_descriptor_impl(port, ptr, rust_vec_len, data_len),
|
|
17 => wire__crate__api__set_hard_mute_impl(port, ptr, rust_vec_len, data_len),
|
|
18 => wire__crate__api__set_input_muted_impl(port, ptr, rust_vec_len, data_len),
|
|
20 => wire__crate__api__set_output_gain_impl(port, ptr, rust_vec_len, data_len),
|
|
21 => wire__crate__api__set_output_muted_impl(port, ptr, rust_vec_len, data_len),
|
|
22 => wire__crate__api__set_ptt_impl(port, ptr, rust_vec_len, data_len),
|
|
23 => wire__crate__api__set_ptt_binding_impl(port, ptr, rust_vec_len, data_len),
|
|
24 => wire__crate__api__set_release_tail_ms_impl(port, ptr, rust_vec_len, data_len),
|
|
25 => wire__crate__api__set_transmit_mode_impl(port, ptr, rust_vec_len, data_len),
|
|
26 => wire__crate__api__snapshot_impl(port, ptr, rust_vec_len, data_len),
|
|
27 => wire__crate__api__update_bookmark_impl(port, ptr, rust_vec_len, data_len),
|
|
28 => wire__crate__api__voice_join_impl(port, ptr, rust_vec_len, data_len),
|
|
29 => wire__crate__api__voice_leave_impl(port, ptr, rust_vec_len, data_len),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
fn pde_ffi_dispatcher_sync_impl(
|
|
func_id: i32,
|
|
ptr: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
|
|
rust_vec_len: i32,
|
|
data_len: i32,
|
|
) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
|
|
// Codec=Pde (Serialization + dispatch), see doc to use other codecs
|
|
match func_id {
|
|
8 => wire__crate__api__export_diagnostics_impl(ptr, rust_vec_len, data_len),
|
|
14 => wire__crate__api__log_file_path_str_impl(ptr, rust_vec_len, data_len),
|
|
19 => wire__crate__api__set_network_state_impl(ptr, rust_vec_len, data_len),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
|
|
// Section: rust2dart
|
|
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::BridgeAudioStats {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.frames_sent.into_into_dart().into_dart(),
|
|
self.frames_received.into_into_dart().into_dart(),
|
|
self.ptt_active.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::BridgeAudioStats {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeAudioStats>
|
|
for crate::api::BridgeAudioStats
|
|
{
|
|
fn into_into_dart(self) -> crate::api::BridgeAudioStats {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::BridgeBookmark {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.id.into_into_dart().into_dart(),
|
|
self.display_name.into_into_dart().into_dart(),
|
|
self.host.into_into_dart().into_dart(),
|
|
self.nickname.into_into_dart().into_dart(),
|
|
self.password.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::BridgeBookmark {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeBookmark> for crate::api::BridgeBookmark {
|
|
fn into_into_dart(self) -> crate::api::BridgeBookmark {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::BridgeChannel {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.id.into_into_dart().into_dart(),
|
|
self.parent.into_into_dart().into_dart(),
|
|
self.name.into_into_dart().into_dart(),
|
|
self.order.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::BridgeChannel {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeChannel> for crate::api::BridgeChannel {
|
|
fn into_into_dart(self) -> crate::api::BridgeChannel {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::BridgeClient {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.id.into_into_dart().into_dart(),
|
|
self.channel.into_into_dart().into_dart(),
|
|
self.name.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::BridgeClient {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeClient> for crate::api::BridgeClient {
|
|
fn into_into_dart(self) -> crate::api::BridgeClient {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::BridgeError {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
crate::BridgeError::InvalidCommand(field0) => {
|
|
[0.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::BridgeError::DnsFailed { host, reason } => [
|
|
1.into_dart(),
|
|
host.into_into_dart().into_dart(),
|
|
reason.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart(),
|
|
crate::BridgeError::Connection(field0) => {
|
|
[2.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::BridgeError::NotConnected => [3.into_dart()].into_dart(),
|
|
crate::BridgeError::AlreadyConnected => [4.into_dart()].into_dart(),
|
|
crate::BridgeError::Unmapped(field0) => {
|
|
[5.into_dart(), field0.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::BridgeError {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::BridgeError> for crate::BridgeError {
|
|
fn into_into_dart(self) -> crate::BridgeError {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::BridgeEvent {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
crate::api::BridgeEvent::Connected { server_name } => {
|
|
[0.into_dart(), server_name.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::api::BridgeEvent::Lost { reason } => {
|
|
[1.into_dart(), reason.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::api::BridgeEvent::Reconnecting {
|
|
attempt,
|
|
delay_secs,
|
|
} => [
|
|
2.into_dart(),
|
|
attempt.into_into_dart().into_dart(),
|
|
delay_secs.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart(),
|
|
crate::api::BridgeEvent::Disconnected { reason } => {
|
|
[3.into_dart(), reason.into_into_dart().into_dart()].into_dart()
|
|
}
|
|
crate::api::BridgeEvent::AudioStarted => [4.into_dart()].into_dart(),
|
|
crate::api::BridgeEvent::AudioStopped => [5.into_dart()].into_dart(),
|
|
crate::api::BridgeEvent::SnapshotChanged { channels, clients } => [
|
|
6.into_dart(),
|
|
channels.into_into_dart().into_dart(),
|
|
clients.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart(),
|
|
crate::api::BridgeEvent::PttCapability {
|
|
level,
|
|
backend_id,
|
|
bound_input_class,
|
|
} => [
|
|
7.into_dart(),
|
|
level.into_into_dart().into_dart(),
|
|
backend_id.into_into_dart().into_dart(),
|
|
bound_input_class.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart(),
|
|
crate::api::BridgeEvent::VoiceState {
|
|
in_channel,
|
|
transmit_mode,
|
|
mute,
|
|
release_tail_ms,
|
|
} => [
|
|
8.into_dart(),
|
|
in_channel.into_into_dart().into_dart(),
|
|
transmit_mode.into_into_dart().into_dart(),
|
|
mute.into_into_dart().into_dart(),
|
|
release_tail_ms.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart(),
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::BridgeEvent {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeEvent> for crate::api::BridgeEvent {
|
|
fn into_into_dart(self) -> crate::api::BridgeEvent {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::BridgeNetworkState {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
Self::Unknown => 0.into_dart(),
|
|
Self::Online => 1.into_dart(),
|
|
Self::Offline => 2.into_dart(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::BridgeNetworkState
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeNetworkState>
|
|
for crate::api::BridgeNetworkState
|
|
{
|
|
fn into_into_dart(self) -> crate::api::BridgeNetworkState {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::BridgePttInputClass {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
Self::None => 0.into_dart(),
|
|
Self::Keyboard => 1.into_dart(),
|
|
Self::MouseSideButton => 2.into_dart(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::BridgePttInputClass
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgePttInputClass>
|
|
for crate::api::BridgePttInputClass
|
|
{
|
|
fn into_into_dart(self) -> crate::api::BridgePttInputClass {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::BridgeSnapshot {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
[
|
|
self.server_name.into_into_dart().into_dart(),
|
|
self.welcome_message.into_into_dart().into_dart(),
|
|
self.platform.into_into_dart().into_dart(),
|
|
self.version.into_into_dart().into_dart(),
|
|
self.channels.into_into_dart().into_dart(),
|
|
self.clients.into_into_dart().into_dart(),
|
|
]
|
|
.into_dart()
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive for crate::api::BridgeSnapshot {}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeSnapshot> for crate::api::BridgeSnapshot {
|
|
fn into_into_dart(self) -> crate::api::BridgeSnapshot {
|
|
self
|
|
}
|
|
}
|
|
// Codec=Dco (DartCObject based), see doc to use other codecs
|
|
impl flutter_rust_bridge::IntoDart for crate::api::BridgeTransmitMode {
|
|
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
|
|
match self {
|
|
Self::Ptt => 0.into_dart(),
|
|
Self::Continuous => 1.into_dart(),
|
|
Self::VoiceActivity => 2.into_dart(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
|
|
for crate::api::BridgeTransmitMode
|
|
{
|
|
}
|
|
impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeTransmitMode>
|
|
for crate::api::BridgeTransmitMode
|
|
{
|
|
fn into_into_dart(self) -> crate::api::BridgeTransmitMode {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(format!("{:?}", self), serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode
|
|
for StreamSink<crate::api::BridgeEvent, flutter_rust_bridge::for_generated::SseCodec>
|
|
{
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
unimplemented!("")
|
|
}
|
|
}
|
|
|
|
impl SseEncode for String {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<Vec<u8>>::sse_encode(self.into_bytes(), serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for bool {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_u8(self as _).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::BridgeAudioStats {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<u32>::sse_encode(self.frames_sent, serializer);
|
|
<u32>::sse_encode(self.frames_received, serializer);
|
|
<bool>::sse_encode(self.ptt_active, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::BridgeBookmark {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i64>::sse_encode(self.id, serializer);
|
|
<String>::sse_encode(self.display_name, serializer);
|
|
<String>::sse_encode(self.host, serializer);
|
|
<String>::sse_encode(self.nickname, serializer);
|
|
<String>::sse_encode(self.password, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::BridgeChannel {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<u64>::sse_encode(self.id, serializer);
|
|
<u64>::sse_encode(self.parent, serializer);
|
|
<String>::sse_encode(self.name, serializer);
|
|
<i64>::sse_encode(self.order, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::BridgeClient {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<u64>::sse_encode(self.id, serializer);
|
|
<u64>::sse_encode(self.channel, serializer);
|
|
<String>::sse_encode(self.name, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::BridgeError {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
match self {
|
|
crate::BridgeError::InvalidCommand(field0) => {
|
|
<i32>::sse_encode(0, serializer);
|
|
<String>::sse_encode(field0, serializer);
|
|
}
|
|
crate::BridgeError::DnsFailed { host, reason } => {
|
|
<i32>::sse_encode(1, serializer);
|
|
<String>::sse_encode(host, serializer);
|
|
<String>::sse_encode(reason, serializer);
|
|
}
|
|
crate::BridgeError::Connection(field0) => {
|
|
<i32>::sse_encode(2, serializer);
|
|
<String>::sse_encode(field0, serializer);
|
|
}
|
|
crate::BridgeError::NotConnected => {
|
|
<i32>::sse_encode(3, serializer);
|
|
}
|
|
crate::BridgeError::AlreadyConnected => {
|
|
<i32>::sse_encode(4, serializer);
|
|
}
|
|
crate::BridgeError::Unmapped(field0) => {
|
|
<i32>::sse_encode(5, serializer);
|
|
<String>::sse_encode(field0, serializer);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::BridgeEvent {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
match self {
|
|
crate::api::BridgeEvent::Connected { server_name } => {
|
|
<i32>::sse_encode(0, serializer);
|
|
<String>::sse_encode(server_name, serializer);
|
|
}
|
|
crate::api::BridgeEvent::Lost { reason } => {
|
|
<i32>::sse_encode(1, serializer);
|
|
<String>::sse_encode(reason, serializer);
|
|
}
|
|
crate::api::BridgeEvent::Reconnecting {
|
|
attempt,
|
|
delay_secs,
|
|
} => {
|
|
<i32>::sse_encode(2, serializer);
|
|
<u32>::sse_encode(attempt, serializer);
|
|
<u32>::sse_encode(delay_secs, serializer);
|
|
}
|
|
crate::api::BridgeEvent::Disconnected { reason } => {
|
|
<i32>::sse_encode(3, serializer);
|
|
<String>::sse_encode(reason, serializer);
|
|
}
|
|
crate::api::BridgeEvent::AudioStarted => {
|
|
<i32>::sse_encode(4, serializer);
|
|
}
|
|
crate::api::BridgeEvent::AudioStopped => {
|
|
<i32>::sse_encode(5, serializer);
|
|
}
|
|
crate::api::BridgeEvent::SnapshotChanged { channels, clients } => {
|
|
<i32>::sse_encode(6, serializer);
|
|
<u32>::sse_encode(channels, serializer);
|
|
<u32>::sse_encode(clients, serializer);
|
|
}
|
|
crate::api::BridgeEvent::PttCapability {
|
|
level,
|
|
backend_id,
|
|
bound_input_class,
|
|
} => {
|
|
<i32>::sse_encode(7, serializer);
|
|
<String>::sse_encode(level, serializer);
|
|
<String>::sse_encode(backend_id, serializer);
|
|
<String>::sse_encode(bound_input_class, serializer);
|
|
}
|
|
crate::api::BridgeEvent::VoiceState {
|
|
in_channel,
|
|
transmit_mode,
|
|
mute,
|
|
release_tail_ms,
|
|
} => {
|
|
<i32>::sse_encode(8, serializer);
|
|
<bool>::sse_encode(in_channel, serializer);
|
|
<crate::api::BridgeTransmitMode>::sse_encode(transmit_mode, serializer);
|
|
<bool>::sse_encode(mute, serializer);
|
|
<u32>::sse_encode(release_tail_ms, serializer);
|
|
}
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::BridgeNetworkState {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(
|
|
match self {
|
|
crate::api::BridgeNetworkState::Unknown => 0,
|
|
crate::api::BridgeNetworkState::Online => 1,
|
|
crate::api::BridgeNetworkState::Offline => 2,
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
},
|
|
serializer,
|
|
);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::BridgePttInputClass {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(
|
|
match self {
|
|
crate::api::BridgePttInputClass::None => 0,
|
|
crate::api::BridgePttInputClass::Keyboard => 1,
|
|
crate::api::BridgePttInputClass::MouseSideButton => 2,
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
},
|
|
serializer,
|
|
);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::BridgeSnapshot {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.server_name, serializer);
|
|
<String>::sse_encode(self.welcome_message, serializer);
|
|
<String>::sse_encode(self.platform, serializer);
|
|
<String>::sse_encode(self.version, serializer);
|
|
<Vec<crate::api::BridgeChannel>>::sse_encode(self.channels, serializer);
|
|
<Vec<crate::api::BridgeClient>>::sse_encode(self.clients, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for crate::api::BridgeTransmitMode {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(
|
|
match self {
|
|
crate::api::BridgeTransmitMode::Ptt => 0,
|
|
crate::api::BridgeTransmitMode::Continuous => 1,
|
|
crate::api::BridgeTransmitMode::VoiceActivity => 2,
|
|
_ => {
|
|
unimplemented!("");
|
|
}
|
|
},
|
|
serializer,
|
|
);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for f32 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_f32::<NativeEndian>(self).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for i32 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_i32::<NativeEndian>(self).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for i64 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_i64::<NativeEndian>(self).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Vec<crate::api::BridgeBookmark> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(self.len() as _, serializer);
|
|
for item in self {
|
|
<crate::api::BridgeBookmark>::sse_encode(item, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Vec<crate::api::BridgeChannel> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(self.len() as _, serializer);
|
|
for item in self {
|
|
<crate::api::BridgeChannel>::sse_encode(item, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Vec<crate::api::BridgeClient> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(self.len() as _, serializer);
|
|
for item in self {
|
|
<crate::api::BridgeClient>::sse_encode(item, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for Vec<u8> {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<i32>::sse_encode(self.len() as _, serializer);
|
|
for item in self {
|
|
<u8>::sse_encode(item, serializer);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SseEncode for (String, String, String) {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
<String>::sse_encode(self.0, serializer);
|
|
<String>::sse_encode(self.1, serializer);
|
|
<String>::sse_encode(self.2, serializer);
|
|
}
|
|
}
|
|
|
|
impl SseEncode for u32 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_u32::<NativeEndian>(self).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for u64 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_u64::<NativeEndian>(self).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for u8 {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
|
|
serializer.cursor.write_u8(self).unwrap();
|
|
}
|
|
}
|
|
|
|
impl SseEncode for () {
|
|
// Codec=Sse (Serialization based), see doc to use other codecs
|
|
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
|
|
}
|
|
|
|
#[cfg(not(target_family = "wasm"))]
|
|
mod io {
|
|
// This file is automatically generated, so please do not edit it.
|
|
// @generated by `flutter_rust_bridge`@ 2.12.0.
|
|
|
|
// Section: imports
|
|
|
|
use super::*;
|
|
use flutter_rust_bridge::for_generated::byteorder::{
|
|
NativeEndian, ReadBytesExt, WriteBytesExt,
|
|
};
|
|
use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
|
|
use flutter_rust_bridge::{Handler, IntoIntoDart};
|
|
|
|
// Section: boilerplate
|
|
|
|
flutter_rust_bridge::frb_generated_boilerplate_io!();
|
|
}
|
|
#[cfg(not(target_family = "wasm"))]
|
|
pub use io::*;
|
|
|
|
/// cbindgen:ignore
|
|
#[cfg(target_family = "wasm")]
|
|
mod web {
|
|
// This file is automatically generated, so please do not edit it.
|
|
// @generated by `flutter_rust_bridge`@ 2.12.0.
|
|
|
|
// Section: imports
|
|
|
|
use super::*;
|
|
use flutter_rust_bridge::for_generated::byteorder::{
|
|
NativeEndian, ReadBytesExt, WriteBytesExt,
|
|
};
|
|
use flutter_rust_bridge::for_generated::wasm_bindgen;
|
|
use flutter_rust_bridge::for_generated::wasm_bindgen::prelude::*;
|
|
use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable};
|
|
use flutter_rust_bridge::{Handler, IntoIntoDart};
|
|
|
|
// Section: boilerplate
|
|
|
|
flutter_rust_bridge::frb_generated_boilerplate_web!();
|
|
}
|
|
#[cfg(target_family = "wasm")]
|
|
pub use web::*;
|