use fidl_fuchsia_lowpan::MacAddress;
use fidl_fuchsia_lowpan_device::{
ConnectivityState as lowpan_ConnectivityState, DeviceState, Role as lowpan_RoleState,
};
use fidl_fuchsia_lowpan_test::{
MacAddressFilterItem, MacAddressFilterMode, MacAddressFilterSettings, NeighborInfo,
};
use serde::{Deserialize, Serialize};
pub enum WpanMethod {
GetIsCommissioned,
GetMacAddressFilterSettings,
GetNcpChannel,
GetNcpMacAddress,
GetNcpRssi,
GetNcpDeviceState,
GetNcpState,
GetNetworkName,
GetNeighborTable,
GetPanId,
GetPartitionId,
GetThreadRloc16,
GetThreadRouterId,
GetWeaveNodeId,
InitializeProxies,
ReplaceMacAddressFilterSettings,
}
impl std::str::FromStr for WpanMethod {
type Err = anyhow::Error;
fn from_str(method: &str) -> Result<Self, Self::Err> {
match method {
"GetIsCommissioned" => Ok(WpanMethod::GetIsCommissioned),
"GetMacAddressFilterSettings" => Ok(WpanMethod::GetMacAddressFilterSettings),
"GetNcpChannel" => Ok(WpanMethod::GetNcpChannel),
"GetNcpMacAddress" => Ok(WpanMethod::GetNcpMacAddress),
"GetNcpRssi" => Ok(WpanMethod::GetNcpRssi),
"GetNcpDeviceState" => Ok(WpanMethod::GetNcpDeviceState),
"GetNcpState" => Ok(WpanMethod::GetNcpState),
"GetNeighborTable" => Ok(WpanMethod::GetNeighborTable),
"GetNetworkName" => Ok(WpanMethod::GetNetworkName),
"GetPanId" => Ok(WpanMethod::GetPanId),
"GetPartitionId" => Ok(WpanMethod::GetPartitionId),
"GetThreadRloc16" => Ok(WpanMethod::GetThreadRloc16),
"GetThreadRouterId" => Ok(WpanMethod::GetThreadRouterId),
"GetWeaveNodeId" => Ok(WpanMethod::GetWeaveNodeId),
"InitializeProxies" => Ok(WpanMethod::InitializeProxies),
"ReplaceMacAddressFilterSettings" => Ok(WpanMethod::ReplaceMacAddressFilterSettings),
_ => return Err(format_err!("invalid Wpan FIDL method: {}", method)),
}
}
}
#[derive(Serialize)]
pub enum ConnectivityState {
Inactive,
Ready,
Offline,
Attaching,
Attached,
Isolated,
Commissioning,
Unknown,
}
#[derive(Serialize)]
pub enum RoleState {
Detached,
Child,
Router,
Leader,
Unknown,
}
#[derive(Serialize)]
pub struct DeviceStateDto {
pub connectivity_state: Option<ConnectivityState>,
pub role: Option<RoleState>,
}
impl From<DeviceState> for DeviceStateDto {
fn from(d: DeviceState) -> Self {
DeviceStateDto {
connectivity_state: d.connectivity_state.map(|state| state.into()),
role: d.role.map(|role| role.into()),
}
}
}
impl From<lowpan_RoleState> for RoleState {
fn from(value: lowpan_RoleState) -> Self {
match value {
lowpan_RoleState::Detached => RoleState::Detached,
lowpan_RoleState::EndDevice => RoleState::Child,
lowpan_RoleState::Router => RoleState::Router,
lowpan_RoleState::SleepyEndDevice => RoleState::Child,
lowpan_RoleState::SleepyRouter => RoleState::Router,
lowpan_RoleState::Leader => RoleState::Leader,
lowpan_RoleState::Coordinator => RoleState::Leader,
_ => RoleState::Unknown,
}
}
}
impl From<lowpan_ConnectivityState> for ConnectivityState {
fn from(value: lowpan_ConnectivityState) -> Self {
match value {
lowpan_ConnectivityState::Inactive => ConnectivityState::Inactive,
lowpan_ConnectivityState::Ready => ConnectivityState::Ready,
lowpan_ConnectivityState::Offline => ConnectivityState::Offline,
lowpan_ConnectivityState::Attaching => ConnectivityState::Attaching,
lowpan_ConnectivityState::Attached => ConnectivityState::Attached,
lowpan_ConnectivityState::Isolated => ConnectivityState::Isolated,
lowpan_ConnectivityState::Commissioning => ConnectivityState::Commissioning,
_ => ConnectivityState::Unknown,
}
}
}
#[derive(Serialize, Deserialize)]
pub struct MacAddressFilterItemDto {
pub mac_address: Option<[u8; 8]>,
pub rssi: Option<i8>,
}
#[derive(Serialize, Deserialize)]
pub struct MacAddressFilterSettingsDto {
pub items: Option<Vec<MacAddressFilterItemDto>>,
pub mode: Option<MacAddressFilterModeDto>,
}
#[derive(Serialize, Deserialize)]
pub enum MacAddressFilterModeDto {
Disabled = 0,
Allow = 1,
Deny = 2,
}
#[derive(Serialize, Deserialize)]
pub struct NeighborInfoDto {
pub mac_address: Option<[u8; 8]>,
pub short_address: Option<u16>,
pub age: Option<i64>,
pub is_child: Option<bool>,
pub link_frame_count: Option<u32>,
pub mgmt_frame_count: Option<u32>,
pub last_rssi_in: Option<i32>,
pub avg_rssi_in: Option<i8>,
pub lqi_in: Option<u8>,
pub thread_mode: Option<u8>,
}
impl Into<MacAddressFilterItemDto> for MacAddressFilterItem {
fn into(self) -> MacAddressFilterItemDto {
let mac_address = self.mac_address.map(|addr| addr.octets);
MacAddressFilterItemDto { mac_address, rssi: self.rssi }
}
}
impl Into<MacAddressFilterItem> for MacAddressFilterItemDto {
fn into(self) -> MacAddressFilterItem {
let mac_address = self.mac_address.map(|octets| MacAddress { octets });
MacAddressFilterItem { mac_address, rssi: self.rssi, ..Default::default() }
}
}
impl Into<MacAddressFilterSettings> for MacAddressFilterSettingsDto {
fn into(self) -> MacAddressFilterSettings {
MacAddressFilterSettings {
mode: match self.mode {
Some(mode) => Some(mode.into()),
None => None,
},
items: match self.items {
Some(items) => Some(items.into_iter().map(|x| x.into()).collect()),
None => None,
},
..Default::default()
}
}
}
impl Into<MacAddressFilterSettingsDto> for MacAddressFilterSettings {
fn into(self) -> MacAddressFilterSettingsDto {
MacAddressFilterSettingsDto {
mode: match self.mode {
Some(mode) => Some(mode.into()),
None => None,
},
items: match self.items {
Some(items) => Some(items.into_iter().map(|x| x.into()).collect()),
None => None,
},
}
}
}
impl Into<MacAddressFilterModeDto> for MacAddressFilterMode {
fn into(self) -> MacAddressFilterModeDto {
match self {
MacAddressFilterMode::Disabled => MacAddressFilterModeDto::Disabled,
MacAddressFilterMode::Allow => MacAddressFilterModeDto::Allow,
MacAddressFilterMode::Deny => MacAddressFilterModeDto::Deny,
}
}
}
impl Into<MacAddressFilterMode> for MacAddressFilterModeDto {
fn into(self) -> MacAddressFilterMode {
match self {
MacAddressFilterModeDto::Disabled => MacAddressFilterMode::Disabled,
MacAddressFilterModeDto::Allow => MacAddressFilterMode::Allow,
MacAddressFilterModeDto::Deny => MacAddressFilterMode::Deny,
}
}
}
impl Into<NeighborInfoDto> for NeighborInfo {
fn into(self) -> NeighborInfoDto {
let mac_address = self.mac_address.map(|addr| addr.octets);
NeighborInfoDto {
mac_address,
short_address: self.short_address,
age: self.age,
is_child: self.is_child,
link_frame_count: self.link_frame_count,
mgmt_frame_count: self.mgmt_frame_count,
last_rssi_in: self.last_rssi_in,
avg_rssi_in: self.avg_rssi_in,
lqi_in: self.lqi_in,
thread_mode: self.thread_mode,
}
}
}
impl Into<NeighborInfo> for NeighborInfoDto {
fn into(self) -> NeighborInfo {
let mac_address = self.mac_address.map(|octets| MacAddress { octets });
NeighborInfo {
mac_address,
short_address: self.short_address,
age: self.age,
is_child: self.is_child,
link_frame_count: self.link_frame_count,
mgmt_frame_count: self.mgmt_frame_count,
last_rssi_in: self.last_rssi_in,
avg_rssi_in: self.avg_rssi_in,
lqi_in: self.lqi_in,
thread_mode: self.thread_mode,
..Default::default()
}
}
}