EI Protocol

https://libinput.pages.freedesktop.org/libei/
Admin
EI Protocol details the protocol to communicate between the client side and the Emulated Input...
Tokens:96,707
Snippets:1,170
Trust Score:7.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### eis_device_start_emulating

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-receiver.html

Starts the emulation sequence for the device.

```APIDOC
void eis_device_start_emulating(struct eis_device *device, uint32_t sequence)
```

--------------------------------

### Start device emulation

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_device/index.html

Notifies the EIS implementation that the device is about to start sending events. This request is restricted to clients with context type sender.

```protocol
ei_device.start_emulating(last_serial, sequence)
```

--------------------------------

### ei_device.start_emulating

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_device/index.html

Notifies the EIS implementation that the device is about to start sending events.

```APIDOC
## ei_device.start_emulating

### Description
Notifies the EIS implementation that the device is about to start sending events. This acts as a transactional boundary for setup and synchronization.

### Method
Request

### Parameters
- **last_serial** (uint32) - Required - The last serial sent by the EIS implementation.
- **sequence** (uint32) - Required - Sequence number to identify this emulation sequence.
```

--------------------------------

### EIS Backend Setup

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Functions for configuring the backend communication channel for the EIS context.

```APIDOC
## eis_setup_backend_socket

### Description
Sets up the EIS backend to listen on a specific Unix socket path.

### Signature
`int eis_setup_backend_socket(struct eis *ctx, const char *path);`

## eis_get_fd

### Description
Retrieves the file descriptor associated with the EIS context for event polling.

### Signature
`int eis_get_fd(struct eis *eis);`
```

--------------------------------

### ei_device_start_emulating

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h_source.html

Notifies the EIS implementation that the given device is about to start sending events.

```APIDOC
## void ei_device_start_emulating(struct ei_device *device, uint32_t sequence)

### Description
Notify the EIS implementation that the given device is about to start sending events.
```

--------------------------------

### Begin pinch gesture

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_gesture_pinch/index.html

Starts a new pinch gesture with a specified number of fingers, which must be between 2 and 5.

```text
ei_gesture_pinch.begin(fingers)
```

--------------------------------

### ei_gesture_pinch.begin

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_gesture_pinch/index.html

Starts a new pinch gesture with a specified number of fingers.

```APIDOC
## ei_gesture_pinch.begin

### Description
Starts a new pinch gesture with the given number of fingers. This request is only available for clients of ei_handshake.context_type.sender.

### Signature
`ei_gesture_pinch.begin(fingers)`

### Parameters
- **fingers** (uint32) - Required - The number of fingers, must be between 2 and 5 inclusive.
```

--------------------------------

### String Encoding with Padding

Source: https://libinput.pages.freedesktop.org/libei/doc/types/index.html

Strings are prefixed by their length (including null terminator), followed by the string data zero-padded to the nearest multiple of 4 bytes. This example shows 'hello' encoded.

```protobuf
[0x06, 0x00, 0x00, 0x00, 'h', 'e', 'l', 'l', 'o', '\0', '\0\', '\0']
```

--------------------------------

### Begin swipe gesture

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_gesture_swipe/index.html

Starts a new swipe gesture with a specified number of fingers, which must be between 1 and 5.

```text
ei_gesture_swipe.begin(fingers)
```

--------------------------------

### ei_gesture_swipe.begin

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_gesture_swipe/index.html

Starts a new swipe gesture with a specified number of fingers.

```APIDOC
## ei_gesture_swipe.begin

### Description
Starts a new swipe gesture with the given number of fingers. This request is only available for clients of ei_handshake.context_type.sender.

### Parameters
- **fingers** (uint32) - Required - Number of fingers (must be between 1 and 5 inclusive).

### Signature
`ei_gesture_swipe.begin(fingers)`
```

--------------------------------

### ei_device.start_emulating event

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_device/index.html

Event used to signal the start of emulation, available only for clients of type receiver.

```protocol
ei_device.start_emulating(serial, sequence)
```

--------------------------------

### Begin hold gesture

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_gesture_hold/index.html

Starts a new hold gesture with a specified number of fingers. Only available for sender context types.

```text
ei_gesture_hold.begin(fingers)
```

--------------------------------

### Bind capabilities for ei_stylus

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_stylus/index.html

Binds the client to a specific set of capabilities, required for sender-type clients before starting emulation.

```protocol
ei_stylus.bind_capabilities(capabilities)
```

--------------------------------

### eis_device_add

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-device.html

Adds the device to its seat and notifies the client of the device's availability. The device starts in a paused state.

```APIDOC
## void eis_device_add(struct eis_device *device)

### Description
Add this device to its seat and notify the client of the device's availability. The device is paused, use eis_device_resume() to enable events from the client.
```

--------------------------------

### ei_gesture_hold.begin

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_gesture_hold/index.html

Starts a new hold gesture with a specified number of fingers.

```APIDOC
## ei_gesture_hold.begin

### Description
Starts a new hold gesture with the given number of fingers. This request is only available for clients of ei_handshake.context_type.sender.

### Method
Request

### Signature
`ei_gesture_hold.begin(fingers)`

### Parameters
- **fingers** (uint32) - Required - Number of fingers (1-5 inclusive).
```

--------------------------------

### eis_setup_backend_fd

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis.html

Sets up the backend using a file descriptor.

```APIDOC
## eis_setup_backend_fd

### Description
Configures the libeis backend using a provided file descriptor.
```

--------------------------------

### eis_setup_backend_fd()

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis.html

Initializes the EIS context using pre-configured socket file descriptors.

