edison/chanora
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(audio,bridge,flutter): v1 audio + PTT lifecycle implementation (SDD-094..097)

Browse Source 
Implement the SDD-094 / SDD-095 / SDD-096 / SDD-097 detailed designs
committed in dfa84ee.

Rust side
- chanora_audio::TransmitMode enum (Ptt/Continuous/VoiceActivity) with
  serde-friendly u8 repr (SDD-095).
- chanora_audio::TransmitModeSelector: lock-free Atomic-backed selector
  that is the sole writer of transmit_active (per SAD-083), applying
  hard_mute as a final clamp. VoiceActivity falls through to Continuous
  for v1 (DEC-030 placeholder).
- chanora_audio::ReleaseTailTimer: tokio-task-owning struct driving the
  selector's ptt_held input; default 200 ms tail, configurable 0–500 ms
  with AtomicU32 hot read; pending JoinHandle held in a std::sync::Mutex
  touched only on PTT edge transitions (SDD-096).
- chanora_storage: AudioMeta persisted as audio_meta.json next to
  identity.dek; get/set_transmit_mode + get/set_release_tail_ms with
  0..=500 clamp on write.
- chanora_core::ChanoraSession: voice_join(channel, password) and
  voice_leave() are the new lifecycle entry points; ensure_audio_running
  and shutdown_audio_if_idle are private helpers around the existing
  Option<AudioEngine> field. SessionEvent::VoiceState carries the
  in_channel / transmit_mode / mute / release_tail_ms tuple. Selector
  state survives reconnect; supervisor rewires it to each fresh engine
  gate.
- chanora_bridge: drop start_audio; add voice_join, voice_leave,
  set/get_transmit_mode, set/get_release_tail_ms, set_hard_mute.
  BridgeEvent::VoiceState mirrors the core event. AudioStarted/Stopped
  kept for backwards compat but Flutter ignores them in the new UI.

Flutter side
- New apps/chanora_flutter/lib/widgets/voice_bar.dart replaces the
  legacy _AudioControls widget. Renders channel pill, mode badge,
  mute toggle, level meter, PttCapabilityBadge, leave button. No
  manual Start affordance anywhere.
- New apps/chanora_flutter/lib/widgets/voice_settings.dart dialog with
  TransmitMode radio group (VoiceActivity disabled with 'Coming soon'
  trailing label per DEC-030), bind-key button, release-tail slider
  0–500 ms step 25.
- main.dart: state fields _inChannel, _transmitMode, _hardMute,
  _releaseTailMs driven by BridgeEvent_VoiceState. Channel-tap now
  calls voiceJoin instead of moveToChannel. Removed _onStartAudio,
  _audioStarted-gated branch, and the FilledButton.
- l10n: 11 new strings in app_en.arb + app_zh.arb.

Verification
- cargo check --workspace: clean.
- cargo test --workspace --lib: 72 passed / 0 failed / 1 ignored
  (chanora_audio: +12 new tests for TransmitMode/Selector/ReleaseTail;
  chanora_storage: +2 new tests for audio_meta round-trip).
- flutter analyze: 0 errors, 0 warnings; 6 infos are the Flutter 3.32
  Radio.groupValue deprecation (pre-existing API usage).
- FRB Dart/Rust bindings regenerated via flutter_rust_bridge_codegen.

Follow-up (intentionally deferred)
- PttController and per-platform PTT backends still drive AudioTransmitGate
  directly via the legacy set_ptt path; routing those key edges through
  ChanoraSession::release_tail_timer().{key_down,key_up} so the tail
  applies to native PTT input is a contained wiring change in a follow-up.
