---
title: SDK SmartPOS
slug: sdk-smartpos
description: Get a complete overview of the latest updates and changes to the card reader software development kit (SDK) in this comprehensive document. Discover the creation of new classes, methods, and interfaces, along with updates to existing ones. Learn about the
docTags:
createdAt: 2022-08-31T18:55:38.000Z
---
### Dispositivos Soportados
| Marca | Dispositivo | Sistema Operativo |
| ------------ | ------------ | ------------------ |
| Ingenico | DX8000 | Android 10 |
| Urovo | i9000 | Android 8.1 |
| Tap on Phone | Con NFC | Android > 10 |
### Versionado
| Versión | Fecha | Observaciones |
| ------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 0.1.0 | 25/07/2022 | - Creación de la Clase `CardReader`. Métodos:
- `CardReader(Context context)`
- `setCardReaderListener(CardReaderListener listener)`
- `getDeviceInfo()`
- `read()`
- Creación interfaz `CardReaderListener`. Funciones:
- `onConnection(Map event)`
- `onRead(Map event)`
- `onStatus(Map event)`
- Logs Genéricos.
- Creación de la Documentación. |
| 0.2.0 | 06/08/2022 | - Nuevos métodos en la clase `CardReader`:
- `isDeviceConnected()`
- `setMagStripe(Boolean boolean)`
- `setChip(Boolean boolean)`
- `setContactless(Boolean boolean)`
- Creación de la Clase `VectorPrinter`. Métodos:
- `VectorPrinter(Context context)`
- `addQrCode(String qrCode, Map parameters)`
- `addText(String text, Map parameters)`
- `addBitMap(BitMap bitMap)`
- `startPrint()`
- Creación interfaz `Aligments`. Opciones:
- `LEFT`
- `CENTER`
- `RIGHT`
- Creación interfaz `TextSize`. Opciones:
- `TINY`
- `SMALL`
- `NORMAL`
- `LARGE`
- `HUGE`
- Agregado de más códigos AID.
- Agregado de Logs.
- Formateo general de Documentación. |
| 0.3.0 | 18/08/2022 | - Nuevos métodos en la clase `CardReader`:
- `stopTasks()`
- `setReadRetries(int retries)`
- `readv2()` (beta)
- Se unifica la Clase `VectorPrinter` dentro de `CardReader`. Agregando los siguientes métodos:
- `initPrinter()`
- `setPrinterImage(BitMap bitMap)`
- `setPrinterBarcode(String barCode, Map parameters)`
- `setPrinterQr(String qrCode, Map parameters)`
- `setPrinterText(String text, Map parameters)`
- `setPrinterFeed(int feed)`
- `startPrint()`
- Ejecución de evento de tipo `CONNECTION` al finalizar la inicialización de la instancia `CardReader`.
- Formateo del objeto data en la respuesta de la lectura.
- Lógica de reintentos automáticos de lectura. |
| 0.4.0 | 26/08/2022 | - Se eliminan métodos en la clase `CardReader`:
- `readv2()`
- Creación de evento de tipo `PRINTER`, con sus valores posibles.
- Ejecución de evento de tipo `CARD` sugiriendo cambio de método de lectura. |
| 0.4.1 | 01/09/2022 | - Formateo del objeto data en la respuesta de la lectura.
- Se agrega explicación de respuesta de lectura. |
| 0.5.0 | 05/10/2022 | - Se eliminan métodos en la clase `CardReader`:
- `read()`
- Nuevos métodos en la clase `CardReader`
- `read(int amount, TRANSACTION_TYPE trxType)`
- `readAndProcess(int amount, TRANSACTION_TYPE trxType, int intentToken, int installments)`
- `processTRX(int intentToken, int installments)`
- `getCardReaderContext()`
- `setDebugMode(Boolean mode)`
- Actualización formato y documentación de eventos
- Se agrega la tabla `ENMUS`. Se crear nuevos `ENUMS`:
- `EVENT_TYPE`
- `READ_TYPE`
- `READER_EVENT`
- `TRANSACTION_TYPE`
- `ALIGNMENT`
- `TEXT_SIZE`
- `READER_ERROR`
- Se agrega apartado para instalar dependencia de librería.
- Se actualiza implementación general del SDK. |
| 0.6.0 | 19/10/2022 | - Se eliminan métodos en la clase `CardReader`:
- `setMagStripe(Boolean boolean)`
- `setChip(Boolean boolean)`
- `setContactless(Boolean boolean)`
- Nuevos métodos en la clase `CardReader`:
- Se agrega la opción `otherAmount` en los método `read()` y `readAndProcess()`.
- Actualización `ENUM` `READER_EVENT`:
- `CONNECTION_SEARCHING` -> `SEARCHING_DEVICES`
- `CONNECTION_SUCCESS` -> `READER_CONNECTED`
- `CARD_READING` -> `READING`
- `CARD_READ_SUCCESS` -> `READ_SUCCESS`
- `CARD_READ_RESTART` -> `READ_RESTART`
- `CARD_WAITING_PIN` -> `WAITING_PIN`
- `CARD_WAITING_AID` -> `WAITING_AID`
- `CARD_PROCESSING` -> `PROCESSING`
- `CARD_PROCESS_SUCCESS` -> `PROCESS_SUCCESS`
- `PRINTER_CONNECTION_SUCCESS` -> `PRINTER_CONNECTED`
- `PRINTER_PRINTING` -> `PRINTING`
- Nuevos `ENUM` dentro de `READER_EVENT`:
- `READ_FAIL`
- `WAITING_CHIP_TO_BE_REMOVED`
- `PROCESS_FAIL`
- `PROCESS_SECURITY_CODE_REQUIRED`
- `PRINTER_FAIL`
- Nuevo `ENUM` dentro de `READER_ERROR`:
- `EMV_CHIP_REMOVED`
- Se agregan ejemplos de lectura. |
| 0.6.1 | 20/10/2022 | - Nuevos `ENUM` dentro de `READER_EVENT`:
- `CDCVM_REQUIRED`
- `CDCVM_VERIFICATION_READY` |
| 0.7.0 | 27/01/2023 | - Se convierte todo objeto de clase `Map` en parámetro o respuesta, a objeto de clase `JSONObject`.
- Se actualiza el formato del objecto de respuesta exitosa de una lectura: se eliminan los campos `source.sourceData.expirationMonth` y `source.sourceData.expirationYear`.
- Se elimina la importación explícita de la librería `Volley`.
- Se agregan funcionalidades Debug Mode:
- Selección de Múltiples Aplicaciones.
- Método de verificación del tarjeta-habiente (CVM) |
| 0.8.0 | 13/06/2023 | - Nuevos métodos en la clase `CardReader`:
- `init()`
- `getDeviceSerialNumber()`
- `setPrinterMultipleColumnText(JSONArray columns, JSONObject parameters)`
- Se eliminan métodos en la clase `CardReader`:
- `getCardReaderContext()`
- `initPrinter()`. La inicialización del mismo se hace de manera automática.
- Nuevo `ENUM` dentro de `READER_EVENT`:
- `CONNECTION_FAILED`
- Nuevo `ENUM` dentro de `READER_ERROR`:
- `UNAUTHORIZED`
- `EMV_CHIP_REQUIRED`
- Se agrega el valor `cvvRequired` en la respuesta de la lectura.
- Se agrega documentación de los métodos:
- `selectApplication(String application)`
- `setPrinterOppositeText(String leftText, String rightText, JSONObject parameters)`
- Se actualiza nombre del método:
- `setCVMVerificationMode(Boolean mode)` -> `setDebugCVMVerificationMode(boolean mode)`
- `setPrinterFeed(int feed)` -> `setPrinterSeparator(int height)`
- `startPrint()` -> `print()`
- Se elimina el enum `READER_EVENT.PRINTER_CONNECTED`
- Se ofusca el código archivo `.arr`
- Se agrega el encendido automático de las luces en el proceso de pago
- Se reemplaza objecto `JSONObject` por objecto `MBBXJson` |
# Requerimientos para la conexión con SmartPOS
### A) Permisos de acceso:
En la aplicación Android no será necesario agregar permisos en el AndroidManifest.xml de manera previa.
Lo que sí será necesario, es agregar dentro del `tag` `- `READER_CONNECTED`
- `CONNECTION_FAILED`
- `ERROR` | `READER_EVENT`(enum) |
| `message` | Mensaje informativo sobre el evento emitido. | | `String` |
| `error`
(opcional) | Objeto informativo sobre el evento de error emitido. | | `SGWJson` |
### Valores Posibles de `type` en el evento `CONNECTION`
| Valor | Descripción |
| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `SEARCHING_DEVICES` | El lector se encuentra buscando dispositivos Bluetooth a enlazar. |
| `READER_CONNECTED` | El dispositivo finalizó su conexión con éxito. |
| `CONNECTION_FAILED` | Se produjo un error en la inicialización, ya sea por no tener un dispositivo actualizado, habilitado o fuera de conexión. |
| `ERROR` | Se produjo un error al procesar alguna solicitud, como por ejemplo, querer obtener la información del dispositivo mientras el mismo está ocupado o no conectado. |
### onCard
La función `onCard`, recibe todo evento `EVENT_TYPE` de tipo `CARD`. Se utiliza para indicar cuando el dispositivo está listo para leer la tarjeta o para cuando ha finalizado de leerla, ya sea que la lectura haya sido exitosa o errónea. También indica si el procesamiento de la transacción está a la espera, en curso o finalizada. Esta función recibe un objeto `event` de tipo `SGWJson` que tiene las siguientes propiedades:
| Nombre | Descripción | Valores Posibles | Tipo |
| ------------------ | ----------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------- |
| `type` | Tipo de evento emitido | - `READING`
- `CARD_DETECTED`
- `READ_SUCCESS`
- `READ_RESTART`
- `READ_FAIL`
- `WAITING_CHIP_TO_BE_REMOVED`
- `WAITING_PIN`
- `WAITING_AID`
- `CDCVM_REQUIRED`
- `CDCVM_VERIFICATION_READY`
- `PROCESSING`
- `PROCESS_SUCCESS`
- `PROCESS_FAIL`
- `PROCESS_SECURITY_CODE_REQUIRED`
- `ERROR` | `READER_EVENT`(enum) |
| `message` | Mensaje informativo sobre el evento emitido. | | `String` |
| `data` | Información adicional necesaria en el evento. Para el caso de `READ_SUCCESS`, ver *"Respuesta de Lectura"*. | | `SGWJson` |
| `error` (opcional) | Objeto informativo sobre el evento de error emitido. | | `SGWJson` |
### Valores Posibles de `type` en el evento `CARD`
| Valor | Descripción |
| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| `READING` | El dispositivo está listo y a la espera para realizar la lectura de la tarjeta. |
| `CARD_DETECTED` | Se ha detectado una tarjeta. |
| `READ_SUCCESS` | La lectura de la tarjeta ha finalizado con éxito. |
| `READ_RESTART` | Reintento automático de lectura, por alguna falla en la misma. |
| `READ_FAIL` | La lectura de la tarjeta ha finalizado con error. |
| `WAITING_CHIP_TO_BE_REMOVED` | La lectura detectó un error en el chip, y debe ser retirado para continuar. |
| `WAITING_PIN` | Lector a la espera de ingreso de PIN. |
| `WAITING_AID` | Lector a la espera de selección de aplicación. |
| `CDCVM_REQUIRED` | *Cardholder Verification Method.* El lector a la espera de que el CardHolder Verifique. |
| `CDCVM_VERIFICATION_READY` | El lector se encuentra nuevamente listo para leer la verificación del CardHolder. |
| `PROCESSING` | La transacción comenzó a procesarse. |
| `PROCESS_SUCCESS` | El procesamiento de la transacción finalizó con éxito. |
| `PROCESS_FAIL` | El procesamiento de la transacción finalizó con error. |
| `PROCESS_SECURITY_CODE_REQUIRED` | Error en el procesamiento de la transacción. Indica la necesidad de enviar el código de seguridad (CVV) para procesar. |
| `ERROR` | Se produjo algún error específico o excepción. |
### onStatus
La función `onStatus`, recibe todo evento `EVENT_TYPE` de tipo `INFO`. Se utiliza para retornar información del dispositivo. Esta función recibe un objeto `event` de tipo `SGWJson` que tiene las siguientes propiedades:
| Nombre | Descripción | Valores Posibles | Tipo |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------- | -------------------- |
| `type` | Tipo de evento emitido | - `DEVICE_INFO`
- `LOG_REPORT`
- `ERROR` | `READER_EVENT`(enum) |
| `message` | Mensaje informativo sobre el evento emitido. | | `String` |
| `data` | Objeto que contiene la información obtenida del dispositivo: serialNumber, model, manufacture, IMSI, IMEI, ICCID, ROMVersion, androidKernelVersion, androidOSVersion, firmwareVersion, hardwareVersion, hardwareSerialNumber, mode, isOvsTerm, CSN, productName, processorInfo, basebandVersion, bootVersion, buildNumber, payComponentVersion, secfwVersion, pn, terminalType, extDeviceVersion. | | `SGWJson` |
| `error` (opcional) | Objeto informativo sobre el evento de error emitido. | | `SGWJson` |
### Valores Posibles de `type` en el evento `INFO`
| Valor | Descripción |
| ------------- | ----------------------------------------------------------- |
| `DEVICE_INFO` | Lectura de información del dispositivo exitosa. |
| `LOG_REPORT` | El envío del reporte solicitado, ah sido enviado con éxito. |
| `ERROR` | Se produjo algún error específico o excepción. |
### onPrinter
La función `onPrinter`, recibe todo evento `EVENT_TYPE` de tipo `PRINTER`. Se utiliza para indicar resultados de inicialización del Printer y cambios de estado en la ejecución de la impresión. Esta función recibe un objeto `event` de tipo `MBBXJson` que tiene las siguientes propiedades:
| Nombre | Descripción | Valores Posibles | Tipo |
| ------------------ | ---------------------------------------------------- | -------------------------------------------------------------------------- | --------------------- |
| `type` | Indica el estado actual de la impresión. | - `PRINTING`
- `PRINTER_SUCCESS`
- `PRINTER_FAIL`
- `ERROR` | `READER_EVENT` (enum) |
| `message` | Mensaje informativo sobre el evento emitido. | | `String` |
| `error` (opcional) | Objeto informativo sobre el evento de error emitido. | | `MBBXJson` |
### Valores Posibles de `type` en el evento `PRINTER`
| Valor | Descripción |
| ----------------- | ------------------------------------------------------------------- |
| `PRINTING` | El módulo `Printer` dentro del SDK comenzó a imprimir. |
| `PRINTER_SUCCESS` | El módulo `Printer` dentro del SDK finalizó la impresión con éxito. |
| `PRINTER_FAIL` | El módulo `Printer` dentro del SDK finalizó la impresión con error. |
| `ERROR` | Se produjo algún error específico o excepción. |
#
# CardReader
Clase utilizada para toda lógica de conexión y funcionamiento del SDK en los SmartPOS.
## Métodos
La siguiente tabla indica los distintos métodos de la clase:
| Metodos | Descripción | Tipo |
| ---------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
| `CardReader(Context context)` | Inicializador de una nueva instancia de la clase `CardReader`. Necesario el parámetro `context`. Ver *`onConnection`.* | `void` |
| `init()` | Permite re-inicializar la instancia `CardReader`. Si la instancia se encuentra ya inicializada correctamente, retornará automáticamente el evento de tipo `READER_CONNECTED`. | `void` |
| `setCardReaderListener(CardReaderListener listener)` | Permite configurar el listener necesario para obtener toda respuesta asíncrona del SDK. Necesario el parámetro `listener`. | `void` |
| `isDeviceConnected()` | Retorna el estado de conexión actual de la instancia `CardReader`. Solo retorna `true` en caso de estar exitosamente conectado a algún SmartPOS posible. | `boolean` |
| `getDeviceInfo()` | Comienza lógica para obtener toda información del SmartPOS. Ver *`onStatus`.* | `void` |
| `getDeviceSerialNumber()` | Retorna el `serialNumber` específico del SmartPOS actualmente conectado. | `String` |
| `read(int amount, int otherAmount, TRANSACTION_TYPE trxType)` | Comienza lógica para lectura en el SmartPOS. Necesario el parámetro `amount`. Valores por defecto: `otherAmount` (0), `trxType` (SALE). Ver *`onCard`*. | `void` |
| `readAndProcess(int amount, int otherAmount, TRANSACTION_TYPE trxType, int intentToken, int installments)` | Comienza lógica para lectura y procesamiento de la transacción en el SmartPOS. Necesario los parámetros `amount`, `intentToken` e `installments`. Valores por defecto: `otherAmount` (0), `trxType` (SALE). Ver *`onCard`.* | `void` |
| `processTRX(int intentToken, int installments, String securityCode)` | Comienza lógica para el procesamiento de la transacción en el SmartPOS. Necesario los parámetros `intentToken` e `installments`. Valores por defecto: `securityCode` (null). Ver *`onCard`.* | `void` |
| `processTRX(int intentToken, String installmentsReference, String securityCode)` | Comienza lógica para el procesamiento de la transacción en el SmartPOS. Necesario los parámetros `intentToken` e `installmentsReference`. Valores por defecto: `securityCode` (null). Ver *`onCard`.* | `void` |
| `stopTasks()` | Métodos como `read()` inicializan instancias nativas del lector que deben ser cerradas luego de cada lectura. Este método permite forzar el cierre de una lectura de manera segura, para los casos en donde el cliente tenga alguna falla externa o quiera finalizar una lectura antes de tiempo. | `void` |
| `release()` | Método que permite desvincular la instancia CardReader existente de manera segura. Al desvincular, detiene toda funcionalidad que esté realizando y es posible su utilización hasta nueva inicialización. | `void` |
| `setReadRetries(int retries)` | Configura en el SDK la cantidad de reintentos que tiene el método `read()`. Necesario el parámetro `retries`. De configurar `retries` en 0, el SDK no realizará reintentos. Previo a cada reintento, se ejecuta un evento de tipo `CARD` para informar a la aplicación el motivo del fallo de la lectura. **Por defecto, el SDK se configura con un valor de 2 reintentos**. | `void` |
| `setDebugMode(boolean mode)` | Configura al SDK en modo debug. Genera logs extras para debugear funcionamiento. Por defecto, el SDK se configura con un valor de `false`. | `void` |
| `setDebugMultipleApplicationMode(boolean mode)` | Fuerza en el SDK la ejecución del evento `READER_EVENT.WAITING_AID` para simular su comportamiento. **Esto es posible solo si el modo debug está en `true` y solo en lecturas Chip.** | `void` |
| `setDebugCVMVerificationMode(boolean mode)` | Fuerza en el SDK la ejecución del evento `READER_EVENT.CDCVM_REQUIRED` y `READER_EVENT.CDCVM_VERIFICATION_READY`, para simular su comportamiento. **Esto es posible solo si el modo debug está en `true` y solo en lecturas Contactless.** | `void` |
| `selectApplication(String application)` | Confirma la Aplicación seleccionada, del listado provisto por el SDK. | `void` |
| `setPrinterImage(BitMap bitMap)` | Agrega una Imagen en la impresión del ticket. Necesario el parámetro `bitMap`. | `void` |
| `setPrinterBarcode(String barCode, MBBXJson parameters)` | Agrega una imagen configurable de código de barras en la impresión del ticket. Necesario el parámetro `barCode`. Opcional el parámetro `parameters`. *(ver Parámetros del Printer)* | `void` |
| `setPrinterQr(String qrCode, MBBXJson parameters)` | Agrega una imagen de código QR en la impresión del ticket. Necesario el parámetro `qrCode`. Opcional el parámetro `parameters`. *(ver Parámetros del Printer)* | `void` |
| `setPrinterText(String text, MBBXJson parameters)` | Agrega un Texto en la impresión del ticket. Necesario el parámetro `text`. Opcional el parámetro `parameters`. *(ver Parámetros del Printer)* | `void` |
| `setPrinterOppositeText(String leftText, String rightText), MBBXJson parameters)` | Agrega 2 Textos en una misma lineas en la impresión del ticket. Necesario los parámetros `leftText` y `rightText`. Opcional el parámetro `parameters`. *(ver Parámetros del Printer)* | `void` |
| `setPrinterMultipleColumnText(JSONArray columns, MBBXJson parameters)` | Agrega tantos textos en una misma linea como cantidad de items en `columns`. Necesario el parámetro `columns`. Opcional el parámetro `parameters`. *(ver Parámetros del Printer)*
En cada item del array, permite configurar:
- `text` (`String` obligatorio): texto a mostrar.
- `size` (int opcional): Tamaño de la columna a ocupar en el renglón de impresión. Valor por defecto 1.
- `alignment` (`ALIGNMENT` opcional): Alineación del texto dentro de su propia columna. Valor por defecto `LEFT`.
La línea no posee un tamaño de columna específico. Irá tomando un tamaño dinámico según la cantidad de columnas posea. El texto de no exceder el ancho de la columna, se mostrará en dos o más renglones. | `void` |
| `setPrinterSeparator(int height)` | Agrega un espacio en blanco en la impresión del ticket del tamaño indicado. Necesario el parámetro `height`. | `void` |
| `print()` | Comienza lógica para comenzar la impresión del ticket, según lo configurado anteriormente. Luego de cada impresión, las distas configuraciones agregadas en el printer se borrarán. | `void` |
## ENUMS
Los siguientes `enums` existen en el SDK Mobbex. Permiten verificar eventos o configurar distintos parámetros según corresponda.
| ENUM | Descripción | Valores Posibles |
| ------------------ | --------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `EVENT_TYPE` | Tipos de eventos a ejecutarse desde el SDK Mobbex a la App. | - `CONNECTION`
- `CARD`
- `INFO`
- `PRINTER` |
| `READ_TYPE` | Tipos de lecturas posibles en el SmartPOS. | - `MAGSTRIPE`
- `EMV_CHIP`
- `EMV_CONTACTLESS` |
| `READER_EVENT` | Tipos de eventos posibles a recibir desde el SDK Mobbex a la App. Ver *`CardReaderListener`*. | - `SEARCHING_DEVICES`
- `READER_CONNECTED`
- `CONNECTION_FAILED`
- `READING`
- `CARD_DETECTED`
- `READ_SUCCESS`
- `READ_RESTART`
- `READ_FAIL`
- `WAITING_CHIP_TO_BE_REMOVED`
- `WAITING_PIN`
- `WAITING_AID`
- `CDCVM_REQUIRED`
- `CDCVM_CHECK_READY`
- `PROCESSING`
- `PROCESS_SUCCESS`
- `PROCESS_FAIL`
- `PROCESS_SECURITY_CODE_REQUIRED`
- `DEVICE_INFO`
- `PRINTING`
- `PRINTER_SUCCESS`
- `PRINTER_FAIL`
- `ERROR` |
| `TRANSACTION_TYPE` | Tipos de lecturas y procesamientos soportados en el SmarPOS. | - `SALE`
- `CASHBACK`
- `REFUND` |
| `ALIGNMENT` | Parámetro de alineamiento a configurar dentro del ticket, en: Texto, código QR, Imagen. | - `LEFT`
- `CENTER`
- `RIGHT` |
| `TEXT_SIZE` | Parámetro de tamaño de Texto a utilizar. | - `TINY`
- `SMALL`
- `NORMAL`
- `LARGE`
- `HUGE` |
| `READER_ERROR` | Tipos de errores identificados en los distintos procesos del SmartPOS. | - `UNAUTHORIZED`
- `CARD_READER_DISCONNECTED`
- `EMV_CONTACTLESS_ERROR`
- `EMV_CHIP_FALLBACK`
- `EMV_CHIP_REMOVED`
- `EMV_CHIP_REQUIRED`
- `LOW_PRIORITY_METHOD`
- `SHOW_CARD_AGAIN`
- `REQUEST`
- `TIMEOUT`
- `UNKNOWN` |
## Parámetros del Printer
Las distintas opciones que puede recibir el parámetro opcional `paramaters` de tipo `MBBXJson` dentro de los distintos método del `Printer`, son los que se muestran a continuación. Toda `Key` es de tipo `String`.
| Key | Constantes Permitidas | Valor por Defecto | Observacion | Tipo (valor) |
| ------------- | ------------------------------------------------------- | ---------------------------------- | --------------------------------------------------- | ------------ |
| `size` | Valor mayor a 1, recomendando un rango entre (150-300). | 150 | Solo aplicable para el tamaño del código QR. | `int` |
| `width` | Valor mayor a 1. | 320 | Solo aplicable para el tamaño del código de barras. | `int` |
| `height` | Valor mayor a 1. | 48 | Solo aplicable para el tamaño del código de barras. | `int` |
| `alignment` | `ALIGNMENT` (ver `ENUMS`). | Textos: `LEFT`.
QR: `CENTER`. | Permite alinear Textos y Código QR. | `enum` |
| `isBold` | - `true`
- `false` | false | Solo aplicable para un formato de fuente de Texto. | `boolean` |
| `isItalic` | - `true`
- `false` | false | Solo aplicable para un formato de fuente de Texto. | `boolean` |
| `isUnderline` | - `true`
- `false` | false | Solo aplicable para un formato de fuente de Texto. | `boolean` |
| `textSize` | `TEXT_SIZE` (ver *`ENUMS`*). | NORMAL | Solo aplicable para un formato de fuente de Texto. | `enum` |
# Respuesta de Lectura
La respuesta exitosa de una lectura, sea `Masgtripe`, `Chip` o `Contactless` retorna dentro del objeto data del evento, el siguiente objeto:
```java
source: {
type: "",
sourceData: {
bin: "",
last4: "",
length: 16,
cvvRequired: false
}
}
```
Lo cual explicamos a continuación cada propiedad:
| Key | Descripción | Tipo |
| ------------- | --------------------------------------------------------------------------- | --------- |
| `type` | Tipo de lectura finalmente detectado en el proceso. | `String` |
| `bin` | Primeros 6 dígitos de la tarjeta detectada. | `String` |
| `last4` | Últimos 4 dígitos de la tarjeta detectada. | `String` |
| `length` | Token generado para realizar la operacion | `int` |
| `cvvRequired` | Indica si es necesario solicitar el código de seguridad al Tarjeta-Habiente | `boolean` |
### Valores Posibles de `type`
| Valor | Descripcion |
| ----------------- | ------------------------------------------ |
| `magstripe` | Tipo de lectura detectado Banda Magnética. |
| `emv.chip` | Tipo de lectura detectado Chip. |
| `emv.contactless` | Tipo de lectura detectado Contactless. |
*Para ver un ejemplos de este objeto, ir a Ejemplos de Respuesta > Evento Lectura > READ\_SUCCESS*
# Implementaciones
## Importación de la librería SDK Mobbex
Todo SDK de Mobbex será un archivo de extensión .aar de nombre con formato:
***mobbex-card-reader-sdk-v.${version}.aar***
A este archivo será necesario agregarlo dentro de la carpeta /libs y luego agregarlo en las dependencias de la aplicación:
***Project Structure > Dependencies > Add > JAR/AAR Dependency***
*Verificar que en el archivo “build.gradle” de la aplicación, se haya agregado la implementación.*
## Implementación CardReader
Se realizará una explicación específica de cómo implementar las distintas clases, funciones y eventos que permitan una correcta inicialización del SDK Mobbex:
- Importar la clase `CardReader` y `CardReaderListener`:
```java
import com.mobbex.cardreader.CardReader;
import com.mobbex.cardreader.interfaces.CardReaderListener;
```
- Crear un objeto de clase `CardReader`, inicializar una nueva instancia y configurar el objeto `CardReaderListener`:
```java
CardReader cardReader;
...
cardReader = new CardReader(context);
cardReader.setCardReaderListener(new CardReaderListener() {
@Override
public void onConnection(MBBXJson jsonObject) {
//El objeto jsonObject del evento de conexión debería ser:
//jsonObject: {
// "type": READER_EVENT.READER_CONNECTED,
// "message": "CardReader is connected."
//}
}
@Override
public void onCard(MBBXJson jsonObject) {
}
@Override
public void onStatus(MBBXJson jsonObject) {
}
@Override
public void onPrinter(MBBXJson jsonObject) {
}
});
```
La conexión completa de la nueva instancia, se notificará mediante un evento de tipo `CONNECTION` (dentro de `onConnection`), el cual tendrá un `type` de tipo `READER_CONNECTED`. Luego de recibir este evento, la instancia `cardReader` estará lista para ejecutar los demás métodos de la clase.
## Información del Lector
Para conocer y poder ejecutar el método `getDeviceInfo()`, será necesario inicializar la instancia de `CardReader`, esperar su conexión exitosa, ejecutar el método y esperar el evento con la respuesta:
```java
CardReader cardReader;
...
cardReader = new CardReader(context);
cardReader.setCardReaderListener(new CardReaderListener() {
@Override
public void onConnection(MBBXJson jsonObject) {
//Si la conexión es exitosa, ejecutar el siguiente método:
cardReader.getDeviceInfo();
}
@Override
public void onCard(MBBXJson jsonObject) {
}
@Override
public void onStatus(MBBXJson jsonObject) {
//El objeto jsonObject del evento de información debería ser:
//jsonObject: {
// "type": READER_EVENT.DEVICE_INFO,
// "message": "Returning device info."
// "data": Json with device data.
//}
}
@Override
public void onPrinter(MBBXJson jsonObject) {
}
});
```
La respuesta de la información, se recibe en un evento de tipo `INFO` (dentro de `onStatus`), el cual tendrá un `type` de tipo `DEVICE_INFO`.
## Lectura y Procesamiento de Tarjeta
El SDK Mobbex posee dos métodos o flujos de lectura y procesamiento de tarjeta. Por un lado, la lectura y el procesamiento se pueden realizar de manera consecutiva, y por otro lado, la lectura y el procesamiento se realizan en métodos y lógicas separados. Para ambos casos, será necesario inicializar la instancia de `CardReader`, esperar su conexión exitosa, ejecutar el/los método/s y esperar el evento con la respuesta. A continuación, explicamos ambos flujos:
### Lectura y Procesamiento Unificado
Este flujo permite realizar el procesamiento de una transacción automática y consecutivamente luego de la detección exitosa de una tarjeta. Para este flujo, es necesario poseer/crear la intención de pago (*intent token*) y cantidad de cuotas (`installment`) de manera previa.
El método utilizado para realizar este flujo, es *`readAndProcess(int amount, int otherAmount, TRANSACTION_TYPE trxType, int intentToken, int installments)`*:
```java
CardReader cardReader;
...
cardReader = new CardReader(context);
cardReader.setCardReaderListener(new CardReaderListener() {
@Override
public void onConnection(MBBXJson jsonObject) {
//Si la conexión es exitosa, ejecutar el siguiente método:
startReadProcess();
}
@Override
public void onCard(MBBXJson jsonObject) {
//Aquí dentro se recibirá todo evento intermedio durante la
//detección y lectura de la tarjeta, y el procesamiento de
//la transacción
}
@Override
public void onStatus(MBBXJson jsonObject) {
}
@Override
public void onPrinter(MBBXJson jsonObject) {
}
});
private void startReadProcess() {
//(opcional) Se configura la cantidad de reintentos automáticos:
setReadRetries(1); //solo un reintento
setReadRetries(4); //4 reintentos
setReadRetries(0); //sin reintentos (manejo manual)
int amount = getAmount();
int otherAmount = getOtherAmount(); //Opcional
TRANSACTION_TYPE trxType = getTrxType(); //Opcional
String intentToken = createIntentToken();
int installments = getInstallments();
//Comienza el proceso de lectura y procesamiento:
cardReader.readAndProcess(amount, otherAmount, trxType, intentToken, installments);
//Otra manera de ejecutar el método, sin parámetros opcionales
cardReader.readAndProcess(amount, intentToken, installments);
}
```
En resumen, se debe:
- Inicializar instancia `CardReader` y esperar su conexión exitosa;
- Configurar parámetros de lectura, obtener/crear intent token, monto a procesar, monto de retiro, tipo de transacción y cantidad de cuotas.
- Ejecutar método `readAndProcess`.
- Toda respuesta de información, error, lectura y/o procesamiento de este último evento, se reciben en eventos de tipo `CARD` (dentro de la función `onCard`).
### Lectura y Procesamiento en Paralelo
Si la necesidad del caso de uso, es primero detectar y leer una tarjeta, luego realizar procesos como detección de bines, selección de cuotas personalizadas u otros procesos específicos, se pueden realizar de la siguiente manera.
Los métodos utilizados para realizar este flujo, son `read(int amount, int otherAmount, TRANSACTION_TYPE trxType)` y *`processTRX(int amount, int intentToken, int installments)`* o *`processTRX(int amount, int intentToken, String installmentsReference)`*
```java
import com.mobbex.cardreader.enums.READER_EVENT;
...
CardReader cardReader;
...
cardReader = new CardReader(context);
cardReader.setCardReaderListener(new CardReaderListener() {
@Override
public void onConnection(MBBXJson jsonObject) {
//Si la conexión es exitosa, ejecutar el siguiente método:
startReadProcess();
}
@Override
public void onCard(MBBXJson jsonObject) {
READER_EVENT type = (READER_EVENT) jsonObject.get("type");
if (type == READER_EVENT.READING) {
//El procesamiento de lectura ha comenzado y
//espera tarjeta a detectar.
} else if (type == READER_EVENT.CARD_DETECTED) {
//La tarjeta fue detectada! Podrás ver el tipo de método detectado
//(READ_TYPE) dentro del objeto del evento.
} else if (type == READER_EVENT.READ_SUCCESS) {
//La lectura y detección finalizó con éxito.
//Podrás ver los datos brindados en los datos del evento.
//TODO: aquí se deberá hacer los distintos procesos que el
//flujo de la app requiera:
// - Detección de BIN.
// - Selección de Cuotas.
// - Interacción pertinente con el usuario.
// - Creación del IntentToken
String intentToken = createIntentToken();
int installments = getInstallments();
// Una vez finalizados los procesos necesarios, comenzar el procesamiento
// - De ser necesario, se debe brindar el código de seguridad
// de la tarjeta.
String cvv = getSecurityCode(); //cuando sea necesario.
cardReader.processTRX(intentToken, installments, cvv);
}
}
@Override
public void onStatus(MBBXJson jsonObject) {
}
@Override
public void onPrinter(MBBXJson jsonObject) {
}
});
private void startReadProcess() {
//(opcional) Se configura la cantidad de reintentos automáticos:
setReadRetries(1); //solo un reintento
setReadRetries(4); //4 reintentos
setReadRetries(0); //sin reintentos (manejo manual)
int amount = getAmount();
int otherAmount = getOtherAmount() //Opcional
//Comienza el proceso de detección y lectura de la tarjeta:
cardReader.read(amount, otherAmount);
//Otra manera de ejecutar el método, sin parámetros opcionales
cardReader.read(amount);
}
```
## Impresión de Ticket
El SDK de Mobbex permite realizar impresiones de tickets customizados, de manera simple y rápida. Será necesario inicializar la instancia de `CardReader`, esperar su conexión exitosa, configurar su contenido y ejecutar el método `print()`:
```java
CardReader cardReader;
...
cardReader = new CardReader(context);
cardReader.setCardReaderListener(new CardReaderListener() {
@Override
public void onConnection(MBBXJson jsonObject) {
}
@Override
public void onCard(MBBXJson jsonObject) {
}
@Override
public void onStatus(MBBXJson jsonObject) {
}
@Override
public void onPrinter(MBBXJson jsonObject) {
//Si lainicialización del Printer fue exitosa, ejecutar el método
//(Acá debería haber un manejo/condición de eventos para evitar
//reimpresiones involuntarias).
createPrinterTicket();
cardReader.print();
}
});
private void createPrinterTicket() {
//Customizo y agrego texto a la memoria del Printer
MBBXJson textParams = new MBBXJson();
textParams.put("textSize", TEXT_SIZE.LARGE);
textParams.put("isBold", true);
textParams.put("alignment", ALIGNMENT.CENTER);
textParams.put("isItalic", true);
textParams.put("isUnderline", false);
cardReader.setPrinterText("MOBBEX", textParams));
//Agrego espacio en blanco en el Printer
cardReader.setPrinterFeed(10);
//Customizo y agrego imágen QR a la memoria del Printer
MBBXJson qrParams = new MBBXJson();
textParams.put("alignment", ALIGNEMNT.CENTER);
textParams.put("qrSize", 300);
cardReader.setPrinterQr(qrCode, qrParams);
cardReader.setPrinterFeed(10);
//Agrego imágen de código de barras en la memoria del Printer
cardReader.setPrinterBarcode(barCode);
}
```
## Detener Tareas del Lector
Es recomendable utilizar la función `stopTask()` siempre que sea necesario.
Tanto el proceso de lectura de tarjetas, como la obtención de datos del lector y la impresión del ticket, inicializan procesos internos entre el SDK de Mobbex y el lector, que deben de finalizarse o cancelarse para su correcto uso y evitar mal funcionamiento.
## Modo Debug
El SDK de Mobbex posee un modo de uso que permite imprimir por consola más información que faciliten su implementación y depuración.
Además, esta sección permite simular ciertos escenarios como Tarjetas Dual o Procesos de Verificación del Tarjeta-Habiente, para poder desarrollar y soportar los eventos sin la necesidad de contar con las tarjetas especiales.
### Activación Modo Debug
Este modo por defecto es `false` y podrá activarse únicamente luego de finalizada la inicialización del `CardReader`.
```java
CardReader cardReader;
...
cardReader = new CardReader(context);
cardReader.setCardReaderListener(new CardReaderListener() {
@Override
public void onConnection(MBBXJson jsonObject) {
//Si la conexión es exitosa, ejecutar el siguiente método:
cardReader.setDebugMode(true);
}
@Override
public void onCard(MBBXJson jsonObject) {
}
@Override
public void onStatus(MBBXJson jsonObject) {
}
@Override
public void onPrinter(MBBXJson jsonObject) {
}
});
```
### Activación Modo Debug Múltiple Aplicaciones
En detección de tarjetas por el método `Chip`, es necesario dar soporte a tarjetas Duales. Esto significa, que el SDK de Mobbex identificará si la tarjeta posee múltiples aplicaciones, y solicitará la selección de alguna aplicaciones posibles. Este escenario, emite eventos de tipo `READER_EVENT` con `type` `WAITING_AID`. Puedes ver un ejemplo de respuesta de este evento que posee el `array` con las distintas aplicaciones posibles, en la sección de *Ejemplos de Respuesta -> Evento Lectura*.
El modo debug de múltiples aplicaciones, permite forzar el lanzamiento de este evento, por más que la tarjeta posea una única aplicación habilitada.
Para activarlo, es necesario haber activado el modo debug previamente. La forma de activar el SDK de Mobbex en modo debug de Múltiples Aplicaciones, es la siguiente:
```java
CardReader cardReader;
...
cardReader = new CardReader(context);
cardReader.setCardReaderListener(new CardReaderListener() {
@Override
public void onConnection(MBBXJson jsonObject) {
//Si la conexión es exitosa, ejecutar el siguiente método:
cardReader.setDebugMode(true);
cardReader.setDebugMultipleApplicationMode(true);
}
@Override
public void onCard(MBBXJson jsonObject) {
}
@Override
public void onStatus(MBBXJson jsonObject) {
}
@Override
public void onPrinter(MBBXJson jsonObject) {
}
});
```
### Activación Modo Debug de Método de Verificación Tarjeta-Habiente
En detección de tarjetas por el método `Contactless`, es necesario dar soporte a tarjetas en donde el tarjeta habiente requiera realizar una verificación requerida por el emisor. Esto significa, que el SDK de Mobbex identificará si la tarjeta requiere de dicha verificación. Este escenario, emite eventos de tipo `READER_EVENT` con los `types` `CDCVM_REQUIRED`de y `CDCVM_VERIFICATION_READY`.
El modo debug de método de Verificación Tarjeta-Habiente, permite forzar el lanzamiento de estos eventos, por más que la tarjeta no lo requiera.
Para activarlo, es necesario haber activado el modo debug previamente. La forma de activar el SDK de Mobbex de método de Verificación Tarjeta-Habiente, es la siguiente:
```java
CardReader cardReader;
...
cardReader = new CardReader(context);
cardReader.setCardReaderListener(new CardReaderListener() {
@Override
public void onConnection(MBBXJson jsonObject) {
//Si la conexión es exitosa, ejecutar el siguiente método:
cardReader.setDebugMode(true);
cardReader.setDebugCVMVerificationMode(true);
}
@Override
public void onCard(MBBXJson jsonObject) {
}
@Override
public void onStatus(MBBXJson jsonObject) {
}
@Override
public void onPrinter(MBBXJson jsonObject) {
}
});
```
### A tener en cuenta en la Activación Modo Debug
- Los modos Múltiples Aplicaciones y Verificación Tarjeta Habiente, solo funcionan si el Modo Debug está activado.
- Al desactivar el Modo Debug, se desactivarán también cualquier otro Modo Debug Activado.
- Sólo un Modo Debug Especial podrá estar activo al mismo tiempo, es decir, al activar el modo Múltiples Aplicaciones, se desactivará el modo Verificación Tarjeta Habiente, y viceversa.
- **Estos modos estarán prohibidos en lectores productivos.**
# Ejemplos de Respuestas
A modo de entender el formato y posibilidades, se presentan algunos ejemplos de respuesta en los distintos eventos:
## Evento Connexión
```java
//READER_EVENT.READER_CONNECTED
jsonObject = {
type: READER_CONNECTED,
message: "Card Reader is Connected."
}
```
```java
//READER_EVENT.READER_ERROR
jsonObject = {
type: READER_ERROR,
message: "getDeviceInfo() function not able. CardReader is disconnected or not fully connected."
}
```
## Evento Lectura
```java
//READER_EVENT.READING
jsonObject = {
type: READING,
message: "Card Reader is Ready to read card."
}
```
```java
//READER_EVENT.CARD_DETECTED
jsonObject = {
type: CARD_DETECTED,
message: "Card detected.",
data: {
type: "EMV_CHIP" //READ_TYPE Enum
}
}
```
```java
//READER_EVENT.READ_RESTART
jsonObject = {
type: READ_RESTART,
message: "Restarting read process. Method use has low priority. Try using other card reader method.",
error: {
type: LOW_PRIORITY_METHOD, //READER_ERROR Enum
message: "Try using other card reader method."
}
}
```
```java
//READER_EVENT.READ_SUCCESS
jsonObject = {
type: READ_SUCCESS,
message: "Card Reader is Ready to read card."
data: {
source: {
type: "emv.contactless",
sourceData: {
bin: "123456",
last4: "6789",
length: 16,
cvvRequired: false
}
}
}
}
```
```java
//READER_EVENT.READ_FAIL
jsonObject = {
type: READ_FAIL,
message: "Reading card failed. Moving to fast or bad swipe, try again.",
data: {},
error: {
type: SHOW_CARD_AGAIN, //READER_ERROR Enum
message: "Moving to fast or bad swipe, try again."
}
}
```
```java
//READER_EVENT.WAITING_AID
jsonObject = {
type: WAITING_AID,
message: "Waiting Application to be selected.",
data: ["Visa debito", "Visa crédito"]
}
```
```java
//READER_EVENT.PROCESSING
jsonObject = {
type: PROCESSING,
message: "Start processing transaction.",
}
```
```java
//READER_EVENT.PROCESS_SUCCESS
jsonObject = {
type: PROCESS_SUCCESS,
message: "Process transaction finished successfully!",
data: {
view: "default",
options: {},
id: "CW2DXGPTCVZA3QQZ5TCGG1",
status: {
code: "415",
text: "Denegada, Método de Pago Inválido",
message: "DENEGADA. ( Cod. 5 )",
data: {},
view: "default",
},
total: 200,
currency: {
value: "ARS",
label: "Peso Argentino",
symbol: "$",
locale: "es-AR",
hidden: false,
},
data: [
{
type: "item",
key: "transactionId",
label: "Transacción Nro",
value: "CW2DXGPTCVZA3QQZ5TCGG1",
priority: 2,
visibility: "visible",
},
{
type: "item",
key: "cardNumber",
label: "Tarjeta",
value: "466057******7851",
priority: 99,
visibility: "hidden",
},
{
type: "item",
key: "authorizationCode",
label: "Código de Autorización",
value: "",
priority: 99,
visibility: "none",
},
{
type: "item",
key: "batchNo",
label: "Lote",
value: "21",
priority: 99,
visibility: "none",
},
{
type: "item",
key: "ticketNo",
label: "Ticket",
value: "80",
priority: 99,
visibility: "none",
},
{
type: "item",
key: "resultCode",
label: "Resultado del Emisor",
value: "5",
priority: 99,
visibility: "none",
},
{
type: "item",
key: "retrievalReferenceNo",
label: "Referencia del Emisor",
value: "",
priority: 99,
visibility: "none",
},
],
actions: [
{
label: "Imprimir",
key: "print",
type: "default",
action: {
type: "print",
data: {
url: "https://ms.mobbex.com/prod/reports",
path: "/v2/coupon/",
id: "CW2DXGPTCVZA3QQZ5TCGG1",
schema: "card",
},
},
},
{
label: "Firmar",
key: "sign",
type: "primary",
action: {
type: "signature",
data: { url: "/p/pos/coupon/signature/CW2DXGPTCVZA3QQZ5TCGG1" },
},
},
{
label: "Enviar Ticket",
key: "send_coupon",
type: "primary",
action: {
type: "notification",
data: { url: "/p/pos/coupon/notification/CW2DXGPTCVZA3QQZ5TCGG1" },
},
},
{ label: "Reintentar", key: "retry", type: "primary", action: { type: "reload" } },
],
}
}
```
```java
//READER_EVENT.PROCESS_FAIL (1)
jsonObject = {
type: PROCESS_FAIL,
error: {
type: REQUEST, // READER_ERROR Enum
error: "Execution failed. Please contact support with the case ID. ID: 221985c9-78b2-49b6-929c-e39cc0d28b18",
code: "GENERIC:EFCS"
}
}
//READER_EVENT.PROCESS_FAIL (2)
jsonObject = {
type: PROCESS_FAIL,
error: {
type: REQUEST, // READER_ERROR Enum
error: "No se encontraron datos para la entidad solicitada",
code: "DNEFRE"
}
}
```
```java
//READER_EVENT.PROCESS_SECURITY_CODE_REQUIRED
jsonObject = {
type: PROCESS_SECURITY_CODE_REQUIRED,
message: "Security Code in this transaction is required."
}
```
## Evento Info
```java
//READER_EVENT.DEVICE_INFO
jsonObject = {
type: DEVICE_INFO,
message: "Returning device info.",
data: {
payComponentVersion: "0",
ROMVersion: "0.2.0RH",
productName: "DX8000",
processorInfo: "Qualcomm Technologies, Inc QCM2150",
hardwareSerialNumber: "S6DX800075-2Q95B<214UCD815316000",
androidKernelVersion: "4.9.217",
bootVersion: "1.1.2 2021-04-15 18:10",
IMSI: null,
CSN: "",
ICCID: null,
secfwVersion: "01.04.01.00003",
mode: "3 - Mockup state",
IMEI: "868735050034844",
basebandVersion: "19080.4000.00.03.01.59,19080.4000.00.03.01.59",
hardwareVersion: "0",
firmwareVersion: "AND-Q4-ALPHA",
extDeviceVersion: null,
isOvsTerm: true,
buildNumber: "0.2.0RH",
terminalType: "DX8000",
serialNumber: "214UCD815316",
model: "DX8000",
manufacture: "LANDI",
androidOSVersion: "10",
pn: "TWT52011869A"
}
}
```
## Evento Printer
```java
//READER_EVENT.PRINTING
jsonObject = {
type: PRINTING,
message: "Printer start printing."
}
```
```java
//READER_EVENT.PRINTER_SUCCESS
jsonObject = {
type: PRINTER_SUCCESS,
message: "Printer print finished successfully!"
}
```
```java
//READER_EVENT.PRINTER_FAIL
jsonObject = {
type: PRINTER_FAIL,
message: "Printer print failed."
}
```