```APIDOC
## int eis_setup_backend_fd(struct eis *ctx)

### Description
Initializes the context that can take pre-configured socket file descriptors. This is the preferred backend for EIS implementations as it keeps file descriptors private and avoids race conditions.

### Parameters
- **ctx** (struct eis *) - The EIS context to initialize.
```

--------------------------------

### Get touch y coordinate

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Returns the y coordinate for touch events.

```c
double eis_event_touch_get_y(struct eis_event *event)
```

--------------------------------

### eis_setup_backend_socket

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis.html

Sets up the backend using a socket.

```APIDOC
## eis_setup_backend_socket

### Description
Configures the libeis backend using a provided socket.
```

--------------------------------

### eis_setup_backend_socket

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h.html

Initialize the context with a UNIX socket name.

```APIDOC
## int eis_setup_backend_socket(struct eis *ctx, const char *path)

### Description
Initialize the context with a UNIX socket name.
```

--------------------------------

### ei_setup_backend_fd()

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei.html

Initializes the ei context on a given socket file descriptor.

```APIDOC
## ei_setup_backend_fd(struct ei *ei, int fd)

### Description
Initialize the ei context on the given socket file descriptor. The ei context will initiate the conversation with the EIS server listening on the other end of this socket. This function takes ownership of the file descriptor and will close it when tearing down.

### Returns
Zero on success or a negative errno on failure.
```

--------------------------------

### eis_backend_fd_add_client

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis.html

Adds a new client to a context initialized with eis_setup_backend_fd.

```APIDOC
## int eis_backend_fd_add_client(struct eis *ctx)

### Description
Add a new client to a context set up with eis_setup_backend_fd().

### Parameters
- **ctx** (struct eis *) - The context to add the client to.

### Returns
- **int** - A file descriptor to be passed to ei_setup_backend_fd(), or a negative errno on failure.
```

--------------------------------

### eis_device_pinch_begin

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-receiver.html

Begins a new pinch gesture.

```APIDOC
## void eis_device_pinch_begin(struct eis_device *device, uint32_t nfingers)

### Description
Begin a new pinch gesture on a device with the EIS_DEVICE_CAP_GESTURES capability. Only one pinch gesture may be active at a time.

### Parameters
- **device** (struct eis_device *) - A device with EIS_DEVICE_CAP_GESTURES capability.
- **nfingers** (uint32_t) - The number of fingers, must be between 2 and 5 (inclusive).
```

--------------------------------

### Get pinch scale

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Returns the normalized scale for an EIS_EVENT_PINCH_UPDATE event.

```c
double eis_event_pinch_get_scale(struct eis_event *event)
```

--------------------------------

### Get pointer y movement

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Returns the relative y movement for an EIS_EVENT_POINTER_MOTION event.

```c
double eis_event_pointer_get_dy(struct eis_event *event)
```

--------------------------------

### Compile and link programs using pkg-config

Source: https://libinput.pages.freedesktop.org/libei/api/index.html

Use pkg-config to provide the necessary compiler flags and libraries for libei, libeis, or liboeffis.

```bash
gcc -o myprogram mylibeiclient.c `pkg-config --cflags --libs libei-1.0`
gcc -o myprogram myEISimplementation.c `pkg-config --cflags --libs libeis-1.0`
gcc -o myprogram myimpl.c `pkg-config --cflags --libs liboeffis-1.0`
```

--------------------------------

### Get pinch y movement

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Returns the relative y movement for an EIS_EVENT_PINCH_UPDATE event.

```c
double eis_event_pinch_get_dy(struct eis_event *event)
```

--------------------------------

### eis_new

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Initializes a new EIS context.

```APIDOC
## struct eis *eis_new(void *user_data)

### Description
Creates a new EIS context. The user_data pointer is associated with the context and can be retrieved later.

### Parameters
- **user_data** (void*) - Optional - User-defined data to associate with the context.
```

--------------------------------

### Get button code

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Returns the button code for an EIS_EVENT_BUTTON_BUTTON event.

```c
uint32_t eis_event_button_get_button(struct eis_event *event)
```

--------------------------------

### ei_device.ready

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_device/index.html

Notifies the EIS implementation that device configuration is complete.

```APIDOC
## ei_device.ready

### Description
Notification by the client that the device configuration is complete and the EIS implementation may send ei_device.resumed. Required for clients supporting version 3 of the interface.

### Method
Request

### Signature
`ei_device.ready()`
```

--------------------------------

### ei_setup_backend_socket()

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei.html

Sets the ei context to use a socket backend at a specific path.

```APIDOC
## ei_setup_backend_socket(struct ei *ei, const char *socketpath)

### Description
Set this ei context to use the socket backend. The ei context will connect to the socket at the given path and initiate the conversation with the EIS server listening on that socket. This backend is primarily useful for testing and debugging.

### Returns
Zero on success or a negative errno on failure.
```

--------------------------------

### Get pinch finger count

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Returns the finger count for pinch events.

```c
uint32_t eis_event_pinch_get_finger_count(struct eis_event *event)
```

--------------------------------

### Get swipe finger count

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Returns the finger count for swipe events.

```c
uint32_t eis_event_swipe_get_finger_count(struct eis_event *event)
```

--------------------------------

### Include standard headers

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h.html

Required standard headers for libei functionality.

```c
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
```

--------------------------------

### ei_setup_backend_socket

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h_source.html

Configures the libei backend to use a specific socket path.

```APIDOC
## ei_setup_backend_socket

### Description
Sets up the libei backend to communicate via a Unix socket at the provided path.

### Parameters
- **ei** (struct ei*) - Required - The libei context.
- **socketpath** (const char*) - Required - The filesystem path to the socket.
```

--------------------------------

### ei_new()

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei.html

Creates a new libei context.

```APIDOC
## ei_new()

### Description
This is an alias for ei_new_sender.

### Signature
`struct ei * ei_new(void * user_data)`
```

