Aprende cómo el código que interactúa con dispositivos externos se puede portar a la Web con las APIs de WebAssembly y Fugu.
En una publicación anterior, mostré cómo transferir apps que usan APIs de sistema de archivos a la Web con la API de File System Access, WebAssembly y Asyncify. Ahora quiero continuar con el mismo tema de integrar las APIs de Fugu con WebAssembly y portar apps a la Web sin perder funciones importantes.
Mostraré cómo las apps que se comunican con dispositivos USB se pueden portar a la Web portando libusb, una biblioteca USB popular escrita en C, a WebAssembly (a través de Emscripten), Asyncify y WebUSB.
Primero, lo primero: una demostración
Lo más importante que debes hacer cuando portas una biblioteca es elegir la demostración correcta, algo que muestre las capacidades de la biblioteca portada, que te permita probarla de varias maneras y que, al mismo tiempo, sea visualmente atractiva.
La idea que elegí fue el control remoto de la DSLR. En particular, un proyecto de código abierto, gPhoto2, lleva el tiempo suficiente en este espacio como para aplicar ingeniería inversa y compatibilidad con una amplia variedad de cámaras digitales. Admite varios protocolos, pero el que más me interesaba era la compatibilidad con USB, que realiza a través de libusb.
Describiré los pasos para compilar esta demostración en dos partes. En esta entrada de blog, describiré cómo porté libusb y qué trucos podrían ser necesarios para portar otras bibliotecas populares a las APIs de Project Fugu. En la segunda publicación, detallaré la portabilidad y la integración de gPhoto2.
Al final, obtuve una aplicación web en funcionamiento que muestra una vista previa del feed en vivo de una DSLR y puede controlar su configuración a través de USB. No dudes en consultar la demostración en vivo o pregrabada antes de leer los detalles técnicos:
Nota sobre las peculiaridades específicas de la cámara
Es posible que hayas notado que cambiar la configuración lleva un tiempo en el video. Al igual que con la mayoría de los demás problemas que podrías ver, esto no se debe al rendimiento de WebAssembly o WebUSB, sino a la forma en que gPhoto2 interactúa con la cámara específica elegida para la demostración.
La Sony a6600 no expone una API para establecer valores como ISO, apertura o velocidad de obturación directamente, sino que solo proporciona comandos para aumentarlos o disminuirlos según la cantidad de pasos especificada. Para complicar aún más las cosas, tampoco devuelve una lista de los valores admitidos, ya que la lista que se devuelve parece estar codificada en muchos modelos de cámaras Sony.
Cuando se establece uno de esos valores, gPhoto2 no tiene otra opción que hacer lo siguiente:
- Da un paso (o algunos) en la dirección del valor elegido.
- Espera un momento a que la cámara actualice la configuración.
- Lee el valor en el que se detuvo la cámara.
- Verifica que el último paso no haya omitido el valor deseado ni haya vuelto al final o al principio de la lista.
- y repite
Puede tardar un poco, pero si la cámara realmente admite el valor, lo alcanzará; de lo contrario, se detendrá en el valor admitido más cercano.
Es probable que otras cámaras tengan diferentes conjuntos de parámetros de configuración, APIs subyacentes y peculiaridades. Ten en cuenta que gPhoto2 es un proyecto de código abierto, y que no es posible realizar pruebas automatizadas ni manuales de todos los modelos de cámaras que existen, por lo que siempre se agradecen los informes de problemas detallados y las solicitudes de extracción (pero asegúrate de reproducir primero los problemas con el cliente oficial de gPhoto2).
Notas importantes sobre la compatibilidad multiplataforma
Lamentablemente, en Windows, a cualquier dispositivo "conocido", incluidas las cámaras DSLR, se le asigna un controlador del sistema, que no es compatible con WebUSB. Si quieres probar la demostración en Windows, deberás usar una herramienta como Zadig para anular el controlador de la DSLR conectada a WinUSB o libusb. Este enfoque funciona bien para mí y para muchos otros usuarios, pero debes usarlo bajo tu propia responsabilidad.
En Linux, es probable que debas establecer permisos personalizados para permitir el acceso a tu DSLR a través de WebUSB, aunque esto depende de tu distribución.
En macOS y Android, la demostración debería funcionar de inmediato. Si lo pruebas en un teléfono Android, asegúrate de cambiar al modo horizontal, ya que no me esforcé mucho en hacerlo responsivo (¡las solicitudes de extracción son bienvenidas!):
Para obtener una guía más detallada sobre el uso multiplataforma de WebUSB, consulta la sección "Consideraciones específicas de la plataforma" de "Cómo compilar un dispositivo para WebUSB".
Agrega un backend nuevo a libusb
Ahora, pasemos a los detalles técnicos. Si bien es posible proporcionar una API de corrección similar a libusb (otras personas ya lo hicieron) y vincular otras aplicaciones con ella, este enfoque es propenso a errores y dificulta cualquier extensión o mantenimiento posterior. Quería hacer las cosas bien, de una manera que pudiera contribuir potencialmente a la cadena de suministro y fusionarse con libusb en el futuro.
Por suerte, el archivo README de libusb dice lo siguiente:
“libusb se abstrae internamente de tal manera que, con suerte, se puede portar a otros sistemas operativos. Consulta el archivo PORTING para obtener más información”.
libusb está estructurada de manera que la API pública está separada de los "backends". Esos backends son responsables de enumerar, abrir, cerrar y comunicarse con los dispositivos a través de las APIs de bajo nivel del sistema operativo. Así es como libusb ya abstrae las diferencias entre Linux, macOS, Windows, Android, OpenBSD/NetBSD, Haiku y Solaris, y funciona en todas estas plataformas.
Lo que tuve que hacer fue agregar otro backend para el "sistema operativo" de Emscripten y WebUSB. Las implementaciones de esos backends se encuentran en la carpeta libusb/os:
~/w/d/libusb $ ls libusb/os
darwin_usb.c haiku_usb_raw.h threads_posix.lo
darwin_usb.h linux_netlink.c threads_posix.o
events_posix.c linux_udev.c threads_windows.c
events_posix.h linux_usbfs.c threads_windows.h
events_posix.lo linux_usbfs.h windows_common.c
events_posix.o netbsd_usb.c windows_common.h
events_windows.c null_usb.c windows_usbdk.c
events_windows.h openbsd_usb.c windows_usbdk.h
haiku_pollfs.cpp sunos_usb.c windows_winusb.c
haiku_usb_backend.cpp sunos_usb.h windows_winusb.h
haiku_usb.h threads_posix.c
haiku_usb_raw.cpp threads_posix.h
Cada backend incluye el encabezado libusbi.h con tipos y asistentes comunes, y debe exponer una variable usbi_backend de tipo usbi_os_backend. Por ejemplo, así se ve el backend de Windows:
const struct usbi_os_backend usbi_backend = {
"Windows",
USBI_CAP_HAS_HID_ACCESS,
windows_init,
windows_exit,
windows_set_option,
windows_get_device_list,
NULL, /* hotplug_poll */
NULL, /* wrap_sys_device */
windows_open,
windows_close,
windows_get_active_config_descriptor,
windows_get_config_descriptor,
windows_get_config_descriptor_by_value,
windows_get_configuration,
windows_set_configuration,
windows_claim_interface,
windows_release_interface,
windows_set_interface_altsetting,
windows_clear_halt,
windows_reset_device,
NULL, /* alloc_streams */
NULL, /* free_streams */
NULL, /* dev_mem_alloc */
NULL, /* dev_mem_free */
NULL, /* kernel_driver_active */
NULL, /* detach_kernel_driver */
NULL, /* attach_kernel_driver */
windows_destroy_device,
windows_submit_transfer,
windows_cancel_transfer,
NULL, /* clear_transfer_priv */
NULL, /* handle_events */
windows_handle_transfer_completion,
sizeof(struct windows_context_priv),
sizeof(union windows_device_priv),
sizeof(struct windows_device_handle_priv),
sizeof(struct windows_transfer_priv),
};
Si revisamos las propiedades, podemos ver que la estructura incluye el nombre del backend, un conjunto de sus capacidades, controladores para varias operaciones USB de bajo nivel en forma de punteros de función y, por último, tamaños que se asignarán para almacenar datos privados a nivel de dispositivo, contexto o transferencia.
Los campos de datos privados son útiles, al menos, para almacenar identificadores del SO para todos esos elementos, ya que, sin identificadores, no sabemos a qué elemento se aplica una operación determinada. En la implementación web, los controladores del SO serían los objetos de JavaScript de WebUSB subyacentes. La forma natural de representarlos y almacenarlos en Emscripten es a través de la clase emscripten::val, que se proporciona como parte de Embind (el sistema de vinculaciones de Emscripten).
La mayoría de los backends de la carpeta se implementan en C, pero algunos se implementan en C++. Embind solo funciona con C++, por lo que la elección se hizo por mí y agregué libusb/libusb/os/emscripten_webusb.cpp con la estructura requerida y con sizeof(val) para los campos de datos privados:
#include <emscripten.h>
#include <emscripten/val.h>
#include "libusbi.h"
using namespace emscripten;
// …function implementations
const usbi_os_backend usbi_backend = {
.name = "Emscripten + WebUSB backend",
.caps = LIBUSB_CAP_HAS_CAPABILITY,
// …handlers—function pointers to implementations above
.device_priv_size = sizeof(val),
.transfer_priv_size = sizeof(val),
};
Almacena objetos de WebUSB como identificadores de dispositivos
libusb proporciona punteros listos para usar al área asignada para los datos privados. Para trabajar con esos punteros como instancias de val, agregué pequeños ayudantes que los construyen in situ, los recuperan como referencias y mueven los valores hacia afuera:
// We store an Embind handle to WebUSB USBDevice in "priv" metadata of
// libusb device, this helper returns a pointer to it.
struct ValPtr {
public:
void init_to(val &&value) { new (ptr) val(std::move(value)); }
val &get() { return *ptr; }
val take() { return std::move(get()); }
protected:
ValPtr(val *ptr) : ptr(ptr) {}
private:
val *ptr;
};
struct WebUsbDevicePtr : ValPtr {
public:
WebUsbDevicePtr(libusb_device *dev)
: ValPtr(static_cast<val *>(usbi_get_device_priv(dev))) {}
};
val &get_web_usb_device(libusb_device *dev) {
return WebUsbDevicePtr(dev).get();
}
struct WebUsbTransferPtr : ValPtr {
public:
WebUsbTransferPtr(usbi_transfer *itransfer)
: ValPtr(static_cast<val *>(usbi_get_transfer_priv(itransfer))) {}
};
APIs web asíncronas en contextos de C síncronos
Ahora se necesitaba una forma de controlar las APIs asíncronas de WebUSB en las que libusb espera operaciones síncronas. Para ello, podría usar Asyncify o, más específicamente, su integración de Embind a través de val::await().
También quería controlar correctamente los errores de WebUSB y convertirlos en códigos de error de libusb, pero, por el momento, Embind no tiene ninguna forma de controlar las excepciones de JavaScript ni los rechazos de Promise desde el lado de C++. Este problema se puede solucionar detectando un rechazo en el lado de JavaScript y convirtiendo el resultado en un objeto { error, value } que ahora se puede analizar de forma segura desde el lado de C++. Para ello, combiné la macro EM_JS y las APIs de Emval.to{Handle, Value}:
EM_JS(EM_VAL, em_promise_catch_impl, (EM_VAL handle), {
let promise = Emval.toValue(handle);
promise = promise.then(
value => ({error : 0, value}),
error => {
const ERROR_CODES = {
// LIBUSB_ERROR_IO
NetworkError : -1,
// LIBUSB_ERROR_INVALID_PARAM
DataError : -2,
TypeMismatchError : -2,
IndexSizeError : -2,
// LIBUSB_ERROR_ACCESS
SecurityError : -3,
…
};
console.error(error);
let errorCode = -99; // LIBUSB_ERROR_OTHER
if (error instanceof DOMException)
{
errorCode = ERROR_CODES[error.name] ?? errorCode;
}
else if (error instanceof RangeError || error instanceof TypeError)
{
errorCode = -2; // LIBUSB_ERROR_INVALID_PARAM
}
return {error: errorCode, value: undefined};
}
);
return Emval.toHandle(promise);
});
val em_promise_catch(val &&promise) {
EM_VAL handle = promise.as_handle();
handle = em_promise_catch_impl(handle);
return val::take_ownership(handle);
}
// C++ struct representation for {value, error} object from above
// (performs conversion in the constructor).
struct promise_result {
libusb_error error;
val value;
promise_result(val &&result)
: error(static_cast<libusb_error>(result["error"].as<int>())),
value(result["value"]) {}
// C++ counterpart of the promise helper above that takes a promise, catches
// its error, converts to a libusb status and returns the whole thing as
// `promise_result` struct for easier handling.
static promise_result await(val &&promise) {
promise = em_promise_catch(std::move(promise));
return {promise.await()};
}
};
Ahora, podría usar promise_result::await() en cualquier Promise que se devuelva de las operaciones de WebUSB y, luego, inspeccionar sus campos error y value por separado.
Por ejemplo, recuperar un val que representa un USBDevice de libusb_device_handle, llamar a su método open(), esperar su resultado y devolver un código de error como un código de estado de libusb se ve de la siguiente manera:
int em_open(libusb_device_handle *handle) {
auto web_usb_device = get_web_usb_device(handle->dev);
return promise_result::await(web_usb_device.call<val>("open")).error;
}
Enumeración de dispositivos
Por supuesto, antes de poder abrir cualquier dispositivo, libusb necesita recuperar una lista de los dispositivos disponibles. El backend debe implementar esta operación a través de un controlador get_device_list.
La dificultad es que, a diferencia de otras plataformas, no hay forma de enumerar todos los dispositivos USB conectados en la Web por motivos de seguridad. En cambio, el flujo se divide en dos partes. Primero, la aplicación web solicita dispositivos con propiedades específicas a través de navigator.usb.requestDevice(), y el usuario elige de forma manual qué dispositivo quiere exponer o rechaza el mensaje de permiso. Luego, la aplicación enumera los dispositivos ya aprobados y conectados a través de navigator.usb.getDevices().
Al principio, intenté usar requestDevice() directamente en la implementación del controlador get_device_list. Sin embargo, mostrar un mensaje de permiso con una lista de dispositivos conectados se considera una operación sensible y debe activarse por la interacción del usuario (como un clic en un botón de una página); de lo contrario, siempre devuelve una promesa rechazada. Es posible que las aplicaciones de libusb a menudo quieran mostrar una lista de los dispositivos conectados cuando se inicia la aplicación, por lo que usar requestDevice() no era una opción.
En cambio, tuve que dejar la invocación de navigator.usb.requestDevice() al desarrollador final y solo exponer los dispositivos ya aprobados de navigator.usb.getDevices():
// Store the global `navigator.usb` once upon initialisation.
thread_local const val web_usb = val::global("navigator")["usb"];
int em_get_device_list(libusb_context *ctx, discovered_devs **devs) {
// C++ equivalent of `await navigator.usb.getDevices()`.
// Note: at this point we must already have some devices exposed -
// caller must have called `await navigator.usb.requestDevice(...)`
// in response to user interaction before going to LibUSB.
// Otherwise this list will be empty.
auto result = promise_result::await(web_usb.call<val>("getDevices"));
if (result.error) {
return result.error;
}
auto &web_usb_devices = result.value;
// Iterate over the exposed devices.
uint8_t devices_num = web_usb_devices["length"].as<uint8_t>();
for (uint8_t i = 0; i < devices_num; i++) {
auto web_usb_device = web_usb_devices[i];
// …
*devs = discovered_devs_append(*devs, dev);
}
return LIBUSB_SUCCESS;
}
La mayor parte del código de backend usa val y promise_result de una manera similar a la que ya se mostró anteriormente. Hay algunos trucos más interesantes en el código de manejo de transferencia de datos, pero esos detalles de implementación son menos importantes para los fines de este artículo. Si te interesa, asegúrate de revisar el código y los comentarios en GitHub.
Cómo portar bucles de eventos a la Web
Otro aspecto de la portabilidad de libusb que quiero analizar es el manejo de eventos. Como se describió en el artículo anterior, la mayoría de las APIs en lenguajes de sistema como C son síncronas, y el control de eventos no es una excepción. Por lo general, se implementa a través de un bucle infinito que "sondea" (intenta leer datos o bloquea la ejecución hasta que haya datos disponibles) un conjunto de fuentes de E/S externas y, cuando al menos una de ellas responde, pasa eso como un evento al controlador correspondiente. Una vez que el controlador finaliza, el control vuelve al bucle y se detiene para realizar otro sondeo.
Este enfoque tiene un par de problemas en la Web.
En primer lugar, WebUSB no expone ni puede exponer identificadores sin procesar de los dispositivos subyacentes, por lo que sondearlos directamente no es una opción. En segundo lugar, libusb usa las APIs de eventfd y pipe para otros eventos, así como para controlar las transferencias en sistemas operativos sin controladores de dispositivos sin procesar, pero eventfd no se admite actualmente en Emscripten, y pipe, si bien se admite, actualmente no cumple con la especificación y no puede esperar eventos.
Por último, el mayor problema es que la Web tiene su propio bucle de eventos. Este bucle de eventos global se usa para cualquier operación de E/S externa (incluidos fetch(), temporizadores o, en este caso, WebUSB) y, además, invoca controladores de eventos o de Promise cada vez que finalizan las operaciones correspondientes. Ejecutar otro bucle de eventos infinito y anidado impedirá que el bucle de eventos del navegador progrese, lo que significa que no solo la IU dejará de responder, sino que el código nunca recibirá notificaciones de los mismos eventos de E/S que está esperando. Esto suele provocar un interbloqueo, y eso es lo que sucedió cuando intenté usar libusb en una demostración. La página se tildó.
Al igual que con otras E/S de bloqueo, para portar esos bucles de eventos a la Web, los desarrolladores deben encontrar una forma de ejecutarlos sin bloquear el subproceso principal. Una forma es refactorizar la aplicación para que controle los eventos de E/S en un subproceso independiente y pase los resultados de vuelta al principal. La otra es usar Asyncify para pausar el bucle y esperar eventos de forma no bloqueante.
No quería realizar cambios significativos en libusb ni en gPhoto2, y ya usé Asyncify para la integración de Promise, por lo que esa es la ruta que elegí. Para simular una variante de bloqueo de poll(), en la prueba de concepto inicial, usé un bucle como se muestra a continuación:
#ifdef __EMSCRIPTEN__
// TODO: optimize this. Right now it will keep unwinding-rewinding the stack
// on each short sleep until an event comes or the timeout expires.
// We should probably create an actual separate thread that does signaling
// or come up with a custom event mechanism to report events from
// `usbi_signal_event` and process them here.
double until_time = emscripten_get_now() + timeout_ms;
do {
// Emscripten `poll` ignores timeout param, but pass 0 explicitly just
// in case.
num_ready = poll(fds, nfds, 0);
if (num_ready != 0) break;
// Yield to the browser event loop to handle events.
emscripten_sleep(0);
} while (emscripten_get_now() < until_time);
#else
num_ready = poll(fds, nfds, timeout_ms);
#endif
Esto es lo que hace:
- Llama a
poll()para verificar si el backend ya informó algún evento. Si hay, el bucle se detiene. De lo contrario, la implementación depoll()de Emscripten se mostrará de inmediato con0. - Llamadas
emscripten_sleep(0). Esta función usa Asyncify ysetTimeout()de forma interna y se usa aquí para devolver el control al bucle de eventos principal del navegador. Esto permite que el navegador controle las interacciones del usuario y los eventos de E/S, incluida la WebUSB. - Verifica si el tiempo de espera especificado ya venció y, si no es así, continúa con el bucle.
Como se menciona en el comentario, este enfoque no era óptimo, ya que seguía guardando y restableciendo toda la pila de llamadas con Asyncify, incluso cuando aún no había eventos de USB para controlar (lo que ocurre la mayor parte del tiempo), y porque setTimeout() tiene una duración mínima de 4 ms en los navegadores actualizados. Aun así, funcionó lo suficientemente bien como para producir una transmisión en vivo de 13 a 14 FPS desde la DSLR en la prueba de concepto.
Más adelante, decidí mejorarlo aprovechando el sistema de eventos del navegador. Hay varias formas en las que se podría mejorar aún más esta implementación, pero, por ahora, elegí emitir eventos personalizados directamente en el objeto global, sin asociarlos con una estructura de datos de libusb en particular. Lo hice a través del siguiente mecanismo de espera y notificación basado en la macro EM_ASYNC_JS:
EM_JS(void, em_libusb_notify, (void), {
dispatchEvent(new Event("em-libusb"));
});
EM_ASYNC_JS(int, em_libusb_wait, (int timeout), {
let onEvent, timeoutId;
try {
return await new Promise(resolve => {
onEvent = () => resolve(0);
addEventListener('em-libusb', onEvent);
timeoutId = setTimeout(resolve, timeout, -1);
});
} finally {
removeEventListener('em-libusb', onEvent);
clearTimeout(timeoutId);
}
});
La función em_libusb_notify() se usa cada vez que libusb intenta informar un evento, como la finalización de la transferencia de datos:
void usbi_signal_event(usbi_event_t *event)
{
uint64_t dummy = 1;
ssize_t r;
r = write(EVENT_WRITE_FD(event), &dummy, sizeof(dummy));
if (r != sizeof(dummy))
usbi_warn(NULL, "event write failed");
#ifdef __EMSCRIPTEN__
em_libusb_notify();
#endif
}
Mientras tanto, la parte em_libusb_wait() se usa para "despertar" de la suspensión de Asyncify cuando se recibe un evento em-libusb o cuando vence el tiempo de espera:
double until_time = emscripten_get_now() + timeout_ms;
for (;;) {
// Emscripten `poll` ignores timeout param, but pass 0 explicitly just
// in case.
num_ready = poll(fds, nfds, 0);
if (num_ready != 0) break;
int timeout = until_time - emscripten_get_now();
if (timeout <= 0) break;
int result = em_libusb_wait(timeout);
if (result != 0) break;
}
Debido a la reducción significativa de las suspensiones y activaciones, este mecanismo solucionó los problemas de eficiencia de la implementación anterior basada en emscripten_sleep() y aumentó la capacidad de procesamiento de la demostración de DSLR de 13 a 14 FPS a más de 30 FPS constantes, lo que es suficiente para una transmisión en vivo fluida.
Sistema de compilación y la primera prueba
Después de que se completó el backend, tuve que agregarlo a Makefile.am y configure.ac. La única parte interesante aquí es la modificación de las marcas específicas de Emscripten:
emscripten)
AC_SUBST(EXEEXT, [.html])
# Note: LT_LDFLAGS is not enough here because we need link flags for executable.
AM_LDFLAGS="${AM_LDFLAGS} --bind -s ASYNCIFY -s ASSERTIONS -s ALLOW_MEMORY_GROWTH -s INVOKE_RUN=0 -s EXPORTED_RUNTIME_METHODS=['callMain']"
;;
Primero, los ejecutables en plataformas Unix normalmente no tienen extensiones de archivo. Sin embargo, Emscripten produce un resultado diferente según la extensión que solicites. Uso AC_SUBST(EXEEXT, …) para cambiar la extensión ejecutable a .html, de modo que cualquier ejecutable dentro de un paquete (pruebas y ejemplos) se convierta en un HTML con la shell predeterminada de Emscripten que se encarga de cargar y crear instancias de JavaScript y WebAssembly.
En segundo lugar, como uso Embind y Asyncify, necesito habilitar esas funciones (--bind -s ASYNCIFY) y permitir el crecimiento dinámico de la memoria (-s ALLOW_MEMORY_GROWTH) a través de los parámetros del vinculador. Lamentablemente, no hay forma de que una biblioteca informe esas marcas al vinculador, por lo que cada aplicación que use este puerto de libusb también tendrá que agregar las mismas marcas del vinculador a su configuración de compilación.
Por último, como se mencionó anteriormente, WebUSB requiere que la enumeración de dispositivos se realice a través de un gesto del usuario. Los ejemplos y las pruebas de libusb suponen que pueden enumerar dispositivos al inicio y fallan con un error sin cambios. En cambio, tuve que inhabilitar la ejecución automática (-s INVOKE_RUN=0) y exponer el método manual callMain() (-s EXPORTED_RUNTIME_METHODS=...).
Una vez hecho todo esto, pude entregar los archivos generados con un servidor web estático, inicializar WebUSB y ejecutar esos ejecutables HTML de forma manual con la ayuda de las Herramientas para desarrolladores.
![Captura de pantalla que muestra una ventana de Chrome con las Herramientas para desarrolladores abiertas en una página de "testlibusb" alojada de forma local. La consola de Herramientas para desarrolladores está evaluando "navigator.usb.requestDevice({ filters: [] })", lo que activó un mensaje de permiso y, en este momento, le solicita al usuario que elija un dispositivo USB que se deba compartir con la página. Actualmente, está seleccionada la ILCE-6600 (una cámara Sony).](https://web.dev/static/articles/porting-libusb-to-webusb/image/screenshot-showing-chrom-b19a9e4e1b916.png?hl=es)
![Captura de pantalla del siguiente paso, con las Herramientas para desarrolladores aún abiertas. Después de seleccionar el dispositivo, Console evaluó una nueva expresión `Module.callMain(['-v'])`, que ejecutó la app `testlibusb` en modo detallado. En el resultado, se muestra información detallada sobre la cámara USB conectada anteriormente: fabricante Sony, producto ILCE-6600, número de serie, configuración, etcétera.](https://web.dev/static/articles/porting-libusb-to-webusb/image/screenshot-the-next-step-bd4e4c7f85be7.png?hl=es)
No parece mucho, pero, cuando se portan bibliotecas a una plataforma nueva, llegar a la etapa en la que se produce un resultado válido por primera vez es bastante emocionante.
Usa el puerto
Como se mencionó anteriormente, la portabilidad depende de algunas funciones de Emscripten que, por el momento, deben habilitarse en la etapa de vinculación de la aplicación. Si quieres usar este puerto de libusb en tu propia aplicación, deberás hacer lo siguiente:
- Descarga la versión más reciente de libusb como un archivo como parte de tu compilación o agrégala como un submódulo de Git en tu proyecto.
- Ejecuta
autoreconf -fiven la carpetalibusb. - Ejecuta
emconfigure ./configure –host=wasm32 –prefix=/some/installation/pathpara inicializar el proyecto para la compilación cruzada y establecer una ruta de acceso en la que quieras colocar los artefactos compilados. - Ejecuta
emmake make install. - Dirige tu aplicación o biblioteca de nivel superior para buscar libusb en la ruta elegida anteriormente.
- Agrega las siguientes marcas a los argumentos de vinculación de tu aplicación:
--bind -s ASYNCIFY -s ALLOW_MEMORY_GROWTH.
Actualmente, la biblioteca tiene algunas limitaciones:
- No se admite la cancelación de transferencias. Esta es una limitación de WebUSB que, a su vez, se debe a la falta de cancelación de transferencias multiplataforma en libusb.
- No se admite la transferencia isócrona. No debería ser difícil agregarlo si se sigue la implementación de los modos de transferencia existentes como ejemplos, pero también es un modo un tanto inusual y no tenía ningún dispositivo para probarlo, por lo que, por ahora, lo dejé como no compatible. Si tienes esos dispositivos y quieres contribuir a la biblioteca, las solicitudes de extracción son bienvenidas.
- Las limitaciones multiplataforma mencionadas anteriormente Esas limitaciones las imponen los sistemas operativos, por lo que no hay mucho que podamos hacer aquí, excepto pedirles a los usuarios que anulen el controlador o los permisos. Sin embargo, si estás portando dispositivos HID o en serie, puedes seguir el ejemplo de libusb y portar alguna otra biblioteca a otra API de Fugu. Por ejemplo, podrías portar una biblioteca de C hidapi a WebHID y evitar por completo esos problemas asociados con el acceso USB de bajo nivel.
Conclusión
En esta publicación, mostré cómo, con la ayuda de las APIs de Emscripten, Asyncify y Fugu, incluso las bibliotecas de bajo nivel, como libusb, se pueden portar a la Web con algunos trucos de integración.
La portabilidad de estas bibliotecas de bajo nivel esenciales y de uso generalizado es particularmente gratificante, ya que, a su vez, permite llevar bibliotecas de nivel superior o incluso aplicaciones completas a la Web. Esto abre experiencias que antes estaban limitadas a los usuarios de una o dos plataformas, a todo tipo de dispositivos y sistemas operativos, lo que hace que esas experiencias estén disponibles con solo hacer clic en un vínculo.
En la próxima publicación, te guiaré por los pasos necesarios para compilar la demostración web de gPhoto2, que no solo recupera información del dispositivo, sino que también usa ampliamente la función de transferencia de libusb. Mientras tanto, espero que el ejemplo de libusb te haya resultado inspirador y que pruebes la demostración, juegues con la biblioteca o, tal vez, incluso portes otra biblioteca de uso generalizado a una de las APIs de Fugu.