Enum WriteError 

pub enum WriteError {
    Hid(String),
    DeviceNotFound,
    DeviceUnreachable {
        index: u8,
    },
    FeatureUnsupported {
        feature_hex: u16,
    },
    EmptyDpiList,
    Hidpp(String),
    HidppFeature {
        operation: HidppOperation,
        feature_hex: u16,
        kind: HidppFeatureErrorKind,
    },
    UnsupportedResponse {
        operation: HidppOperation,
        feature_hex: u16,
    },
    RequestTimedOut {
        operation: HidppOperation,
    },
    RuntimeInit {
        message: String,
    },
    AgentUnavailable,
    InvalidLightValue {
        control: String,
        value: u16,
    },
    LightUnsupported {
        control: String,
    },
    AmbiguousRawDevice,
    DpiUnsupported {
        requested: Dpi,
    },
    DpiNotApplied {
        requested: Dpi,
        actual: Dpi,
    },
    HapticWaveformUnsupported {
        waveform: u8,
    },
    ReportRateUnsupported {
        requested: ReportRate,
    },
    ReportRateNotApplied {
        requested: ReportRate,
        actual: ReportRate,
    },
    BacklightChangeUnsupported {
        change: BacklightChange,
    },
    BacklightNotApplied {
        change: BacklightChange,
    },
    HapticsUnavailable {
        status: u8,
    },
    HostRenameUnsupported,
    HostSlotEmpty {
        slot: u8,
    },
    HostNameRejected {
        max_len: u8,
    },
    HostNameNotApplied {
        requested: String,
        actual: Option<String>,
    },
}

Error returned by HID++ read/write operations.

Serializable + Clone so it can cross the agent↔GUI IPC unchanged: the GUI classifies a device read/write error as permanent (FeatureUnsupported / EmptyDpiList) vs transient, so the discriminating variant must survive the wire — stringifying it would collapse every case to “transient” and a device that genuinely lacks a feature would be re-probed forever. Variant order is therefore wire format: changes require a PROTOCOL_VERSION bump (guarded by openlogi-ipc/tests/wire_format.rs).

Variants

Hid(String)

HID transport error serialized as text.

openlogi_hid::BackendError isn’t Serialize, so carry its message as text; the typed error is never matched on (only constructed + displayed).

DeviceNotFound

No currently connected device matched the requested route.

DeviceUnreachable

The HID node opened, but the target HID++ device index did not answer.

Fields

index: u8

HID++ device index that failed to answer.

FeatureUnsupported

Device does not expose the requested HID++ feature.

Fields

feature_hex: u16

HID++ feature ID that was not present.

EmptyDpiList

Device reported no valid DPI values.

Hidpp(String)

Generic HID++ protocol error serialized as text.

HidppFeature

HID++ feature error response.

Fields

operation: HidppOperation

Operation being performed.

feature_hex: u16

HID++ feature ID involved in the operation.

kind: HidppFeatureErrorKind

HID++ feature error kind.

UnsupportedResponse

Device returned a structurally unsupported response.

Fields

operation: HidppOperation

Operation being performed.

feature_hex: u16

HID++ feature ID involved in the operation.

RequestTimedOut

HID++ request timed out.

Fields

operation: HidppOperation

Operation that timed out.

RuntimeInit

Tokio runtime could not be initialized for a sync caller.

Fields

message: String

Runtime initialization error message.

AgentUnavailable

Background agent write path is unavailable.

InvalidLightValue

A standalone light value is outside the driver’s supported range.

Fields

control: String

Semantic control name.

value: u16

Rejected value in the semantic/native unit supplied by the caller.

LightUnsupported

The selected light driver does not implement a requested control.

Fields

control: String

Semantic control name.

AmbiguousRawDevice

Multiple raw HID nodes matched one physical route.

DpiUnsupported

A DPI write asked for a value the device does not report as supported.

Nothing was written: the device layer checks the device-reported list first rather than leaving the firmware to clamp, ignore or reject it.

Fields

requested: Dpi

The rejected DPI.

DpiNotApplied

The device acknowledged a DPI write but reads back a different value, including after one re-write.

Fields

requested: Dpi

The DPI that was written.

actual: Dpi

The DPI the device reports afterwards.

HapticWaveformUnsupported

A haptic play asked for a waveform the device does not advertise.

Nothing was sent: the device layer checks the 0x19b0 capability mask first, as Logi Options+ does, so a retry cannot succeed.

Fields

waveform: u8

The waveform ID that was refused.

ReportRateUnsupported

A report-rate write asked for a rate the device does not list for its current connection.

Nothing was written: the device layer checks the device-reported list first, so the firmware never has to clamp or reject it.

Fields

requested: ReportRate

The rejected rate.

ReportRateNotApplied

The device acknowledged a report-rate write but reads back a different rate — for instance a gaming mouse whose onboard profile owns the rate.

Fields

requested: ReportRate

The rate that was written.

actual: ReportRate

The rate the device reports afterwards.

BacklightChangeUnsupported

A backlight change the keyboard does not offer — a level beyond its level count, or a mode, level or battery-saving control its 0x1982 capability bits leave out.

Nothing was written: the device layer checks a fresh read first.

Fields

change: BacklightChange

The rejected change.

BacklightNotApplied

The keyboard acknowledged a backlight write but reads back a configuration without the change.

Fields

change: BacklightChange

The change that was written.

HapticsUnavailable

A haptic play refused because the device reports a non-zero 0x19b0 haptic status.

Nothing was sent: Logi Options+ plays only while the status is zero, and the device layer applies the same gate, so a retry cannot succeed until the device reports otherwise.

Fields

status: u8

The raw status byte the device reported.

HostRenameUnsupported

A rename of an Easy-Switch slot’s computer on a device whose 0x1815 capabilities leave renaming out.

Nothing was written.

HostSlotEmpty

A rename of an Easy-Switch slot that has no computer paired, or that the device does not have.

Nothing was written.

Fields

slot: u8

The zero-based slot index asked for.

HostNameRejected

A host name that is empty, holds a NUL, or is longer than the slot stores.

Nothing was written.

Fields

max_len: u8

The longest name, in UTF-8 bytes, the slot stores.

HostNameNotApplied

The device acknowledged a host-name write but reads back another name.

Fields

requested: String

The name that was written.

actual: Option<String>

The name the device reports afterwards, if any.

Trait Implementations

impl Clone for WriteError

fn clone(&self) -> WriteError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WriteError

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WriteError

fn deserialize<__D>( __deserializer: __D, ) -> Result<WriteError, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for WriteError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for WriteError

impl Error for WriteError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<BackendError> for WriteError

Carries a backend failure across the IPC boundary as text.

WriteError is Serialize and BackendError is not, so the message is the payload; the typed error is never matched on downstream.

The impl lives here rather than beside WriteError because BackendError is the local half — the orphan rule allows exactly one of the two homes, and openlogi-core must never depend on a backend.

fn from(error: BackendError) -> Self

Converts to this type from the input type.

impl PartialEq for WriteError

fn eq(&self, other: &WriteError) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for WriteError

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for WriteError