--------------------------------

### Create session

Source: https://libinput.pages.freedesktop.org/libei/api/liboeffis_8h_source.html

Functions to initiate a session, optionally specifying a bus name.

```c
void
oeffis_create_session(struct oeffis *oeffis, uint32_t devices);
```

```c
void
oeffis_create_session_on_bus(struct oeffis *oeffis, const char *busname, uint32_t devices);
```

--------------------------------

### eis_device_pinch_begin

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-receiver.html

Begin a new pinch gesture on a device with the EIS_DEVICE_CAP_GESTURES capability.

```APIDOC
void eis_device_pinch_begin(struct eis_device *device, uint32_t nfingers);
```

--------------------------------

### oeffis_get_fd

Source: https://libinput.pages.freedesktop.org/libei/api/liboeffis_8h.html

Gets the main file descriptor used by liboeffis for all events. This file descriptor can be used for monitoring events.

```APIDOC
## oeffis_get_fd

### Description
liboeffis keeps a single file descriptor for all events.

### Signature
int oeffis_get_fd (struct oeffis *oeffis)

### Parameters
* **oeffis** (struct oeffis *) - Required - A pointer to the oeffis context.

### Returns
int - The file descriptor for monitoring events.
```

--------------------------------

### EIS Initialization and Utilities

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Functions for creating an EIS context and converting event types to strings.

```c
const char *eis_event_type_to_string(enum eis_event_type);

struct eis *
eis_new(void *user_data);
```

--------------------------------

### Report Touch Down Event

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_touchscreen/index.html

Use this request to notify the EIS implementation of a new touch starting. Ensure the touch ID is unique for the current touch sequence and coordinates are within the device's logical pixel regions. This request is only available for clients of ei_handshake.context_type.sender.

```c
ei_touchscreen.down(touchid, x, y)
```

--------------------------------

### oeffis_create_session

Source: https://libinput.pages.freedesktop.org/libei/api/liboeffis_8h_source.html

Initiates a new remote desktop session for the specified devices.

```APIDOC
## void oeffis_create_session(struct oeffis *oeffis, uint32_t devices)

### Description
Request a new session for the given device types.

### Parameters
- **oeffis** (struct oeffis *) - Required - The oeffis context.
- **devices** (uint32_t) - Required - A bitmask of oeffis_device types to request.
```

--------------------------------

### oeffis_create_session

Source: https://libinput.pages.freedesktop.org/libei/api/group__liboeffis.html

Initiates a connection to a RemoteDesktop session.

```APIDOC
## void oeffis_create_session(struct oeffis *oeffis, uint32_t devices)

### Description
Connect this oeffis instance to a RemoteDesktop session with the given device mask selected.

### Parameters
- **oeffis** (struct oeffis*) - Required - The oeffis context.
- **devices** (uint32_t) - Required - A bitmask of devices (oeffis_device) to request.
```

--------------------------------

### eis_new

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h.html

Create a new libeis context with a refcount of 1.

```APIDOC
## struct eis * eis_new(void *user_data)

### Description
Create a new libeis context with a refcount of 1.

### Parameters
- **user_data** (void*) - Optional - Custom data pointer to associate with the context.
```

--------------------------------

### eis_device_add

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Adds the configured device to the system.

```APIDOC
## void eis_device_add(struct eis_device *device)

### Description
Adds the device to the EIS context.
```

--------------------------------

### eis_device_touch_new

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-receiver.html

Creates a new touch context for the given device.

```APIDOC
## struct eis_touch *eis_device_touch_new(struct eis_device *device)

### Description
Creates a new touch context for the given device.
```

--------------------------------

### Device Configuration and Lifecycle

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-device.html

Functions for configuring device properties such as name, type, size, and capabilities, as well as managing the device lifecycle.

```APIDOC
## eis_device_configure_name
### Description
Sets the name of the device.
### Signature
void eis_device_configure_name(struct eis_device *device, const char *name)

## eis_device_configure_type
### Description
Sets the device type for this device.
### Signature
void eis_device_configure_type(struct eis_device *device, enum eis_device_type type)

## eis_device_configure_size
### Description
Configure the size in mm of a device of type EIS_DEVICE_TYPE_PHYSICAL.
### Signature
void eis_device_configure_size(struct eis_device *device, uint32_t width, uint32_t height)

## eis_device_add
### Description
Add this device to its seat and notify the client of the device's availability.
### Signature
void eis_device_add(struct eis_device *device)

## eis_device_remove
### Description
Remove the device.
### Signature
void eis_device_remove(struct eis_device *device)
```

--------------------------------

### ei-scanner Command-Line Help

Source: https://libinput.pages.freedesktop.org/libei/doc/ei-scanner/index.html

Displays the help message for the ei-scanner command-line tool, outlining its usage, arguments, and options. Use this to understand how to invoke the scanner and what parameters are available.

