#[derive(Debug, Clone, serde::Serialize)]
pub struct AddCharacteristicParams {
#[serde(rename = "serviceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub service_id: String,
#[serde(rename = "characteristicUuid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub characteristic_uuid: String,
#[serde(rename = "properties")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub properties: crate::bluetooth_emulation::types::CharacteristicProperties,
}
impl<'de> serde::Deserialize<'de> for AddCharacteristicParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddCharacteristicParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "serviceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub service_id: String,
#[serde(rename = "characteristicUuid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub characteristic_uuid: String,
#[serde(rename = "properties")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub properties: crate::bluetooth_emulation::types::CharacteristicProperties,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddCharacteristicParams {
service_id: fields.service_id,
characteristic_uuid: fields.characteristic_uuid,
properties: fields.properties,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddCharacteristic;
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddCharacteristicResponse {
#[serde(rename = "characteristicId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub characteristic_id: String,
}
impl<'de> serde::Deserialize<'de> for AddCharacteristicResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddCharacteristicResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "characteristicId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub characteristic_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddCharacteristicResponse {
characteristic_id: fields.characteristic_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for AddCharacteristic {
type Params = AddCharacteristicParams;
type Response = AddCharacteristicResponse;
const METHOD: &'static str = "BluetoothEmulation.addCharacteristic";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddDescriptorParams {
#[serde(rename = "characteristicId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub characteristic_id: String,
#[serde(rename = "descriptorUuid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub descriptor_uuid: String,
}
impl<'de> serde::Deserialize<'de> for AddDescriptorParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddDescriptorParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "characteristicId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub characteristic_id: String,
#[serde(rename = "descriptorUuid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub descriptor_uuid: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddDescriptorParams {
characteristic_id: fields.characteristic_id,
descriptor_uuid: fields.descriptor_uuid,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddDescriptor;
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddDescriptorResponse {
#[serde(rename = "descriptorId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub descriptor_id: String,
}
impl<'de> serde::Deserialize<'de> for AddDescriptorResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddDescriptorResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "descriptorId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub descriptor_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddDescriptorResponse {
descriptor_id: fields.descriptor_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for AddDescriptor {
type Params = AddDescriptorParams;
type Response = AddDescriptorResponse;
const METHOD: &'static str = "BluetoothEmulation.addDescriptor";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddServiceParams {
#[serde(rename = "address")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub address: String,
#[serde(rename = "serviceUuid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub service_uuid: String,
}
impl<'de> serde::Deserialize<'de> for AddServiceParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddServiceParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "address")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub address: String,
#[serde(rename = "serviceUuid")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub service_uuid: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddServiceParams {
address: fields.address,
service_uuid: fields.service_uuid,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct AddService;
#[derive(Debug, Clone, serde::Serialize)]
pub struct AddServiceResponse {
#[serde(rename = "serviceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub service_id: String,
}
impl<'de> serde::Deserialize<'de> for AddServiceResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = AddServiceResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "serviceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub service_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(AddServiceResponse {
service_id: fields.service_id,
})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for AddService {
type Params = AddServiceParams;
type Response = AddServiceResponse;
const METHOD: &'static str = "BluetoothEmulation.addService";
}
#[derive(Debug, Clone, serde::Serialize, Default)]
pub struct DisableParams {}
impl<'de> serde::Deserialize<'de> for DisableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DisableParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DisableParams {})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Disable;
#[derive(Debug, Clone, serde::Serialize)]
pub struct DisableResponse {}
impl<'de> serde::Deserialize<'de> for DisableResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = DisableResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(DisableResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Disable {
type Params = DisableParams;
type Response = DisableResponse;
const METHOD: &'static str = "BluetoothEmulation.disable";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct EnableParams {
#[serde(rename = "state")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub state: crate::bluetooth_emulation::types::CentralState,
#[serde(rename = "leSupported")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub le_supported: bool,
}
impl<'de> serde::Deserialize<'de> for EnableParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "state")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub state: crate::bluetooth_emulation::types::CentralState,
#[serde(rename = "leSupported")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub le_supported: bool,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EnableParams {
state: fields.state,
le_supported: fields.le_supported,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct Enable;
#[derive(Debug, Clone, serde::Serialize)]
pub struct EnableResponse {}
impl<'de> serde::Deserialize<'de> for EnableResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = EnableResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(EnableResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for Enable {
type Params = EnableParams;
type Response = EnableResponse;
const METHOD: &'static str = "BluetoothEmulation.enable";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveCharacteristicParams {
#[serde(rename = "characteristicId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub characteristic_id: String,
}
impl<'de> serde::Deserialize<'de> for RemoveCharacteristicParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveCharacteristicParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "characteristicId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub characteristic_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveCharacteristicParams {
characteristic_id: fields.characteristic_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveCharacteristic;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveCharacteristicResponse {}
impl<'de> serde::Deserialize<'de> for RemoveCharacteristicResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveCharacteristicResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveCharacteristicResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveCharacteristic {
type Params = RemoveCharacteristicParams;
type Response = RemoveCharacteristicResponse;
const METHOD: &'static str = "BluetoothEmulation.removeCharacteristic";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveDescriptorParams {
#[serde(rename = "descriptorId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub descriptor_id: String,
}
impl<'de> serde::Deserialize<'de> for RemoveDescriptorParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveDescriptorParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "descriptorId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub descriptor_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveDescriptorParams {
descriptor_id: fields.descriptor_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveDescriptor;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveDescriptorResponse {}
impl<'de> serde::Deserialize<'de> for RemoveDescriptorResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveDescriptorResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveDescriptorResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveDescriptor {
type Params = RemoveDescriptorParams;
type Response = RemoveDescriptorResponse;
const METHOD: &'static str = "BluetoothEmulation.removeDescriptor";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveServiceParams {
#[serde(rename = "serviceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub service_id: String,
}
impl<'de> serde::Deserialize<'de> for RemoveServiceParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveServiceParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "serviceId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub service_id: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveServiceParams {
service_id: fields.service_id,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct RemoveService;
#[derive(Debug, Clone, serde::Serialize)]
pub struct RemoveServiceResponse {}
impl<'de> serde::Deserialize<'de> for RemoveServiceResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = RemoveServiceResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(RemoveServiceResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for RemoveService {
type Params = RemoveServiceParams;
type Response = RemoveServiceResponse;
const METHOD: &'static str = "BluetoothEmulation.removeService";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSimulatedCentralStateParams {
#[serde(rename = "state")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub state: crate::bluetooth_emulation::types::CentralState,
}
impl<'de> serde::Deserialize<'de> for SetSimulatedCentralStateParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSimulatedCentralStateParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "state")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub state: crate::bluetooth_emulation::types::CentralState,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetSimulatedCentralStateParams {
state: fields.state,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SetSimulatedCentralState;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SetSimulatedCentralStateResponse {}
impl<'de> serde::Deserialize<'de> for SetSimulatedCentralStateResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SetSimulatedCentralStateResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SetSimulatedCentralStateResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SetSimulatedCentralState {
type Params = SetSimulatedCentralStateParams;
type Response = SetSimulatedCentralStateResponse;
const METHOD: &'static str = "BluetoothEmulation.setSimulatedCentralState";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulateAdvertisementParams {
#[serde(rename = "entry")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub entry: crate::bluetooth_emulation::types::ScanEntry,
}
impl<'de> serde::Deserialize<'de> for SimulateAdvertisementParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulateAdvertisementParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "entry")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub entry: crate::bluetooth_emulation::types::ScanEntry,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulateAdvertisementParams {
entry: fields.entry,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SimulateAdvertisement;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulateAdvertisementResponse {}
impl<'de> serde::Deserialize<'de> for SimulateAdvertisementResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulateAdvertisementResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulateAdvertisementResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SimulateAdvertisement {
type Params = SimulateAdvertisementParams;
type Response = SimulateAdvertisementResponse;
const METHOD: &'static str = "BluetoothEmulation.simulateAdvertisement";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulateCharacteristicOperationResponseParams {
#[serde(rename = "characteristicId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub characteristic_id: String,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::bluetooth_emulation::types::CharacteristicOperationType,
#[serde(rename = "code")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub code: i64,
#[serde(rename = "data")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub data: Option<String>,
}
impl<'de> serde::Deserialize<'de> for SimulateCharacteristicOperationResponseParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulateCharacteristicOperationResponseParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "characteristicId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub characteristic_id: String,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::bluetooth_emulation::types::CharacteristicOperationType,
#[serde(rename = "code")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub code: i64,
#[serde(rename = "data")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub data: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulateCharacteristicOperationResponseParams {
characteristic_id: fields.characteristic_id,
r#type: fields.r#type,
code: fields.code,
data: fields.data,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SimulateCharacteristicOperationResponse;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulateCharacteristicOperationResponseResponse {}
impl<'de> serde::Deserialize<'de> for SimulateCharacteristicOperationResponseResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulateCharacteristicOperationResponseResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulateCharacteristicOperationResponseResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SimulateCharacteristicOperationResponse {
type Params = SimulateCharacteristicOperationResponseParams;
type Response = SimulateCharacteristicOperationResponseResponse;
const METHOD: &'static str = "BluetoothEmulation.simulateCharacteristicOperationResponse";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulateDescriptorOperationResponseParams {
#[serde(rename = "descriptorId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub descriptor_id: String,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::bluetooth_emulation::types::DescriptorOperationType,
#[serde(rename = "code")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub code: i64,
#[serde(rename = "data")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub data: Option<String>,
}
impl<'de> serde::Deserialize<'de> for SimulateDescriptorOperationResponseParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulateDescriptorOperationResponseParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "descriptorId")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub descriptor_id: String,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::bluetooth_emulation::types::DescriptorOperationType,
#[serde(rename = "code")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub code: i64,
#[serde(rename = "data")]
#[serde(
default,
deserialize_with = "ydp_core::binding_support::presence",
skip_serializing_if = "Option::is_none"
)]
pub data: Option<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulateDescriptorOperationResponseParams {
descriptor_id: fields.descriptor_id,
r#type: fields.r#type,
code: fields.code,
data: fields.data,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SimulateDescriptorOperationResponse;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulateDescriptorOperationResponseResponse {}
impl<'de> serde::Deserialize<'de> for SimulateDescriptorOperationResponseResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulateDescriptorOperationResponseResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulateDescriptorOperationResponseResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SimulateDescriptorOperationResponse {
type Params = SimulateDescriptorOperationResponseParams;
type Response = SimulateDescriptorOperationResponseResponse;
const METHOD: &'static str = "BluetoothEmulation.simulateDescriptorOperationResponse";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulateGattDisconnectionParams {
#[serde(rename = "address")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub address: String,
}
impl<'de> serde::Deserialize<'de> for SimulateGattDisconnectionParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulateGattDisconnectionParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "address")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub address: String,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulateGattDisconnectionParams {
address: fields.address,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SimulateGattDisconnection;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulateGattDisconnectionResponse {}
impl<'de> serde::Deserialize<'de> for SimulateGattDisconnectionResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulateGattDisconnectionResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulateGattDisconnectionResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SimulateGattDisconnection {
type Params = SimulateGattDisconnectionParams;
type Response = SimulateGattDisconnectionResponse;
const METHOD: &'static str = "BluetoothEmulation.simulateGATTDisconnection";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulateGattOperationResponseParams {
#[serde(rename = "address")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub address: String,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::bluetooth_emulation::types::GattOperationType,
#[serde(rename = "code")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub code: i64,
}
impl<'de> serde::Deserialize<'de> for SimulateGattOperationResponseParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulateGattOperationResponseParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "address")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub address: String,
#[serde(rename = "type")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub r#type: crate::bluetooth_emulation::types::GattOperationType,
#[serde(rename = "code")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub code: i64,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulateGattOperationResponseParams {
address: fields.address,
r#type: fields.r#type,
code: fields.code,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SimulateGattOperationResponse;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulateGattOperationResponseResponse {}
impl<'de> serde::Deserialize<'de> for SimulateGattOperationResponseResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulateGattOperationResponseResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulateGattOperationResponseResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SimulateGattOperationResponse {
type Params = SimulateGattOperationResponseParams;
type Response = SimulateGattOperationResponseResponse;
const METHOD: &'static str = "BluetoothEmulation.simulateGATTOperationResponse";
}
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulatePreconnectedPeripheralParams {
#[serde(rename = "address")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub address: String,
#[serde(rename = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
#[serde(rename = "manufacturerData")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manufacturer_data: Vec<crate::bluetooth_emulation::types::ManufacturerData>,
#[serde(rename = "knownServiceUuids")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub known_service_uuids: Vec<String>,
}
impl<'de> serde::Deserialize<'de> for SimulatePreconnectedPeripheralParams {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulatePreconnectedPeripheralParams;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {
#[serde(rename = "address")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub address: String,
#[serde(rename = "name")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub name: String,
#[serde(rename = "manufacturerData")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub manufacturer_data: Vec<crate::bluetooth_emulation::types::ManufacturerData>,
#[serde(rename = "knownServiceUuids")]
#[serde(deserialize_with = "ydp_core::binding_support::required")]
pub known_service_uuids: Vec<String>,
}
let fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulatePreconnectedPeripheralParams {
address: fields.address,
name: fields.name,
manufacturer_data: fields.manufacturer_data,
known_service_uuids: fields.known_service_uuids,
})
}
}
d.deserialize_map(Visitor)
}
}
#[derive(Debug, Clone, Copy)]
pub struct SimulatePreconnectedPeripheral;
#[derive(Debug, Clone, serde::Serialize)]
pub struct SimulatePreconnectedPeripheralResponse {}
impl<'de> serde::Deserialize<'de> for SimulatePreconnectedPeripheralResponse {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct Visitor;
impl<'de> serde::de::Visitor<'de> for Visitor {
type Value = SimulatePreconnectedPeripheralResponse;
fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("协议 object")
}
fn visit_map<A: serde::de::MapAccess<'de>>(
self,
a: A,
) -> Result<Self::Value, A::Error> {
#[derive(serde::Deserialize)]
struct Fields {}
let _fields = <Fields as serde::Deserialize>::deserialize(
serde::de::value::MapAccessDeserializer::new(a),
)?;
Ok(SimulatePreconnectedPeripheralResponse {})
}
}
d.deserialize_map(Visitor)
}
}
impl ydp_core::Command for SimulatePreconnectedPeripheral {
type Params = SimulatePreconnectedPeripheralParams;
type Response = SimulatePreconnectedPeripheralResponse;
const METHOD: &'static str = "BluetoothEmulation.simulatePreconnectedPeripheral";
}