- Real audio-level RMS in BridgeAudioStats (current meter is binary).
- VoiceActivity backend (DEC-030).
This commit is contained in:
EdisonJwa
2026-05-15 23:05:37 +08:00
parent dfa84ee7bb
commit ba444d94bd
25 changed files with 2519 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/chanora_bridge/src/api.rs
+139 -11
View File
@@ -232,24 +232,128 @@ pub async fn is_connected() -> bool {
// ---------- Audio commands (Beta) ----------
/// Start the audio engine on the active connection. Requires a
/// connection; idempotent (will replace any previous engine).
pub async fn start_audio() -> Result<(), BridgeError> {
// `start_audio` was removed per SDD-094 — voice activation now
// flows through `voice_join` / `voice_leave`, which transparently
// drive `AudioEngine::ensure_running` / `shutdown_if_idle`.
/// Set the push-to-talk state.
///
/// Superseded in v1 by [`set_transmit_mode`] + the binding capture
/// dialog. Retained so legacy callers and integration tests keep
/// working; the new VoiceBar UI no longer invokes this.
pub async fn set_ptt(active: bool) -> Result<(), BridgeError> {
runtime()
.spawn(async {
session()
.start_audio(chanora_core::AudioEngineConfig::default())
.await
})
.spawn(async move { session().set_ptt(active).await })
.await
.map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
Ok(())
}
/// Set the push-to-talk state.
pub async fn set_ptt(active: bool) -> Result<(), BridgeError> {
// ---------- v1 voice lifecycle (SDD-094/095/096) ----------
/// Voice transmit mode mirror (SDD-095). Schema-controlled enum;
/// the wire encoding matches [`chanora_core::TransmitMode::as_u8`].
#[derive(Debug, Clone, Copy)]
pub enum BridgeTransmitMode {
/// Push-to-talk (default).
Ptt,
/// Continuous transmission while in channel and not muted.
Continuous,
/// Voice-activity detection — reserved per DEC-030; v1 behaves
/// as `Continuous`.
VoiceActivity,
}
impl From<BridgeTransmitMode> for chanora_core::TransmitMode {
fn from(m: BridgeTransmitMode) -> Self {
match m {
BridgeTransmitMode::Ptt => Self::Ptt,
BridgeTransmitMode::Continuous => Self::Continuous,
BridgeTransmitMode::VoiceActivity => Self::VoiceActivity,
}
}
}
impl From<chanora_core::TransmitMode> for BridgeTransmitMode {
fn from(m: chanora_core::TransmitMode) -> Self {
match m {
chanora_core::TransmitMode::Ptt => Self::Ptt,
chanora_core::TransmitMode::Continuous => Self::Continuous,
chanora_core::TransmitMode::VoiceActivity => Self::VoiceActivity,
}
}
}
fn transmit_mode_from_u8(v: u8) -> BridgeTransmitMode {
chanora_core::TransmitMode::from_u8(v)
.unwrap_or_default()
.into()
}
/// Join a voice channel (SDD-094). Moves the user to `channel_id`,
/// brings up the audio engine if needed, and emits
/// `BridgeEvent::VoiceState`. `password` may be empty.
pub async fn voice_join(channel_id: u64, password: String) -> Result<(), BridgeError> {
let pw = if password.is_empty() { None } else { Some(password) };
runtime()
.spawn(async move { session().set_ptt(active).await })
.spawn(async move { session().voice_join(channel_id, pw).await })
.await
.map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
Ok(())
}
/// Leave the current voice channel (SDD-094). Tears down the audio
/// engine and emits `BridgeEvent::VoiceState`.
pub async fn voice_leave() -> Result<(), BridgeError> {
runtime()
.spawn(async { session().voice_leave().await })
.await
.map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
Ok(())
}
/// Set the active transmit mode (SDD-095).
pub async fn set_transmit_mode(mode: BridgeTransmitMode) -> Result<(), BridgeError> {
runtime()
.spawn(async move { session().set_transmit_mode(mode.into()).await })
.await
.map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
Ok(())
}
/// Read the active transmit mode.
pub async fn get_transmit_mode() -> BridgeTransmitMode {
runtime()
.spawn(async { session().transmit_mode() })
.await
.unwrap_or(chanora_core::TransmitMode::Ptt)
.into()
}
/// Update the release-tail in milliseconds (SDD-096). Values are
/// clamped to `0..=500` on the Rust side; passing anything larger
/// silently saturates.
pub async fn set_release_tail_ms(ms: u32) -> Result<(), BridgeError> {
runtime()
.spawn(async move { session().set_release_tail_ms(ms).await })
.await
.map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
Ok(())
}
/// Read the current release-tail in milliseconds.
pub async fn get_release_tail_ms() -> u32 {
runtime()
.spawn(async { session().release_tail_ms() })
.await
.unwrap_or(200)
}
/// Engage or release the hard-mute clamp (SDD-094). When `true`
/// the audio engine transmits nothing regardless of mode.
pub async fn set_hard_mute(muted: bool) -> Result<(), BridgeError> {
runtime()
.spawn(async move { session().set_hard_mute(muted).await })
.await
.map_err(|e| BridgeError::Unmapped(format!("join: {e}")))??;
Ok(())
@@ -579,6 +683,19 @@ pub enum BridgeEvent {
/// `"mouse-side-button"`); empty when no binding is active.
bound_input_class: String,
},
/// Voice subsystem state snapshot (SDD-094). The Flutter
/// VoiceBar listens to this stream.
VoiceState {
/// True when the session is currently joined to a voice
/// channel and the audio engine is running.
in_channel: bool,
/// Active transmit mode.
transmit_mode: BridgeTransmitMode,
/// True when the hard-mute clamp is engaged.
mute: bool,
/// Current release-tail in milliseconds (0..=500).
release_tail_ms: u32,
},
}
impl From<chanora_core::SessionEvent> for BridgeEvent {
@@ -612,6 +729,17 @@ impl From<chanora_core::SessionEvent> for BridgeEvent {
backend_id,
bound_input_class,
},
chanora_core::SessionEvent::VoiceState {
in_channel,
transmit_mode,
mute,
release_tail_ms,
} => BridgeEvent::VoiceState {
in_channel,
transmit_mode: transmit_mode_from_u8(transmit_mode),
mute,
release_tail_ms,
},
}
}
}
crates/chanora_bridge/src/frb_generated.rs
+363 -50
View File
@@ -38,7 +38,7 @@ flutter_rust_bridge::frb_generated_boilerplate!(
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 = -427953414;
pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = -330689763;
// Section: executor
@@ -326,6 +326,77 @@ fn wire__crate__api__export_diagnostics_impl(
},
)
}
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,
@@ -505,6 +576,42 @@ fn wire__crate__api__ptt_descriptor_impl(
},
)
}
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,
@@ -719,6 +826,78 @@ fn wire__crate__api__set_ptt_binding_impl(
},
)
}
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,
@@ -754,41 +933,6 @@ fn wire__crate__api__snapshot_impl(
},
)
}
fn wire__crate__api__start_audio_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: "start_audio",
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::start_audio().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,
@@ -825,6 +969,79 @@ fn wire__crate__api__update_bookmark_impl(
},
)
}
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
@@ -1012,6 +1229,19 @@ impl SseDecode for crate::api::BridgeEvent {
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!("");
}
@@ -1065,6 +1295,19 @@ impl SseDecode for crate::api::BridgeSnapshot {
}
}
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 {
@@ -1186,19 +1429,25 @@ fn pde_ffi_dispatcher_primary_impl(
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__init_storage_impl(port, ptr, rust_vec_len, data_len),
10 => wire__crate__api__is_connected_impl(port, ptr, rust_vec_len, data_len),
11 => wire__crate__api__list_bookmarks_impl(port, ptr, rust_vec_len, data_len),
12 => wire__crate__api__move_to_channel_impl(port, ptr, rust_vec_len, data_len),
13 => wire__crate__api__ptt_descriptor_impl(port, ptr, rust_vec_len, data_len),
14 => wire__crate__api__set_input_muted_impl(port, ptr, rust_vec_len, data_len),
16 => wire__crate__api__set_output_gain_impl(port, ptr, rust_vec_len, data_len),
17 => wire__crate__api__set_output_muted_impl(port, ptr, rust_vec_len, data_len),
18 => wire__crate__api__set_ptt_impl(port, ptr, rust_vec_len, data_len),
19 => wire__crate__api__set_ptt_binding_impl(port, ptr, rust_vec_len, data_len),
20 => wire__crate__api__snapshot_impl(port, ptr, rust_vec_len, data_len),
21 => wire__crate__api__start_audio_impl(port, ptr, rust_vec_len, data_len),
22 => wire__crate__api__update_bookmark_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),
14 => wire__crate__api__move_to_channel_impl(port, ptr, rust_vec_len, data_len),
15 => wire__crate__api__ptt_descriptor_impl(port, ptr, rust_vec_len, data_len),
16 => wire__crate__api__set_hard_mute_impl(port, ptr, rust_vec_len, data_len),
17 => wire__crate__api__set_input_muted_impl(port, ptr, rust_vec_len, data_len),
19 => wire__crate__api__set_output_gain_impl(port, ptr, rust_vec_len, data_len),
20 => wire__crate__api__set_output_muted_impl(port, ptr, rust_vec_len, data_len),
21 => wire__crate__api__set_ptt_impl(port, ptr, rust_vec_len, data_len),
22 => wire__crate__api__set_ptt_binding_impl(port, ptr, rust_vec_len, data_len),
23 => wire__crate__api__set_release_tail_ms_impl(port, ptr, rust_vec_len, data_len),
24 => wire__crate__api__set_transmit_mode_impl(port, ptr, rust_vec_len, data_len),
25 => wire__crate__api__snapshot_impl(port, ptr, rust_vec_len, data_len),
26 => wire__crate__api__update_bookmark_impl(port, ptr, rust_vec_len, data_len),
27 => wire__crate__api__voice_join_impl(port, ptr, rust_vec_len, data_len),
28 => wire__crate__api__voice_leave_impl(port, ptr, rust_vec_len, data_len),
_ => unreachable!(),
}
}
@@ -1212,7 +1461,7 @@ fn pde_ffi_dispatcher_sync_impl(
// 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),
15 => wire__crate__api__set_network_state_impl(ptr, rust_vec_len, data_len),
18 => wire__crate__api__set_network_state_impl(ptr, rust_vec_len, data_len),
_ => unreachable!(),
}
}
@@ -1366,6 +1615,19 @@ impl flutter_rust_bridge::IntoDart for crate::api::BridgeEvent {
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!("");
}
@@ -1442,6 +1704,28 @@ impl flutter_rust_bridge::IntoIntoDart<crate::api::BridgeSnapshot> for crate::ap
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
@@ -1591,6 +1875,18 @@ impl SseEncode for crate::api::BridgeEvent {
<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!("");
}
@@ -1644,6 +1940,23 @@ impl SseEncode for crate::api::BridgeSnapshot {
}
}
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) {