```bash
$ ei-scanner --help
usage: ei-scanner [-h] [--component {ei,eis,brei}] [--output OUTPUT]
                  [--jinja-extra-data JINJA_EXTRA_DATA]
                  [--jinja-extra-data-file JINJA_EXTRA_DATA_FILE]
                  protocol template

ei-scanner is a tool to parse the EI protocol description XML and
pass the data to a Jinja2 template. That template can then be
used to generate protocol bindings for the desired language.

typical usages:
     ei-scanner --component=ei protocol.xml my-template.tpl
     ei-scanner --component=eis --output=bindings.rs
        protocol.xml bindings.rs.tpl

Elements in the XML file are provided as variables with attributes
generally matching the XML file. For example, each interface has
requests, events and enums, and each of those has a name.

ei-scanner additionally provides the following values to the Jinja2 templates:
    - interface.incoming and interface.outgoing: maps to the
       requests/events of the interface, depending on the component.
    - argument.signature: a single-character signature type mapping
      from the protocol XML type:
        uint32 -> "u"
        int32 -> "i"
        uint64 -> "t"
        int64 -> "x"
        float -> "f"
        fd -> "h"
        new_id -> "n"
        object -> "o"
        string -> "s"

ei-scanner adds the following Jinja2 filters for convenience:
    {{foo|c_type}} ... resolves to "struct foo *"
    {{foo|as_c_arg}} ... resolves to "struct foo *foo"
    {{foo_bar|camel}} ... resolves to "FooBar"

positional arguments:
  protocol              The protocol XML file
  template              The Jinja2 compatible template file

options:
  -h, --help            show this help message and exit
  --component {ei,eis,brei}
  --output OUTPUT       Output file to write to
  --jinja-extra-data JINJA_EXTRA_DATA
                        Extra data (in JSON format) to pass through
                        to the Jinja template as 'extra'
  --jinja-extra-data-file JINJA_EXTRA_DATA_FILE
                        Path to file with extra data to pass through
                        to the Jinja template as 'extra'

```

--------------------------------

### eis_device_new_keymap()

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-device.html

Creates a new keymap for a device with the specified type and file descriptor.

```APIDOC
## eis_device_new_keymap()

### Description
Create a new keymap of the given type. This keymap does not immediately apply to the device; use eis_keymap_add() to apply it. A keymap may only be applied once and to a single device.

### Parameters
- **device** (struct eis_device *) - The device with a EIS_DEVICE_CAP_KEYBOARD capability
- **type** (enum eis_keymap_type) - The type of the keymap
- **fd** (int) - A memmap-able file descriptor of size size pointing to the keymap
- **size** (size_t) - The size of the data at fd in bytes

### Returns
A keymap object or NULL on failure.
```

--------------------------------

### ei_device_pinch_begin

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei-sender.html

Begin a new pinch gesture on a device with the EI_DEVICE_CAP_GESTURES capability.

```APIDOC
## void ei_device_pinch_begin(struct ei_device *device, uint32_t nfingers)

### Description
Begin a new pinch gesture on a device with the EI_DEVICE_CAP_GESTURES capability. Only one pinch gesture may be active at a time.

### Parameters
- **device** (struct ei_device *) - A device with EI_DEVICE_CAP_GESTURES capability
- **nfingers** (uint32_t) - The number of fingers, must be between 2 and 5 (inclusive)

### Since
1.7
```

--------------------------------

### eis_device_swipe_begin

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-receiver.html

Begin a new swipe gesture on a device with the EIS_DEVICE_CAP_GESTURES capability.

```APIDOC
void eis_device_swipe_begin(struct eis_device *device, uint32_t nfingers);
```

--------------------------------

### EIS Implementation and Clients Connected via Socket

Source: https://libinput.pages.freedesktop.org/libei/doc/overview/index.html

Illustrates the connection between an ei client and an EIS implementation through a UNIX socket.

```mermaid
flowchart LR;
subgraph EIS implementation
socket[[ei.socket]]
end
c1[ei client 1] -- ei protocol --> socket
c2[ei client 2] -- ei protocol --> socket
```

--------------------------------

### eis_seat_new_device

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-seat.html

Creates a new device on the seat.

```APIDOC
## struct eis_device * eis_seat_new_device(struct eis_seat * seat)

### Description
Creates a new device on the seat. The device is not immediately active; use eis_device_add() to notify the client. The returned device is refcounted; use eis_device_unref() to drop the reference.

### Parameters
- **seat** (struct eis_seat *) - The seat object.
```

--------------------------------

### Device Lifecycle Management

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h.html

Functions for adding, removing, pausing, and resuming devices.

```APIDOC
## void eis_device_add(struct eis_device *device)

### Description
Add this device to its seat and notify the client of the device's availability.

## void eis_device_remove(struct eis_device *device)

### Description
Remove the device.

## void eis_device_pause(struct eis_device *device)

### Description
Notify the client that the device is paused and that no events from the client will be processed.

## void eis_device_resume(struct eis_device *device)

### Description
Notify the client that the capabilities are resumed and that events from the device will be processed.
```

--------------------------------

### Manage user data and file descriptors

Source: https://libinput.pages.freedesktop.org/libei/api/liboeffis_8h_source.html

Accessors for custom user data and internal file descriptors used by the library.

```c
void
oeffis_set_user_data(struct oeffis *oeffis, void *user_data);
```

```c
void *
oeffis_get_user_data(struct oeffis *oeffis);
```

```c
int
oeffis_get_fd(struct oeffis *oeffis);
```

```c
int
oeffis_get_eis_fd(struct oeffis *oeffis);
```

--------------------------------

### Device Management

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Functions for creating, configuring, and controlling the lifecycle of virtual input devices.

```APIDOC
## Device Management

### Functions
- `eis_seat_new_device(struct eis_seat *seat)`: Create a new device on a seat.
- `eis_device_configure_type(struct eis_device *device, enum eis_device_type type)`: Set the device type.
- `eis_device_configure_name(struct eis_device *device, const char *name)`: Set the device name.
- `eis_device_add(struct eis_device *device)`: Finalize and add the device.
- `eis_device_remove(struct eis_device *device)`: Remove the device.
- `eis_device_pause(struct eis_device *device)`: Pause device emulation.
- `eis_device_resume(struct eis_device *device)`: Resume device emulation.
```

--------------------------------

### libei Core API Functions

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei.html

Core functions for initializing and managing a libei client context.

```APIDOC
## ei_new_sender()
### Description
Creates a new libei context in sender mode.

## ei_new_receiver()
### Description
Creates a new libei context in receiver mode.

## ei_setup_backend_fd(int fd)
### Description
Sets up the backend using a file descriptor.

## ei_setup_backend_socket(const char *path)
### Description
Sets up the backend using a socket path.

## ei_get_fd()
### Description
Returns the file descriptor for the libei context to be used with an event loop.

## ei_dispatch()
### Description
Dispatches events for the libei context. Should be called when the file descriptor is ready.

## ei_get_event()
### Description
Retrieves the next event from the libei context.
```

--------------------------------

### Define libei functions

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h_source.html

Functions for event type string conversion and context creation.

```c
const char *ei_event_type_to_string(enum ei_event_type);

struct ei *
ei_new(void *user_data);

struct ei *
ei_new_sender(void *user_data);
```

--------------------------------

### Input Emulation

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Functions for sending input events like pointer motion, buttons, and keyboard input.

```APIDOC
## Input Emulation

### Functions
- `eis_device_pointer_motion(struct eis_device *device, double x, double y)`: Send relative pointer motion.
- `eis_device_pointer_motion_absolute(struct eis_device *device, double x, double y)`: Send absolute pointer motion.
- `eis_device_button_button(struct eis_device *device, uint32_t button, bool is_press)`: Send button event.
- `eis_device_text_utf8(struct eis_device *device, const char *utf8)`: Send UTF-8 text input.
- `eis_device_frame(struct eis_device *device, uint64_t time)`: Commit pending events with a timestamp.
```

--------------------------------

### eis_device_hold_begin

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-receiver.html

Begins a new hold gesture on a device with gesture capabilities.

```APIDOC
## void eis_device_hold_begin(struct eis_device *device, uint32_t nfingers)

### Description
Begin a new hold gesture on a device with the EIS_DEVICE_CAP_GESTURES capability. Only one hold gesture may be active at a time.

### Parameters
- **device** (struct eis_device *) - A device with EIS_DEVICE_CAP_GESTURES capability
- **nfingers** (uint32_t) - The number of fingers, must be between 1 and 5 (inclusive)

### Since
1.7
```

--------------------------------

### eis_device_hold_begin

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-receiver.html

Begin a new hold gesture on a device with the EIS_DEVICE_CAP_GESTURES capability.

```APIDOC
void eis_device_hold_begin(struct eis_device *device, uint32_t nfingers);
```

--------------------------------

### eis_device_swipe_begin

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h_source.html

Begins a swipe gesture with the specified number of fingers.

```APIDOC
## eis_device_swipe_begin

### Description
Begins a swipe gesture with the specified number of fingers.

### Signature
`void eis_device_swipe_begin(struct eis_device *device, uint32_t nfingers);`
```

--------------------------------

### ei_keymap_get_context

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei-keymap.html

Retrieves the device associated with the given keymap.

```APIDOC
## struct ei_device * ei_keymap_get_context(struct ei_keymap *keymap)

### Description
Return the struct ei_device this keymap is associated with.

### Parameters
- **keymap** (struct ei_keymap *) - The keymap object to query.

### Returns
- **struct ei_device*** - The associated device.
```

--------------------------------

### eis_device_swipe_begin

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-receiver.html

Begins a new swipe gesture on a device with the EIS_DEVICE_CAP_GESTURES capability.

```APIDOC
## void eis_device_swipe_begin(struct eis_device *device, uint32_t nfingers)

### Description
Begin a new swipe gesture on a device with the EIS_DEVICE_CAP_GESTURES capability. Only one swipe gesture may be active at a time.

### Parameters
- **device** (struct eis_device *) - A device with EIS_DEVICE_CAP_GESTURES capability
- **nfingers** (uint32_t) - The number of fingers, must be between 1 and 5 (inclusive)

### Since
1.7
```

--------------------------------

### Pointer and Scroll Events

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h_source.html

Functions for simulating pointer motion, button clicks, and scrolling behavior.

```APIDOC
## void ei_device_pointer_motion(struct ei_device *device, double x, double y)
Sends relative pointer motion events.

## void ei_device_pointer_motion_absolute(struct ei_device *device, double x, double y)
Sends absolute pointer motion events.

## void ei_device_button_button(struct ei_device *device, uint32_t button, bool is_press)
Sends a button press or release event.

## void ei_device_scroll_delta(struct ei_device *device, double x, double y)
Sends scroll delta events.
```

--------------------------------

### Device Management Functions

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h_source.html

Functions for managing device state, properties, and lifecycle.

```APIDOC
## ei_device_close

### Description
Notify the server that the client is no longer interested in this device.

## ei_device_set_user_data

### Description
Set a custom data pointer for this device context.

## ei_device_get_width

### Description
Return the width of the device in mm if the device is of type EI_DEVICE_TYPE_PHYSICAL.
```

--------------------------------

### ei_new

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h_source.html

Creates a new ei context for the client implementation.

```APIDOC
## struct ei *ei_new(void *user_data)

### Description
Creates a new ei context. The user_data pointer is associated with the context and can be retrieved later.

### Parameters
- **user_data** (void*) - Optional - User-defined data pointer to associate with the context.
```

--------------------------------

### Device Configuration and Capabilities

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei-device.html

Functions to query device dimensions, capabilities, and associated seat or context information.

```APIDOC
## ei_device_get_seat
struct ei_seat *ei_device_get_seat(struct ei_device *device);

## ei_device_get_width
uint32_t ei_device_get_width(struct ei_device *device);
Return the width of the device in mm if the device is of type EI_DEVICE_TYPE_PHYSICAL, otherwise zero.

## ei_device_get_height
uint32_t ei_device_get_height(struct ei_device *device);
Return the height of the device in mm if the device is of type EI_DEVICE_TYPE_PHYSICAL, otherwise zero.

## ei_device_has_capability
bool ei_device_has_capability(struct ei_device *device, enum ei_device_capability cap);
Return true if the device has the requested capability.

## ei_device_get_context
struct ei *ei_device_get_context(struct ei_device *device);
Return the struct ei context this device is associated with.
```

--------------------------------

### ei_new_receiver

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei-receiver.html

Creates a new receiver client instance for the libei library.

```APIDOC
## ei_new_receiver

### Description
Creates a new receiver client instance. This function initializes the client as a receiver, allowing it to process incoming emulated input events.

### Signature
struct ei *ei_new_receiver(void);
```

--------------------------------

### Keymap Management

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h.html

Functions for creating and managing keymaps associated with devices.

```APIDOC
## struct eis_keymap *eis_device_new_keymap(struct eis_device *device, enum eis_keymap_type type, int fd, size_t size)

### Description
Create a new keymap of the given type.

## void eis_keymap_add(struct eis_keymap *keymap)

### Description
Set the keymap on the device.
```

--------------------------------

### Device Lifecycle and Metadata

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei-device.html

Functions for managing device reference counts, user data, and basic device identification.

```APIDOC
## ei_device_ref
struct ei_device *ei_device_ref(struct ei_device *device);
Increase the refcount of this struct by one.

## ei_device_unref
struct ei_device *ei_device_unref(struct ei_device *device);
Decrease the refcount of this struct by one.

## ei_device_set_user_data
void ei_device_set_user_data(struct ei_device *device, void *user_data);
Set a custom data pointer for this context.

## ei_device_get_user_data
void *ei_device_get_user_data(struct ei_device *device);
Return the custom data pointer for this context.

## ei_device_get_name
const char *ei_device_get_name(struct ei_device *device);

## ei_device_get_type
enum ei_device_type ei_device_get_type(struct ei_device *device);
```

--------------------------------

### oeffis_new

Source: https://libinput.pages.freedesktop.org/libei/api/group__liboeffis.html

Creates a new oeffis context for interacting with the library.

```APIDOC
## struct oeffis * oeffis_new(void *user_data)

### Description
Create a new oeffis context. This context is used for all subsequent interactions with the liboeffis API.

### Parameters
- **user_data** (void*) - Optional - A custom data pointer to associate with the context.
```

--------------------------------

### Backend and Dispatch

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h.html

Functions for configuring the communication backend and processing events.

```APIDOC
## ei_setup_backend_fd
### Description
Initialize the ei context on the given socket file descriptor.

## ei_setup_backend_socket
### Description
Set this ei context to use the socket backend.

## ei_dispatch
### Description
Main event dispatching function.

## ei_get_event / ei_peek_event
### Description
Retrieve or inspect the next event from the event queue.
```

--------------------------------

### eis_device_new_region()

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-device.html

Creates a new region on a virtual device.

```APIDOC
## eis_device_new_region()

### Description
Create a new region on the device of type EIS_DEVICE_TYPE_VIRTUAL with an initial refcount of 1. Use eis_region_add() to properly add the region to the device. A region must have a size to be valid, see eis_region_set_size(). For a device of type EIS_DEVICE_TYPE_PHYSICAL this function returns NULL.

### Parameters
- **device** (struct eis_device *) - The device to create a region for
```

--------------------------------

### ei_device_text_keysym

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei-sender.html

Generates a key event using XKB-compatible keysyms for devices with the EI_DEVICE_CAP_TEXT capability.

```APIDOC
## void ei_device_text_keysym(struct ei_device *device, uint32_t keysym, bool is_press)

### Description
Generate a key event on a device with the EI_DEVICE_CAP_TEXT capability. Keysyms are XKB-compatible and independent of any active keymap.

### Parameters
- **device** (struct ei_device *) - The EI device.
- **keysym** (uint32_t) - The keysym.
- **is_press** (bool) - true for key down, false for key up.
```

--------------------------------

### Request and Event Flow

Source: https://libinput.pages.freedesktop.org/libei/doc/overview/index.html

Shows the asynchronous flow of requests from client to server and events from server to client.

```mermaid
flowchart LR;
ei -- request --> eis
eis -- event --> ei
```

--------------------------------

### eis_device_configure_capability

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-device.html

Configures the capabilities for the specified device.

```APIDOC
## void eis_device_configure_capability(struct eis_device *device, enum eis_device_capability cap)

### Description
Configures the capability for the given device.
```

--------------------------------

### ei_device.done

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_device/index.html

Notifies the client that the initial burst of events is complete.

```APIDOC
## ei_device.done

### Description
Notification that the initial burst of events is complete and the client can set up this device now.

### Signature
`ei_device.done()`
```

--------------------------------

### ei_text.keysym

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_text/index.html

Generate an XKB key sym event. This request is only available for clients of `ei_handshake.context_type.sender`.

```APIDOC
## ei_text.keysym

### Description
Generate an XKB key sym event. This request is only available for clients of `ei_handshake.context_type.sender`.

### Method
`ei_text.keysym(keysym, state)`

### Endpoint
N/A (Method call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **keysym** (uint32) - Required - The key sym
- **state** (uint32) - Required - Logical state of the keysym
```

--------------------------------

### ei_stylus.bind_capabilities

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_stylus/index.html

Requests to bind to a given set of capabilities for the stylus.

```APIDOC
## ei_stylus.bind_capabilities

### Description
Request to bind to a given set of capabilities. This is used by clients to describe which subset of server-supported capabilities may be sent by this particular stylus. This request is only available for clients of ei_handshake.context_type.sender.

### Parameters
- **capabilities** (uint32) - Required - A mask of ‘capability’ flags that the client wishes to handle
```

--------------------------------

### Define libei structures

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h_source.html

Forward declarations for core libei structures used throughout the library.

```c
struct ei;
struct ei_device;
struct ei_seat;
struct ei_event;
struct ei_keymap;
struct ei_region;
struct ei_touch;
struct ei_ping;
```

--------------------------------

### Device Interaction and Regions

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei-device.html

Functions for handling device regions, keymaps, and closing device connections.

```APIDOC
## ei_device_close
void ei_device_close(struct ei_device *device);
Notify the server that the client is no longer interested in this device.

## ei_device_get_region
struct ei_region *ei_device_get_region(struct ei_device *device, size_t index);
Obtain a region from a device of type EI_DEVICE_TYPE_VIRTUAL.

## ei_device_get_region_at
struct ei_region *ei_device_get_region_at(struct ei_device *device, double x, double y);
Return the region that contains the given point x/y (in desktop-wide coordinates) or NULL if the coordinates are outside all regions.

## ei_device_keyboard_get_keymap
struct ei_keymap *ei_device_keyboard_get_keymap(struct ei_device *device);
Return the keymap for this device or NULL.
```

--------------------------------

### ei_device.name event

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_device/index.html

Provides the optional device name, sent once immediately after object creation.

```protocol
ei_device.name(name)
```

--------------------------------

### Define ei_device.interface event

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_device/index.html

Notifies the client of a new sub-interface for the device. Must be sent before ei_device.done.

```text
ei_device.interface(object, interface_name, version)
```

--------------------------------

### Manage oeffis context lifecycle

Source: https://libinput.pages.freedesktop.org/libei/api/liboeffis_8h_source.html

Functions for creating, referencing, and unreferencing the oeffis context structure.

```c
struct oeffis *
oeffis_new(void *user_data);
```

```c
struct oeffis *
oeffis_ref(struct oeffis *oeffis);
```

```c
struct oeffis *
oeffis_unref(struct oeffis *oeffis);
```

--------------------------------

### Input Event Emulation

Source: https://libinput.pages.freedesktop.org/libei/api/libeis_8h.html

Functions for sending input events like pointer motion, button presses, and gestures.

```APIDOC
## void eis_device_pointer_motion(struct eis_device *device, double x, double y)

### Description
Send relative pointer motion events.

## void eis_device_button_button(struct eis_device *device, uint32_t button, bool is_press)

### Description
Send button press or release events.

## void eis_device_swipe_begin(struct eis_device *device, uint32_t nfingers)

### Description
Begin a new swipe gesture on a device with the EIS_DEVICE_CAP_GESTURES capability.
```

--------------------------------

### ei_device.interface

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_device/index.html

Notifies the client that a new device has a sub-interface.

```APIDOC
## ei_device.interface

### Description
Notification that a new device has a sub-interface. This event is optional and sent immediately after object creation and at most once per interface.

### Signature
`ei_device.interface(object, interface_name, version)`

### Parameters
- **object** (new_id) - The new interface object.
- **interface_name** (string) - The interface name.
- **version** (uint32) - The interface version.
```

--------------------------------

### liboeffis DBus Interaction Flow

Source: https://libinput.pages.freedesktop.org/libei/libraries/index.html

This sequence diagram illustrates the simplified process of how liboeffis interacts with the XDG Desktop Portal and EIS implementation to establish a connection for libei.

```sequenceDiagram
sequenceDiagram participant libei participant liboeffis participant portal as XDG Desktop Portal participant eis as EIS implementation liboeffis ->> portal: CreateSession portal ->> eis: CreateSession eis -->> portal: fd portal -->> liboeffis: fd liboeffis -->> libei: take fd for libei context libei ->> eis: setup connection libei ->> eis: emulate events
```

--------------------------------

### eis_device_resume

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-device.html

Resumes event processing for the device.

```APIDOC
## void eis_device_resume(struct eis_device *device)

### Description
Notifies the client that the capabilities are resumed and that events from the device will be processed.

### Parameters
- **device** (struct eis_device *) - A connected device
```

--------------------------------

### eis_device_configure_name

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-device.html

Sets the name of the device.

```APIDOC
## void eis_device_configure_name(struct eis_device *device, const char *name)

### Description
Sets the name for the specified device.
```

--------------------------------

### oeffis_create_session

Source: https://libinput.pages.freedesktop.org/libei/api/liboeffis_8h.html

Connects the oeffis instance to a RemoteDesktop session with the specified device mask. This function initiates the connection to the XDG RemoteDesktop portal.

```APIDOC
## oeffis_create_session

### Description
Connect this oeffis instance to a RemoteDesktop session with the given device mask selected.

### Signature
void oeffis_create_session (struct oeffis *oeffis, uint32_t devices)

### Parameters
* **oeffis** (struct oeffis *) - Required - A pointer to the oeffis context.
* **devices** (uint32_t) - Required - The bitmask of devices to request. See oeffis_device enumeration.
```

--------------------------------

### OEFFIS_DEVICE_ALL_DEVICES

Source: https://libinput.pages.freedesktop.org/libei/api/globals_o.html

An enumerator or constant representing all available devices in Oeffis.

```APIDOC
## OEFFIS_DEVICE_ALL_DEVICES

### Description
An enumerator or constant representing all available devices in Oeffis.

### Method
Not applicable (constant/enum)

### Endpoint
Not applicable (constant/enum)

### Parameters
None explicitly documented in this section.

### Request Example
None available.

### Response
None explicitly documented in this section.

### Response Example
None available.
```

--------------------------------

### Event Dispatching

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h_source.html

Functions for handling the event loop and retrieving events from the library.

```APIDOC
## ei_dispatch
void ei_dispatch(struct ei *ei)
Main event dispatching function.

## ei_get_fd
int ei_get_fd(struct ei *ei)
Returns the file descriptor used for all events.

## ei_peek_event
struct ei_event * ei_peek_event(struct ei *ei)
Returns the next event in the internal event queue without removing it.
```

--------------------------------

### ei_new_sender

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei-sender.html

Creates a new sender client instance. This function is required to initialize a client that intends to send emulated input events.

```APIDOC
## ei_new_sender

### Description
Creates a new sender client instance. This function is the entry point for clients that need to act as input senders.

### Signature
struct ei *ei_new_sender(void *user_data);
```

--------------------------------

### Synchronize with EIS

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_connection/index.html

Use ei_connection.sync to ensure all previous requests and their resulting events have been processed by the EIS implementation. Requires the ei_callback interface to be supported.

```c
ei_connection.sync(callback, version)
```

--------------------------------

### eis_keymap_add

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-keymap.html

Sets the keymap on the device. This function must be called before eis_device_add().

```APIDOC
## void eis_keymap_add(struct eis_keymap *keymap)

### Description
Set the keymap on the device. The keymap is constant for the lifetime of the device. This function has no effect if called after eis_device_add().

### Parameters
- **keymap** (struct eis_keymap *) - The keymap to assign to the device.
```

--------------------------------

### oeffis_new

Source: https://libinput.pages.freedesktop.org/libei/api/globals_o.html

Creates a new Oeffis instance. This is likely an initialization function.

```APIDOC
## oeffis_new

### Description
Creates a new Oeffis instance.

### Method
Not applicable (function signature)

### Endpoint
Not applicable (function signature)

### Parameters
None explicitly documented in this section.

### Request Example
None available.

### Response
None explicitly documented in this section.

### Response Example
None available.
```

--------------------------------

### Pointer and Scroll Events

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei-sender.html

Functions for generating pointer motion and scroll events.

```APIDOC
## void ei_device_pointer_motion(struct ei_device *device, double x, double y)
Generate a relative motion event on a device with the EI_DEVICE_CAP_POINTER capability.

## void ei_device_pointer_motion_absolute(struct ei_device *device, double x, double y)
Generate an absolute motion event on a device with the EI_DEVICE_CAP_POINTER_ABSOLUTE capability.

## void ei_device_scroll_delta(struct ei_device *device, double x, double y)
Generate a smooth (pixel-precise) scroll event on a device with the EI_DEVICE_CAP_SCROLL capability.
```

--------------------------------

### Include libeis header

Source: https://libinput.pages.freedesktop.org/libei/api/structeis.html

Include this header to access the libeis server API functionality.

```c
#include <libeis.h>
```

--------------------------------

### eis_client_connect

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis.html

Allows a connection from the specified client.

```APIDOC
## void eis_client_connect (struct eis_client *client)

### Description
Allow connection from the client.
```

--------------------------------

### ei_keymap_get_fd

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei-keymap.html

Returns a memmap-able file descriptor pointing to the keymap used by the device.

```APIDOC
## int ei_keymap_get_fd(struct ei_keymap *keymap)

### Description
Returns a memmap-able file descriptor pointing to the keymap used by the device. The keymap is constant for the lifetime of the device and assigned to this device individually.
```

--------------------------------

### eis_event_text_get_keysym()

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-sender.html

Retrieves the XKB-compatible keysym for an EIS_EVENT_TEXT_KEYSYM event.

```APIDOC
## uint32_t eis_event_text_get_keysym(struct eis_event *event)

### Description
For an event of type EIS_EVENT_TEXT_KEYSYM, this function returns the XKB-compatible keysym.

### Parameters
- **event** (struct eis_event *) - The event to query.
```

--------------------------------

### ei_device_touch_new

Source: https://libinput.pages.freedesktop.org/libei/api/libei_8h.html

Initiates a new touch on a device with the EI_DEVICE_CAP_TOUCH capability.

```APIDOC
## struct ei_touch * ei_device_touch_new (struct ei_device *device)

### Description
Initiate a new touch on a device with the EI_DEVICE_CAP_TOUCH capability.
```

--------------------------------

### eis_keymap_get_device

Source: https://libinput.pages.freedesktop.org/libei/api/group__libeis-keymap.html

Retrieves the device associated with the given keymap.

```APIDOC
## struct eis_device * eis_keymap_get_device(struct eis_keymap *keymap)

### Description
Return the device this keymap belongs to.

### Parameters
- **keymap** (struct eis_keymap *) - The keymap to query.

### Returns
- **struct eis_device*** - The device associated with the keymap.
```

--------------------------------

### Announce Interface Version

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_handshake/index.html

Clients use this request to inform the EIS implementation about the interfaces they support and the maximum version number for each. This must be sent before ei_handshake.finish and not for the 'ei_connection' interface.

```C
ei_handshake.interface_version(name, version)
```

--------------------------------

### ei_device.name

Source: https://libinput.pages.freedesktop.org/libei/interfaces/ei_device/index.html

Provides the name of the device.

```APIDOC
## ei_device.name

### Description
Provides the name of the device. This event is optional and sent once immediately after object creation.

### Parameters
- **name** (string) - The device name.
```

--------------------------------

### ei_configure_name

Source: https://libinput.pages.freedesktop.org/libei/api/group__libei.html

Sets the client name for the libei connection.

```APIDOC
## void ei_configure_name(struct ei *ei, const char *name)

### Description
Set the name for this client. This is a suggestion to the server only and may not be honored. The client name may be used for display to the user, for example in an authorization dialog that requires the user to approve a connection to the EIS implementation. This function must be called immediately after ei_new() and before setting up a backend with ei_setup_backend_fd() or ei_setup_backend_socket().
```
Tokens:
Raw