# Conectarse a un lector

Conecta tu aplicación a un lector de Stripe Terminal.

> Si aún no has elegido ningún lector, compara los [lectores de Terminal](https://docs.stripe.com/terminal/payments/setup-reader.md) disponibles y elige el que mejor se adapte a tus necesidades.

# Lector simulado

> This is a Lector simulado for when terminal-sdk-platform is server-driven and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=server-driven&reader-type=simulated.

Stripe proporciona un lector simulado basado en servidor para que puedas desarrollar y probar tu aplicación y simular pagos de Terminal, sin necesidad de conectarte a un hardware físico.

## Crea un lector simulado

Para crear un lector simulado, utiliza uno de los códigos de registro designados (`simulated-wpe`, `simulated-s700` o `simulated-s710`) al registrar el lector. Este código de registro crea un objeto lector WisePOS E, Stripe S700 o Stripe S710 simulado solo en un entorno de pruebas. Puedes registrar el lector simulado utilizando la API de Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "location={{TERMINALLOCATION_ID}}" \
  -d registration_code=simulated-wpe
```

Esto devuelve un objeto [lector](https://docs.stripe.com/api/terminal/readers.md) que representa tu lector simulado:

```json
{
  "id": "tmr_xxx",
  "object": "terminal.reader",
  "device_sw_version": "2.37.2.0",
  "device_type": "simulated_wisepos_e",
  "ip_address": "0.0.0.0",
  "label": "simulated-wpe-xxx-xxx-xx-xxx",
  "livemode": false,
  "location": "tml_xxx",
  "serial_number": "simulated-wpe-xxx-xxx-xx-xxx",
  "status": "online"
}
```

## Consulta tu lector simulado

El lector simulado se comporta como un lector real. Puedes recuperar su información desde el [punto de conexión del lector](https://docs.stripe.com/api/terminal/readers/retrieve.md):

```curl
curl https://api.stripe.com/v1/terminal/readers/tmr_xxx \
  -u "<<YOUR_SECRET_KEY>>:"
```

```json
{
  "id": "tmr_xxx",
  "object": "terminal.reader",
  "action": null,
  "device_sw_version": "2.37.2.0",
  "device_type": "simulated_wisepos_e",
  "ip_address": "0.0.0.0",
  "label": "simulated-wpe-xxx-xxx-xx-xxx",
  "livemode": false,
  "location": "tml_xxx",
  "metadata": {
  },
  "serial_number": "simulated-wpe-xxx-xxx-xx-xxx",
  "status": "offline"
}
```


# Lector simulado

> This is a Lector simulado for when terminal-sdk-platform is js and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=js&reader-type=simulated.

Los SDK de Stripe Terminal y la integración basada en el servidor cuentan con un lector de tarjetas simulado incorporado para que puedas desarrollar y probar tu aplicación sin tener que conectarla a un hardware físico. Ya sea que tengas una integración completa o que la estés desarrollando, utiliza el lector simulado para emular todos los flujos de Terminal de tu aplicación.

El lector simulado no proporciona una interfaz de usuario. Después de conectarte a él en tu aplicación, podrás ver que funciona cuando se realizan correctamente las llamadas al SDK o a la API de Stripe.

Los lectores simulados para SDK simulan automáticamente la presentación de la tarjeta según sea necesario. Para la integración basada en servidor, actualiza tu integración a [simular presentación de tarjeta](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment).

Para utilizar el lector simulado, llama a [discoverReaders](https://docs.stripe.com/terminal/references/api/js-sdk.md#discover-readers) para buscar lectores, con la opción `simulated` establecida en `true`. Cuando `discoverReaders` devuelve un resultado, llama a [connectReader](https://docs.stripe.com/terminal/references/api/js-sdk.md#connect-reader) para conectarte al lector simulado.

```javascript
// Handler for a "Connect Reader" button
async function connectReaderHandler() {
  const config = {simulated: true};
  const discoverResult = await terminal.discoverReaders(config);
  if (discoverResult.error) {
    console.log('Failed to discover: ', discoverResult.error);
  } else if (discoverResult.discoveredReaders.length === 0) {
    console.log('No available readers.');
  } else {
    // Just select the first reader here.
    const selectedReader = discoverResult.discoveredReaders[0];

    const connectResult = await terminal.connectReader(selectedReader);
    if (connectResult.error) {
      console.log('Failed to connect: ', connectResult.error);
    } else {
      console.log('Connected to reader: ', connectResult.reader.label);
    }
  }
}
```

### Configuración del lector simulado

- [setSimulatorConfiguration (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#stripeterminal-setsimulatorconfig)

El lector simulado acepta una pequeña configuración, con lo que puedes probar diferentes flujos de la aplicación en tu punto de venta, por ejemplo: diferentes marcas de tarjeta o situaciones de error, como que se rechace un cobro. Para habilitar este comportamiento, usa el siguiente código antes de recolectar tu método de pago:

```javascript
terminal.setSimulatorConfiguration({testCardNumber: '4242424242424242'});
```


# Lector simulado

> This is a Lector simulado for when terminal-sdk-platform is ios and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=simulated.

Los SDK de Stripe Terminal y la integración basada en el servidor cuentan con un lector de tarjetas simulado incorporado para que puedas desarrollar y probar tu aplicación sin tener que conectarla a un hardware físico. Ya sea que tengas una integración completa o que la estés desarrollando, utiliza el lector simulado para emular todos los flujos de Terminal de tu aplicación.

El lector simulado no proporciona una interfaz de usuario. Después de conectarte a él en tu aplicación, podrás ver que funciona cuando se realizan correctamente las llamadas al SDK o a la API de Stripe.

Los lectores simulados para SDK simulan automáticamente la presentación de la tarjeta según sea necesario. Para la integración basada en servidor, actualiza tu integración a [simular presentación de tarjeta](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment).

Para usar el lector simulado, llama a [discoverReaders](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:) para buscar lectores, con la opción `simulated` establecida en `true`. Cuando `discoverReaders` devuelve un resultado, llama a [connectReader](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:delegate:completion:) para conectarte al lector simulado.

Cuando te conectas a un lector móvil o a un lector Tap to Pay, tu integración debe incluir el `locationId` en la configuración de conexión, incluso para el lector simulado. Como el lector simulado no se puede asociar con una ubicación real, proporciona en su lugar el simulacro de `locationId` del lector simulado.

```swift
import UIKit
import StripeTerminal

class DiscoverReadersViewController: UIViewController, DiscoveryDelegate {

    var discoverCancelable: Cancelable?

    // ...

    // Action for a "Discover Readers" button
    func discoverReadersAction() throws {let config = try BluetoothScanDiscoveryConfigurationBuilder().setSimulated(true).build()
        self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in
            if let error = error {
                print("discoverReaders failed: \(error)")
            } else {
                print("discoverReaders succeeded")
            }
        }
    }

    // ...

    // MARK: DiscoveryDelegate

    // This delegate method can get called multiple times throughout the discovery process.
    // You might want to update a UITableView and display all available readers.
    // Here, we're automatically connecting to the first reader we discover.
    func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) {

        // Select the first reader we discover
        guard let selectedReader = readers.first else { return }

        // Since the simulated reader is not associated with a real location, we recommend
        // specifying its existing mock location.
        guard let locationId = selectedReader.locationId else { return }

        // Only connect if we aren't currently connected.
        guard terminal.connectionStatus == .notConnected || terminal.connectionStatus == .discovering else { return }
// Replace 'yourMobileReaderDelegate' with your actual MobileReaderDelegate implementation
        let mobileReaderDelegate = yourMobileReaderDelegate
        do {
            connectionConfig = try BluetoothConnectionConfigurationBuilder(
                // When connecting to a physical reader, your integration should specify either the
                // same location as the last connection (selectedReader.locationId) or a new location
                // of your user's choosing.
                delegate: mobileReaderDelegate,
                locationId: locationId
            )
            .setAutoReconnectOnUnexpectedDisconnect(true) // This is optional as it's the default value
            .build()
        } catch {
            // Handle error building the connection configuration
            return
        }

        // Note `readerDelegate` should be provided by your application.
        // See our Quickstart guide at https://stripe.com/docs/terminal/quickstart
        // for more example code.
        Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in
            if let reader = reader {
                print("Successfully connected to reader: \(reader)")
            } else if let error = error {
                print("connectReader failed: \(error)")
            }
        }
    }
}
```

### Configuración del lector simulado

- [SimulatorConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPSimulatorConfiguration.html)

El lector simulado acepta una pequeña configuración, con lo que puedes probar diferentes flujos de la aplicación en tu punto de venta, por ejemplo: diferentes marcas de tarjeta o situaciones de error, como que se rechace un cobro. Para habilitar este comportamiento, usa el siguiente código antes de recolectar tu método de pago:

#### Swift

```swift
let simulatorConfiguration = Terminal.shared.simulatorConfiguration
simulatorConfiguration.simulatedCard = SimulatedCard(type: .amex)
simulatorConfiguration.simulatedTipAmount = 1000
```


# Lector simulado

> This is a Lector simulado for when terminal-sdk-platform is android and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=simulated.

Los SDK de Stripe Terminal y la integración basada en el servidor cuentan con un lector de tarjetas simulado incorporado para que puedas desarrollar y probar tu aplicación sin tener que conectarla a un hardware físico. Ya sea que tengas una integración completa o que la estés desarrollando, utiliza el lector simulado para emular todos los flujos de Terminal de tu aplicación.

El lector simulado no proporciona una interfaz de usuario. Después de conectarte a él en tu aplicación, podrás ver que funciona cuando se realizan correctamente las llamadas al SDK o a la API de Stripe.

Los lectores simulados para SDK simulan automáticamente la presentación de la tarjeta según sea necesario. Para la integración basada en servidor, actualiza tu integración a [simular presentación de tarjeta](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment).

Para utilizar el lector simulado, llama a [discoverReaders](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html) para buscar lectores, con la opción `isSimulated` en la `DiscoveryConfiguration` elegida establecida en `true`. Cuando `discoverReaders` devuelve un resultado, llama a [connectReader](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html) para conectarte al lector simulado.

Cuando te conectas a un lector móvil, tu integración debe incluir el `locationId` en la configuración de conexión, incluso para el lector simulado. Como el lector simulado no se puede asociar con una ubicación real, proporciona en su lugar el simulacro de `locationId` del lector simulado.

```kotlin
// Handler for a "Connect Reader" button
fun onConnect() {
    val config = BluetoothDiscoveryConfiguration(timeout = 0, isSimulated = true)

    Terminal.getInstance().discoverReaders(
        config,
        object : DiscoveryListener {
            override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
                // Select the first reader here.
                val firstReader = readers.first()
                // Replace 'yourMobileReaderListener' with your actual MobileReaderListener implementation
                val mobileReaderListener = yourMobileReaderListener
                val autoReconnectOnUnexpectedDisconnect = true

                // When connecting to a physical reader, specify either the
                // same location as the last connection (selectedReader.location?.id) or a new location
                // of your user's choosing.
                //
                // Since the simulated reader isn't associated with a real location, we recommend
                // specifying its existing mock location.
                val connectionConfig = BluetoothConnectionConfiguration(
                    locationId = firstReader.location?.id.orEmpty(),
                    autoReconnectOnUnexpectedDisconnect = autoReconnectOnUnexpectedDisconnect,
                    bluetoothReaderListener = mobileReaderListener
                )

                Terminal.getInstance().connectReader(
                    firstReader,
                    connectionConfig,
                    object : ReaderCallback {
                        override fun onSuccess(reader: Reader) {
                            // Placeholder for handling successful operation
                        }

                        override fun onFailure(e: TerminalException) {
                            // Placeholder for handling exception
                        }
                    }
                )
            }
        },
        object : Callback {
            override fun onSuccess() {
                // Placeholder for handling successful operation
            }

            override fun onFailure(e: TerminalException) {
                // Placeholder for handling exception
            }
        }
    )
}
```

### Configuración del lector simulado

- [SimulatorConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-simulator-configuration/index.html)

El lector simulado acepta una pequeña configuración, con lo que puedes probar diferentes flujos de la aplicación en tu punto de venta, por ejemplo: diferentes marcas de tarjeta o situaciones de error, como que se rechace un cobro. Para habilitar este comportamiento, usa el siguiente código antes de recolectar tu método de pago:

#### Kotlin

```kotlin
val simulatedFixedTipAmount = 1000L;

val simulatorConfig = SimulatorConfiguration(
    simulatedCard = SimulatedCard(SimulatedCardType.AMEX),
    simulatedTipAmount = simulatedFixedTipAmount
);

Terminal.getInstance().setSimulatorConfiguration(simulatorConfig);
```


# Lector simulado

> This is a Lector simulado for when terminal-sdk-platform is react-native and reader-type is simulated. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=simulated.

Los SDK de Stripe Terminal y la integración basada en el servidor cuentan con un lector de tarjetas simulado incorporado para que puedas desarrollar y probar tu aplicación sin tener que conectarla a un hardware físico. Ya sea que tengas una integración completa o que la estés desarrollando, utiliza el lector simulado para emular todos los flujos de Terminal de tu aplicación.

El lector simulado no proporciona una interfaz de usuario. Después de conectarte a él en tu aplicación, podrás ver que funciona cuando se realizan correctamente las llamadas al SDK o a la API de Stripe.

Los lectores simulados para SDK simulan automáticamente la presentación de la tarjeta según sea necesario. Para la integración basada en servidor, actualiza tu integración a [simular presentación de tarjeta](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment).

Para utilizar el lector simulado, llama a [discoverReaders](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders) para buscar lectores, con la opción `simulated` establecida en `true`. Cuando se llama a la devolución de llamada `onUpdateDiscoveredReaders` con una matriz de lectores como argumento, llama a [connectReader](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1) para conectarte al lector simulado.

Cuando te conectas a un lector móvil o a un lector TapToPay, tu integración debe incluir el `locationId` en la configuración de conexión, incluso para el lector simulado. Como el lector simulado no se puede asociar con una ubicación real, proporciona en su lugar el simulacro de `locationId` del lector simulado.

```js
function DiscoverReadersScreen() {
  const { discoverReaders, connectReader, discoveredReaders } =
    useStripeTerminal({
      onUpdateDiscoveredReaders: (readers) => {
        // After the SDK discovers a reader, your app can connect to it.
        // Here, we're automatically connecting to the first discovered reader.
        handleConnectBluetoothReader(readers[0]);
      },
    });

  useEffect(() => {
    handleDiscoverReaders();
  }, []);

  const handleDiscoverReaders = async () => {
    // The list of discovered readers is reported in the `onUpdateDiscoveredReaders` method
    // within the `useStripeTerminal` hook.
    const { error } = await discoverReaders({
      discoveryMethod: 'bluetoothScan',
      simulated: true,
    });

    if (error) {
      Alert.alert(
        'Discover readers error: ',
        `${error.code}, ${error.message}`
      );
    }
  };

  const handleConnectBluetoothReader = async (discoveredReader: Reader.Type) => {
    const { reader, error } = await connectReader({
        discoveryMethod: 'bluetoothScan',
        reader: discoveredReader,
        // Since the simulated reader is not associated with a real location, we recommend
        // specifying its existing mock location.
        locationId: discoveredReader.locationId,
      });

    if (error) {
      console.log('connectReader error', error);
      return;
    }

    console.log('Reader connected successfully', reader);
  };

  return <View />;
}
```

### Configuración del lector simulado

- [setSimulatedCard (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#setSimulatedCard)

El lector simulado acepta una pequeña configuración, con lo que puedes probar diferentes flujos de la aplicación en tu punto de venta, por ejemplo: diferentes marcas de tarjeta o situaciones de error, como que se rechace un cobro. Para habilitar este comportamiento, usa el siguiente código antes de recolectar tu método de pago:

```js
const { error } = await setSimulatedCard('4242424242424242');

if (error) {
  // Placeholder for handling exception
}

// Placeholder for handling successful operation
```


# Lectores Bluetooth

> This is a Lectores Bluetooth for when terminal-sdk-platform is ios and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=bluetooth.

Los lectores conectados por Bluetooth son dispositivos Bluetooth LE. Recopilan detalles de pago, pero dependen de un dispositivo móvil emparejado para la comunicación con Stripe.

Para conectar la aplicación a un lector Terminal mediante Bluetooth, sigue estos pasos:

1. [Descubrir lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers).
1. [Conectar a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader).

> No uses la configuración del dispositivo móvil para emparejarlo con tu lector. Emparejar el lector a través de la configuración del dispositivo hace que el lector no esté disponible para conectarse a tu aplicación.

## Detectar lectores [Lado del cliente]

- [discoverReaders (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:)
- [BluetoothScanDiscoveryConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPBluetoothScanDiscoveryConfiguration.html)

Para empezar, asegúrate de que el lector esté encendido y cerca de él.

Luego, desde tu aplicación, busca lectores cercanos conectados a Bluetooth con el método `discoverReaders`, usando `BluetoothScanDiscoveryConfiguration`.

#### Swift

```swift
import StripeTerminal

class DiscoverReadersViewController: UIViewController, DiscoveryDelegate {

    var discoverCancelable: Cancelable?

    // ...

    // Action for a "Discover Readers" button
    func discoverReadersAction() throws {
        let config = try BluetoothScanDiscoveryConfigurationBuilder().build()
        // In addition to Terminal's completion block methods, Swift async alternatives are available.
        // See our Example app for usage examples: https://github.com/stripe/stripe-terminal-ios/tree/master/Example
        self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in
            if let error = error {
                print("discoverReaders failed: \(error)")
            } else {
                print("discoverReaders succeeded")
            }
        }
    }

    // ...

    // MARK: DiscoveryDelegate

    func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) {
        // In your app, display the discovered readers to the user.
        // Call `connectReader` after the user selects a reader to connect to.
    }
}

```

#### Proximidad Bluetooth  * (BBPOS Chipper 2X BT only)

La proximidad de Bluetooth filtros los resultados de búsqueda para mostrar el lector más cercano. Cuando se detecta, el lector parpadea con luces multicolores, lo que permite al usuario identificar al lector detectado entre muchos otros lectores. Después de que el SDK detecte un lector, no cambiará a un lector más cercano a menos que apagues el lector detectado.

Ten en cuenta que, cuando se utiliza la proximidad Bluetooth, el SDK devuelve el lector a la devolución de llamada de la aplicación dos veces. La primera vez, la aplicación recibe un objeto `Reader` rellenado solo con el número de serie del lector. Después de un breve retraso, tu aplicación recibe el mismo objeto `Reader` rellenado con nueva información, como el nivel de batería del lector.

Recomendamos mostrar el lector detectado en la interfaz de usuario, lo que permite al usuario confirmar la conexión con el lector o cancelarla si no quiere conectarse a este lector.

#### Escaneo Bluetooth

El escaneo Bluetooth busca todos los lectores cercanos y devuelve a tu aplicación una lista de lectores detectados. A medida que continúa el proceso de detección, el SDK sigue invocando el método `DiscoveryDelegate.didUpdateDiscoveredReaders` con la última lista de lectores cercanos.

Durante el proceso de detección, el `SCPConnectionStatus` del Terminal pasa a `SCPConnectionStatus.SCPConnectionStatusDiscovering` mientras la detección está en curso.

Con el método de detección de escaneo Bluetooth, puedes establecer un tiempo de espera para escanear durante un período de tiempo determinado, que puedes usar para gestionar la vida útil de la batería o activar un mensaje de error si no se encuentran dispositivos.

En tu aplicación móvil, te recomendamos mostrar una lista que se actualice automáticamente con los lectores detectados y sus números de serie para ayudar a los usuarios a identificar su lector móvil. La propiedad `label` no se rellena para los lectores móviles durante la detección de lectores. Si necesitas mostrar nombres descriptivos para los lectores, mantén tu propia asignación de números de serie a etiquetas en tu aplicación.

#### Emparejamiento Bluetooth

Para mejorar la seguridad y cumplir con la normativa de la UE, a partir de noviembre de 2025 Stripe utiliza el proceso de comparación numérica Bluetooth para lectores de tarjetas WisePad 3. El proceso de comparación numérica requiere que verifiques una clave de acceso tanto en tu lector de tarjetas como en el dispositivo del sistema POS al comparar. Después de actualizar tu dispositivo a la [última versión de software](https://docs.stripe.com/terminal/readers/bbpos-wisepad3.md#reader-software-releases), sigue estos pasos al conectar tu WisePad 3 a una nueva aplicación móvil. Después de que el dispositivo del sistema POS descubra y muestre el lector WisePad 3:

1. Verifica que el código de 6 dígitos coincida tanto en el WisePad 3 como en el sistema POS.
1. Selecciona **Confirmar** en el WisePad 3.
1. Selecciona **Emparejar** en el dispositivo de tu sistema POS.

> #### Nota
> 
> Solo necesitas hacer una comparación numérica cuando emparejas un WisePad 3 con un nuevo sistema POS o cuando lo reemparejas con un sistema POS existente «olvidado».

## Conectarse a un lector [Lado del cliente]

- [connectReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:connectionConfig:completion:)
- [BluetoothConnectionConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPBluetoothConnectionConfiguration.html)

Para conectarte a un lector detectado, llama al método `connectReader` desde tu aplicación.

Debes [registrar tu lector](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en una [ubicación](https://docs.stripe.com/api/terminal/locations.md) tras la conexión. Para hacerlo, crea y utiliza una `BluetoothConnectionConfiguration` con el `locationId` establecido en el ID de ubicación relevante al conectarte.

#### Swift

```swift
// Call `connectReader` with the selected reader and a connection config
// to register to a location as set by your app.
let connectionConfig: BluetoothConnectionConfiguration
do {
    connectionConfig = try BluetoothConnectionConfigurationBuilder(delegate: yourMobileReaderDelegate, locationId: ""{{LOCATION_ID}}"")
    .build()
} catch {
    // Handle the error building the connection configuration
    return
}
Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in
    if let reader = reader {
        print("Successfully connected to reader: \(reader)")
    } else if let error = error {
        print("connectReader failed: \(error)")
    }
}
```

Para que tu aplicación se ejecute en segundo plano y permanezca conectada al lector, [configúrala](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=ios#configure) para incluir el modo de segundo plano requerido.

> #### Usar el modo de espera
> 
> No programes tu aplicación para que llame a `disconnectReader` con el fin de ahorrar energía. El lector gestiona de forma eficiente la administración de energía usando su modo de espera.

## Gestiona las desconexiones del lector

- [MobileReaderDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPMobileReaderDelegate.html)
- [DisconnectReason (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPDisconnectReason.html)

A veces pueden producirse desconexiones del lector entre tu aplicación y el lector. Por ejemplo, el lector puede desconectarse de tu aplicación si it’s out of range, or runs out of battery. Para simular una desconexión inesperada durante las pruebas, puedes apagar el lector.

El `MobileReaderDelegate` incluye un método `reader:didDisconnect:` que proporciona a tu aplicación el `DisconnectReason` para ayudar a identificar por qué se desconectó el lector.

Para gestionar las desconexiones del lector, puedes hacer lo siguiente:

1. Establece `autoReconnectOnUnexpectedDisconnect` en `false` durante la conexión.
1. Gestiona la devolución de llamada de desconexión para mostrar un mensaje en la aplicación que alerte al usuario de que el lector se ha desconectado inesperadamente, y que se inicia la detección y conexión del lector.

#### Swift

```swift
import StripeTerminal

class ReaderViewController: UIViewController, MobileReaderDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        // Set the reader delegate when connecting to a reader
    }

    // ...



    func reader(_ reader: Reader, didDisconnect reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }
}
```

### Reinicia el lector conectado

- [rebootReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)rebootReader:.html)

Stripe Reader M2 y BBPOS WisePad 3 se reinician automáticamente después de 24 horas de funcionamiento. Sin embargo, puedes forzar al lector a que se reinicie y restablezca su temporizador de 24 horas con la API `rebootReader`. Después de esta acción, el lector se desconecta del SDK y se reinicia. Si estás utilizando la reconexión automática, el SDK intenta restaurar la conexión con el lector.

#### Swift

```swift
Terminal.shared.rebootReader { error in
    if let error = error {
        // Placeholder for handling the error
    } else {
        // Reboot succeeded and the reader will disconnect.
        // If your app is using automatic reconnect the reconnect will begin.
    }
}

```

#### Intenta la reconexión de forma automática

Cuando un lector se desconecta, intentamos reconectarlo automáticamente de forma predeterminada y te recomendamos que muestres notificaciones en tu aplicación que retransmitan el estado del lector durante todo el proceso.

Para mostrar notificaciones en tu aplicación durante la reconexión automática, haz lo siguiente:

1. Implementa las devoluciones de llamada de reconexión del lector en el `MobileReaderDelegate`.
1. Pasa el `MobileReaderDelegate` a tu `BluetoothConnectionConfiguration`.
1. Cuando el SDK envíe [`reader:didStartReconnect:disconnectReason:`](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)reader:didStartReconnect:disconnectReason:) a tu aplicación, muestra un mensaje que anuncie que el lector ha perdido la conexión y que la reconexión está en curso.
   - Puedes usar el objeto `Cancelable` para detener el intento de reconexión en cualquier momento.
1. Cuando el SDK indique una reconexión realizada correctamente enviando [`readerDidSucceedReconnect:`](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)readerDidSucceedReconnect:), muestra un mensaje anunciando que la conexión se ha restablecido y que se reanudarán las operaciones normales.
1. Si el SDK no puede volver a conectarse al lector y envía tanto [`readerDidFailReconnect:`](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)readerDidFailReconnect:) y `reader:didDisconnect:`, muestra un mensaje que indica que se ha producido una desconexión inesperada.

#### Swift

```swift
import StripeTerminal

extension ReaderViewController: MobileReaderDelegate {
    // MARK: MobileReaderDelegate

    func reader(_ reader: Reader, didStartReconnect cancelable: Cancelable, disconnectReason: DisconnectReason) {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
    }

    func readerDidSucceedReconnect(_ reader: Reader) {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
    }
    func readerDidFailReconnect(_ reader: Reader) {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
    }
}
```

#### Reconexión automática al iniciar la aplicación

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

1. Cuando te conectes a un lector de forma satisfactoria, guarda su número de serie en una ubicación de almacenamiento persistente de datos, como la [API UserDefaults](https://developer.apple.com/documentation/foundation/userdefaults) (iOS).

1. Cuando se inicie la aplicación, comprueba si hay un número de serie guardado en la ubicación de almacenamiento persistente de datos. Si se encuentra uno, llama al método `discoverReaders` para que tu aplicación pueda intentar encontrar ese lector nuevamente.
1. Si el número de serie guardado coincide con cualquiera de los lectores detectados, intenta conectarte a ese lector con el objeto de lector coincidente devuelto de la llamada a `discoverReaders`. Si no se encuentra el lector previamente conectado, detén el proceso de detección.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.

## Actualiza el software del lector [Lado del cliente]



- [MobileReaderDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPMobileReaderDelegate.html)

Tu aplicación debe actualizar los lectores móviles para aplicar lo siguiente:

- Configuraciones regionales que te mantienen al día respecto a los requisitos de la red de tarjetas y del emisor
- Actualizaciones de seguridad

Las actualizaciones necesarias comienzan a instalarse cuando te conectas al lector. No puedes usar el lector hasta que se complete la actualización.

> Para instalar actualizaciones, el nivel de batería del lector debe ser superior al 50&nbsp;%.

### Actualizaciones necesarias

Cuando las actualizaciones urgentes están disponibles para el lector, el `MobileReaderDelegate` de la integración recibe la devolución de llamada `didStartInstallingUpdate` con un `ReaderSoftwareUpdate`.

El `ReaderSoftwareUpdate` proporciona los detalles necesarios de la actualización, incluida una estimación de la duración total de la actualización, indicada por `durationEstimate`.

Durante el proceso de instalación, el `connectionStatus` del Terminal pasa a `connecting` mientras se instala la actualización en el lector.

Tu aplicación debe avisar a los usuarios de que se está instalando una actualización y mostrar el progreso en tu interfaz de usuario. Deja claro por qué la conexión puede tardar más de lo habitual.

Si falla el proceso de la actualización necesaria, Stripe comunica el error al `MobileReaderDelegate` con `didFinishInstallingUpdate`. No puedes volver a conectarte al lector después de que falle la actualización requerida, a menos que se cumplan las siguientes condiciones:

- El lector ejecuta la última versión del software disponible para la ubicación en los últimos 30 días.
- La versión del SDK de iOS es mayor o igual a `3.5.0`.

Si se cumplen las condiciones, el proceso de conexión se realiza correctamente a pesar de una actualización incompleta. Stripe volverá a intentar realizar la actualización necesaria la próxima vez que te conectes a ese lector hasta que se instale correctamente.

#### Swift

```swift
import UIKit
import StripeTerminal

class ReaderViewController: UIViewController, MobileReaderDelegate {

    // ...

    // MARK: MobileReaderDelegate

    func reader(_ reader: Reader, didStartInstallingUpdate update: ReaderSoftwareUpdate, cancelable: Cancelable?) {
        // Show UI communicating that a required update has started installing
    }

    func reader(_ reader: Reader, didReportReaderSoftwareUpdateProgress progress: Float) {
        // Update the progress of the installation
    }

    func reader(_ reader: Reader, didFinishInstallingUpdate update: ReaderSoftwareUpdate?, error: Error?) {
        // Report success or failure of the update
    }

    // ...
}
```

Puedes cancelar las actualizaciones obligatorias usando el objeto `Cancelable`, lo que también hace que falle la conexión con el lector. No puedes cancelar las actualizaciones incrementales en curso.

### Actualizaciones opcionales

Puedes aplazar las actualizaciones opcionales hasta la fecha especificada, después de la cual serán obligatorias. El SDK te avisa de las actualizaciones opcionales a través del `MobileReaderDelegate` en cualquier momento en que el lector esté conectado pero no realizando una transacción. Si está disponible una actualización opcional, el `MobileReaderDelegate` de tu aplicación recibe la devolución de llamada `didReportAvailableUpdate` con el objeto `ReaderSoftwareUpdate` que contiene los detalles de la actualización, incluyendo:

- Tiempo estimado para que se complete la actualización (`durationEstimate`)
- Marca de tiempo a partir de la cual se requiere la actualización (`requiredAt`)

En tu aplicación, notifica a los usuarios que hay una actualización disponible y muestra un mensaje para continuar opcionalmente con la actualización.

Para proceder a la actualización previamente informada con `didReportAvailableUpdate`, llama a `Terminal.shared.installAvailableUpdate`.

La actualización disponible también se almacena en el objeto lector como `reader.availableUpdate`.

A medida que avanza la actualización, bloquea al usuario para que no abandone la página en tu aplicación e indícale que debe mantener el lector dentro del alcance y encendido hasta que se complete la actualización. Recomendamos también que le proporciones a tu usuario un indicador visual del progreso de la actualización. El `MobileReaderDelegate` informa del progreso de la actualización en el método `didReportReaderSoftwareUpdateProgress`.

Cuando haya pasado la fecha `requiredAt` de una actualización opcional, la actualización se instalará la próxima vez que se conecte el lector.

#### Swift

```swift
import UIKit
import StripeTerminal

class ReaderViewController: UIViewController, MobileReaderDelegate {

    // ...

    // MARK: MobileReaderDelegate

    func reader(_ reader: Reader, didReportAvailableUpdate update: ReaderSoftwareUpdate) {
        // An update is available for the connected reader. Show this update in your application.
        // Install this update using `Terminal.shared.installAvailableUpdate`.
    }

}
```

Para obtener más información sobre cómo asegurarse de que la aplicación gestiona los diferentes tipos de actualizaciones que puede tener un lector, consulta [Prueba de actualizaciones del lector](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates).


# Lectores Bluetooth

> This is a Lectores Bluetooth for when terminal-sdk-platform is android and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=bluetooth.

Los lectores conectados por Bluetooth son dispositivos Bluetooth LE. Recopilan detalles de pago, pero dependen de un dispositivo móvil emparejado para la comunicación con Stripe.

Para conectar la aplicación a un lector Terminal mediante Bluetooth, sigue estos pasos:

1. [Descubrir lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers).
1. [Conectar a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader).

> No uses la configuración del dispositivo móvil para emparejarlo con tu lector. Emparejar el lector a través de la configuración del dispositivo hace que el lector no esté disponible para conectarse a tu aplicación.

## Detectar lectores [Lado del cliente]

- [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html)
- [BluetoothDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-bluetooth-discovery-configuration/index.html)

Para empezar, asegúrate de que el lector esté encendido y cerca de él.

Luego, desde tu aplicación, busca lectores cercanos conectados a Bluetooth con el método `discoverReaders`, usando `BluetoothDiscoveryConfiguration`.

#### Kotlin

```kotlin
class DiscoverReadersActivity : AppCompatActivity(), DiscoveryListener {

    var discoverCancelable: Cancelable? = null

    // ...

    // Action for a "Discover Readers" button
    fun discoverReadersAction() {
        val timeout = 0
        val isSimulated = false

        val config = BluetoothDiscoveryConfiguration(
            timeout = timeout,
            isSimulated = isSimulated
        )

        discoverCancelable = Terminal.getInstance().discoverReaders(
            config,
            this,
            object : Callback {
                override fun onSuccess() {
                    // Placeholder for handling successful operation
                }

                override fun onFailure(e: TerminalException) {
                    // Placeholder for handling exception
                }
            }
        )
    }

    // DiscoveryListener
    override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
        // In your app, display the discovered readers to the user.
        // Call `connectReader` after the user selects a reader to connect to.
    }
}
```

#### Escaneo Bluetooth

El escaneo Bluetooth busca todos los lectores cercanos y devuelve a tu aplicación una lista de lectores detectados. A medida que continúa el proceso de detección, el SDK sigue invocando el método `onUpdateDiscoveredReaders` con la última lista de lectores cercanos.

Durante el proceso de detección, el `connectionStatus` del Terminal pasa a `ConnectionStatus.DISCOVERING` mientras el descubrimiento está en curso.

Con el método de detección de escaneo Bluetooth, puedes establecer un tiempo de espera para escanear durante un período de tiempo determinado, que puedes usar para gestionar la vida útil de la batería o activar un mensaje de error si no se encuentran dispositivos.

En tu aplicación móvil, te recomendamos mostrar una lista que se actualice automáticamente con los lectores detectados y sus números de serie para ayudar a los usuarios a identificar su lector móvil. La propiedad `label` no se rellena para los lectores móviles durante la detección de lectores. Si necesitas mostrar nombres descriptivos para los lectores, mantén tu propia asignación de números de serie a etiquetas en tu aplicación.

#### Emparejamiento Bluetooth

Para mejorar la seguridad y cumplir con la normativa de la UE, a partir de noviembre de 2025 Stripe utiliza el proceso de comparación numérica Bluetooth para lectores de tarjetas WisePad 3. El proceso de comparación numérica requiere que verifiques una clave de acceso tanto en tu lector de tarjetas como en el dispositivo del sistema POS al comparar. Después de actualizar tu dispositivo a la [última versión de software](https://docs.stripe.com/terminal/readers/bbpos-wisepad3.md#reader-software-releases), sigue estos pasos al conectar tu WisePad 3 a una nueva aplicación móvil. Después de que el dispositivo del sistema POS descubra y muestre el lector WisePad 3:

1. Verifica que el código de 6 dígitos coincida tanto en el WisePad 3 como en el sistema POS.
1. Selecciona **Confirmar** en el WisePad 3.
1. Selecciona **Emparejar** en el dispositivo de tu sistema POS.

> #### Nota
> 
> Solo necesitas hacer una comparación numérica cuando emparejas un WisePad 3 con un nuevo sistema POS o cuando lo reemparejas con un sistema POS existente «olvidado».

## Conectarse a un lector [Lado del cliente]

- [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html)
- [BluetoothConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-bluetooth-connection-configuration/index.html)

Para conectarte a un lector detectado, llama al método `connectReader` desde tu aplicación.

Debes [registrar tu lector](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en una [ubicación](https://docs.stripe.com/api/terminal/locations.md) tras la conexión. Para hacerlo, crea y utiliza una `BluetoothConnectionConfiguration` con el `locationId` establecido en el ID de ubicación relevante al conectarte.

#### Kotlin

```kotlin
// Implement your MobileReaderListener
val mobileReaderListener = yourMobileReaderListener
val autoReconnectOnUnexpectedDisconnect = true

val connectionConfig = BluetoothConnectionConfiguration(
    ""{{LOCATION_ID}}"",
    autoReconnectOnUnexpectedDisconnect,
    mobileReaderListener
)

Terminal.getInstance().connectReader(
    selectedReader,
    connectionConfig,
    object : ReaderCallback {
        override fun onSuccess(reader: Reader) {
            // Placeholder for handling successful operation
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

> #### Usar el modo de espera
> 
> No programes tu aplicación para que llame a `disconnectReader` con el fin de ahorrar energía. El lector gestiona de forma eficiente la administración de energía usando su modo de espera.

## Gestiona las desconexiones del lector

- [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html)
- [DisconnectReason (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-disconnect-reason/index.html)

A veces pueden producirse desconexiones del lector entre tu aplicación y el lector. Por ejemplo, el lector puede desconectarse de tu aplicación si it’s out of range, or runs out of battery. Para simular una desconexión inesperada durante las pruebas, puedes apagar el lector.

El `MobileReaderListener` incluye una devolución de llamada `onDisconnect` que proporciona a tu aplicación el `DisconnectReason` para ayudar a identificar por qué se desconectó el lector.

Para gestionar las desconexiones del lector, puedes hacer lo siguiente:

1. Establece `autoReconnectOnUnexpectedDisconnect` en `false` durante la conexión.
1. Gestiona la devolución de llamada de desconexión para mostrar un mensaje en la aplicación que alerte al usuario de que el lector se ha desconectado inesperadamente, y que se inicia la detección y conexión del lector.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onDisconnect(reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

    // ...
}
```

### Reinicia el lector conectado

- [rebootReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/reboot-reader.html)

Stripe Reader M2 y BBPOS WisePad 3 se reinician automáticamente después de 24 horas de funcionamiento. Sin embargo, puedes forzar al lector a que se reinicie y restablezca su temporizador de 24 horas con la API `rebootReader`. Después de esta acción, el lector se desconecta del SDK y se reinicia. Si estás utilizando la reconexión automática, el SDK intenta restaurar la conexión con el lector.

#### Kotlin

```kotlin
Terminal.getInstance().rebootReader(
    object : Callback {
        override fun onSuccess() {
            // Reboot succeeded and the reader will disconnect.
            // If your app is using automatic reconnect the reconnect will begin.
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

#### Intenta la reconexión de forma automática

Cuando un lector se desconecta, intentamos reconectarlo automáticamente de forma predeterminada y te recomendamos que muestres notificaciones en tu aplicación que retransmitan el estado del lector durante todo el proceso.

Para mostrar notificaciones en tu aplicación durante la reconexión automática, haz lo siguiente:

1. Implementa las devoluciones de llamada de reconexión del lector en el `MobileReaderListener`.
1. Transfiere el `MobileReaderListener` a tu `BluetoothConnectionConfiguration`.
1. Cuando el SDK envía [onReaderReconnectStarted](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-started.html) a tu aplicación, muestra un mensaje anunciando que el lector ha perdido la conexión y que la reconexión está en curso.
   - Puedes usar el objeto `Cancelable` para detener el intento de reconexión en cualquier momento.
1. Cuando el SDK indique una reconexión exitosa enviando [`onReaderReconnectSucceeded`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-succeeded.html), muestra un mensaje anunciando que la conexión se ha restaurado y que se reanudará el funcionamiento con normalidad.
1. Si el SDK no puede volver a conectarse al lector y envía tanto [`onReaderReconnectFailed`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-failed.html) como `onDisconnect`, muestra un mensaje que indique que se ha producido una desconexión inesperada.

#### Kotlin

```kotlin
class CustomMobileReaderListener : MobileReaderListener {
    // ...

    override fun onReaderReconnectStarted(reader: Reader, cancelReconnect: Cancelable, reason: DisconnectReason) {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
    }

    override fun onReaderReconnectSucceeded(reader: Reader) {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
    }

    override fun onReaderReconnectFailed(reader: Reader) {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
    }

    // ...
}
```

#### Reconexión automática al iniciar la aplicación

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

1. Cuando te conectes a un lector de forma satisfactoria, guarda su número de serie en una ubicación de almacenamiento persistente de datos, como la [API Shared Preferences](https://developer.android.com/training/data-storage/shared-preferences) (Android).

1. Cuando se inicie la aplicación, comprueba si hay un número de serie guardado en la ubicación de almacenamiento persistente de datos. Si se encuentra uno, llama al método `discoverReaders` para que tu aplicación pueda intentar encontrar ese lector nuevamente.
1. Si el número de serie guardado coincide con cualquiera de los lectores detectados, intenta conectarte a ese lector con el objeto de lector coincidente devuelto de la llamada a `discoverReaders`. Si no se encuentra el lector previamente conectado, detén el proceso de detección.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.

## Actualiza el software del lector [Lado del cliente]



- [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html)

Tu aplicación debe actualizar los lectores móviles para aplicar lo siguiente:

- Configuraciones regionales que te mantienen al día respecto a los requisitos de la red de tarjetas y del emisor
- Actualizaciones de seguridad

Las actualizaciones necesarias comienzan a instalarse cuando te conectas al lector. No puedes usar el lector hasta que se complete la actualización.

> Para instalar actualizaciones, el nivel de batería del lector debe ser superior al 50&nbsp;%.

### Actualizaciones necesarias

Cuando las actualizaciones urgentes están disponibles para el lector, el `MobileReaderListener` de la integración recibe `onStartInstallingUpdate` con un `ReaderSoftwareUpdate`.

El `ReaderSoftwareUpdate` proporciona los detalles necesarios de la actualización, incluida una estimación de la duración total de la actualización, indicada por `durationEstimate`.

Durante el proceso de instalación, el `connectionStatus` del Terminal pasa a `ConnectionStatus.CONNECTING` mientras la actualización se instala en el lector.

Tu aplicación debe avisar a los usuarios de que se está instalando una actualización y mostrar el progreso en tu interfaz de usuario. Deja claro por qué la conexión puede tardar más de lo habitual.

Si falla el proceso de la actualización necesaria, Stripe comunica el error al `MobileReaderListener` con `onFinishInstallingUpdate`. No puedes volver a conectarte al lector después de que falle la actualización requerida, a menos que se cumplan las siguientes condiciones:

- El lector ejecuta la última versión del software disponible para la ubicación en los últimos 30 días.
- La versión del SDK de Android es mayor o igual a `3.5.0`.

Si se cumplen las condiciones, el proceso de conexión se realiza correctamente a pesar de una actualización incompleta. Stripe volverá a intentar realizar la actualización necesaria la próxima vez que te conectes a ese lector hasta que se instale correctamente.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onStartInstallingUpdate(update: ReaderSoftwareUpdate, cancelable: Cancelable) {
        // Show UI communicating that a required update has started installing
    }

    override fun onReportReaderSoftwareUpdateProgress(progress: Float) {
        // Update the progress of the installation
    }

    override fun onFinishInstallingUpdate(update: ReaderSoftwareUpdate?, e: TerminalException?) {
        // Report success or failure of the update
    }

    // ...
}
```

Puedes cancelar las actualizaciones obligatorias usando el objeto `Cancelable`, lo que también hace que falle la conexión con el lector. No puedes cancelar las actualizaciones incrementales en curso.

### Actualizaciones opcionales

Puedes aplazar las actualizaciones opcionales hasta la fecha especificada, después de la cual serán obligatorias. El SDK te avisa de las actualizaciones opcionales a través del `MobileReaderListener` en cualquier momento en que el lector esté conectado pero no realizando una transacción. Si está disponible una actualización opcional, el `MobileReaderListener` de tu aplicación recibe la devolución de llamada `onReportAvailableUpdate` con el objeto `ReaderSoftwareUpdate` que contiene los detalles de la actualización, incluyendo:

- Tiempo estimado para que se complete la actualización (`durationEstimate`)
- Fecha a partir de la cual se requiere la actualización (`requiredAt`)

En tu aplicación, notifica a los usuarios que hay una actualización disponible y muestra un mensaje para continuar opcionalmente con la actualización.

Para proceder a la actualización previamente informada con `onReportAvailableUpdate`, llama a `Terminal.getInstance().installAvailableUpdate`.

La actualización disponible también se almacena en el objeto lector como `reader.availableUpdate`.

A medida que avanza la actualización, bloquea al usuario para que no abandone la página en tu aplicación e indícale que debe mantener el lector dentro del alcance y encendido hasta que se complete la actualización. Recomendamos también que le proporciones a tu usuario un indicador visual del progreso de la actualización. El `MobileReaderListener` informa del progreso de la actualización en el método `onReportReaderSoftwareUpdateProgress`.

Cuando haya pasado la fecha `requiredAt` de una actualización opcional, la actualización se instalará la próxima vez que se conecte el lector.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onReportAvailableUpdate(update: ReaderSoftwareUpdate) {
        // An update is available for the connected reader. Show this update in your application.
        // Install this update using `Terminal.getInstance().installAvailableUpdate`.
    }

    // ...
}
```

Para obtener más información sobre cómo asegurarse de que la aplicación gestiona los diferentes tipos de actualizaciones que puede tener un lector, consulta [Prueba de actualizaciones del lector](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates).


# Lectores Bluetooth

> This is a Lectores Bluetooth for when terminal-sdk-platform is react-native and reader-type is bluetooth. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=bluetooth.

Los lectores conectados por Bluetooth son dispositivos Bluetooth LE. Recopilan detalles de pago, pero dependen de un dispositivo móvil emparejado para la comunicación con Stripe.

Para conectar la aplicación a un lector Terminal mediante Bluetooth, sigue estos pasos:

1. [Descubrir lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers).
1. [Conectar a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader).

> No uses la configuración del dispositivo móvil para emparejarlo con tu lector. Emparejar el lector a través de la configuración del dispositivo hace que el lector no esté disponible para conectarse a tu aplicación.

## Detectar lectores [Lado del cliente]

- [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders)

Para empezar, asegúrate de que el lector esté encendido y cerca de él.

Luego, desde tu aplicación, busca lectores cercanos conectados a Bluetooth con el método `discoverReaders`, estableciendo `discoveryMethod` en `bluetoothScan`.

```js
function DiscoverReadersScreen() {
  const { discoverReaders, discoveredReaders } =
    useStripeTerminal({
      onUpdateDiscoveredReaders: (readers) => {
        // After the SDK discovers a reader, your app can connect to it.
      },
    });

  useEffect(() => {
    handleDiscoverReaders();
  }, [discoverReaders]);

  const handleDiscoverReaders = async () => {
    // The list of discovered readers is reported in the `onUpdateDiscoveredReaders` method
    // within the `useStripeTerminal` hook.
    const { error } = await discoverReaders({
      discoveryMethod: 'bluetoothScan',
    });

    if (error) {
      Alert.alert(
        'Discover readers error: ',
        `${error.code}, ${error.message}`
      );
    }
  };

  return <View />;
}
```

#### Escaneo Bluetooth

El escaneo Bluetooth busca todos los lectores cercanos y devuelve a tu aplicación una lista de lectores detectados. A medida que continúa el proceso de detección, el SDK sigue invocando `onUpdateDiscoveredReaders` dentro del hook `useStripeTerminal` con la última lista de lectores cercanos.

Con el método de detección de escaneo Bluetooth, puedes establecer un tiempo de espera para escanear durante un período de tiempo determinado, que puedes usar para gestionar la vida útil de la batería o activar un mensaje de error si no se encuentran dispositivos.

En tu aplicación móvil, te recomendamos mostrar una lista que se actualice automáticamente con los lectores detectados y sus números de serie para ayudar a los usuarios a identificar su lector móvil. La propiedad `label` no se rellena para los lectores móviles durante la detección de lectores. Si necesitas mostrar nombres descriptivos para los lectores, mantén tu propia asignación de números de serie a etiquetas en tu aplicación.

#### Emparejamiento Bluetooth

Para mejorar la seguridad y cumplir con la normativa de la UE, a partir de noviembre de 2025 Stripe utiliza el proceso de comparación numérica Bluetooth para lectores de tarjetas WisePad 3. El proceso de comparación numérica requiere que verifiques una clave de acceso tanto en tu lector de tarjetas como en el dispositivo del sistema POS al comparar. Después de actualizar tu dispositivo a la [última versión de software](https://docs.stripe.com/terminal/readers/bbpos-wisepad3.md#reader-software-releases), sigue estos pasos al conectar tu WisePad 3 a una nueva aplicación móvil. Después de que el dispositivo del sistema POS descubra y muestre el lector WisePad 3:

1. Verifica que el código de 6 dígitos coincida tanto en el WisePad 3 como en el sistema POS.
1. Selecciona **Confirmar** en el WisePad 3.
1. Selecciona **Emparejar** en el dispositivo de tu sistema POS.

> #### Nota
> 
> Solo necesitas hacer una comparación numérica cuando emparejas un WisePad 3 con un nuevo sistema POS o cuando lo reemparejas con un sistema POS existente «olvidado».

## Conectarse a un lector [Lado del cliente]

- [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1)

Para conectarte a un lector detectado, llama al método `connectReader` desde tu aplicación.

Debes [registrar tu lector](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en una [ubicación](https://docs.stripe.com/api/terminal/locations.md) tras la conexión. Para hacerlo, asegúrate de que `locationId` esté establecido en el ID de ubicación relevante al conectarte.

```js
const handleConnectBluetoothReader = async (id) => {
  const { reader, error } = await connectReader({
    discoveryMethod: 'bluetoothScan',
    reader: selectedReader,
    locationId: {{LOCATION_ID}},
  });

  if (error) {
    console.log('connectReader error', error);
    return;
  }

  console.log('Reader connected successfully', reader);
};
```

> #### Usar el modo de espera
> 
> No programes tu aplicación para que llame a `disconnectReader` con el fin de ahorrar energía. El lector gestiona de forma eficiente la administración de energía usando su modo de espera.

## Gestiona las desconexiones del lector

- [REPORT_UNEXPECTED_READER_DISCONNECT (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#REPORT_UNEXPECTED_READER_DISCONNECT)
- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks)
- [DisconnectReason (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/modules/Reader.html#DisconnectReason)

A veces pueden producirse desconexiones del lector entre tu aplicación y el lector. Por ejemplo, el lector puede desconectarse de tu aplicación si it’s out of range, or runs out of battery. Para simular una desconexión inesperada durante las pruebas, puedes apagar el lector.

`UserCallbacks` incluye `onDidDisconnect` que proporciona a tu aplicación el `DisconnectReason` para ayudar a identificar por qué se desconectó el lector.

Para gestionar las desconexiones del lector, puedes hacer lo siguiente:

1. Establece `autoReconnectOnUnexpectedDisconnect` en `false` durante la conexión.
1. Gestiona la devolución de llamada de desconexión para mostrar un mensaje en la aplicación que alerte al usuario de que el lector se ha desconectado inesperadamente, y que se inicia la detección y conexión del lector.

```js
const terminal = useStripeTerminal({
  onDidDisconnect: (result) => {
    // Consider displaying a UI to notify the user and start rediscovering readers
  },
});
```

### Reinicia el lector conectado

- [rebootReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#rebootReader)

Stripe Reader M2 y BBPOS WisePad 3 se reinician automáticamente después de 24 horas de funcionamiento. Sin embargo, puedes forzar al lector a que se reinicie y restablezca su temporizador de 24 horas con la API `rebootReader`. Después de esta acción, el lector se desconecta del SDK y se reinicia. Si estás utilizando la reconexión automática, el SDK intenta restaurar la conexión con el lector.

```js
const { error } = await rebootReader();

if (error) {
  console.log('rebootReader error:', error);
  return;
}

console.log('rebootReader succeeded');
```

#### Intenta la reconexión de forma automática

Cuando un lector se desconecta, intentamos reconectarlo automáticamente de forma predeterminada y te recomendamos que muestres notificaciones en tu aplicación que retransmitan el estado del lector durante todo el proceso.

Para mostrar notificaciones en tu aplicación durante la reconexión automática, haz lo siguiente:

1. Establece `autoReconnectOnUnexpectedDisconnect` en true en `ConnectBluetoothReaderParams`.
1. Implementa las devoluciones de llamada de reconexión automática que se encuentran en `UserCallbacks`.
1. Cuando el SDK envía `onDidStartReaderReconnect` a tu aplicación, muestra un mensaje que anuncie que el lector ha perdido la conexión y que la reconexión está en curso.
   - Puedes usar `cancelReaderReconnection` para detener el intento de reconexión en cualquier momento.
1. Cuando el SDK indique que se ha reconectado correctamente enviando `onDidSucceedReaderReconnect`, muestra un mensaje que indique que se ha restablecido la conexión y que se reanudará el funcionamiento con normalidad.
1. Si el SDK no puede volver a conectarse al lector y envía `onDidFailReaderReconnect`, muestra un mensaje que indique que se ha producido una desconexión inesperada.

#### Reconexión automática al iniciar la aplicación

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

1. Cuando te conectes a un lector de forma satisfactoria, guarda su número de serie en una ubicación de almacenamiento persistente de datos, como [Async Storage](https://github.com/react-native-async-storage/async-storage) (React Native).

1. Cuando se inicie la aplicación, comprueba si hay un número de serie guardado en la ubicación de almacenamiento persistente de datos. Si se encuentra uno, llama al método `discoverReaders` para que tu aplicación pueda intentar encontrar ese lector nuevamente.
1. Si el número de serie guardado coincide con cualquiera de los lectores detectados, intenta conectarte a ese lector con el objeto de lector coincidente devuelto de la llamada a `discoverReaders`. Si no se encuentra el lector previamente conectado, detén el proceso de detección.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.

## Actualiza el software del lector [Lado del cliente]



- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks)

Tu aplicación debe actualizar los lectores móviles para aplicar lo siguiente:

- Configuraciones regionales que te mantienen al día respecto a los requisitos de la red de tarjetas y del emisor
- Actualizaciones de seguridad

Las actualizaciones necesarias comienzan a instalarse cuando te conectas al lector. No puedes usar el lector hasta que se complete la actualización.

> Para instalar actualizaciones, el nivel de batería del lector debe ser superior al 50&nbsp;%.

### Actualizaciones necesarias

Cuando las actualizaciones urgentes están disponibles para el lector, la integración recibe `onDidStartInstallingUpdate` del hook `useStripeTerminal` con un `Reader.SoftwareUpdate`.

El `Reader.SoftwareUpdate` proporciona los detalles necesarios de la actualización, incluida una estimación de la duración total de la actualización, indicada por `estimatedUpdateTime`.

Durante el proceso de instalación, el `connectionStatus` del Terminal pasa a `"connecting"` mientras la actualización se instala en el lector.

Tu aplicación debe avisar a los usuarios de que se está instalando una actualización y mostrar el progreso en tu interfaz de usuario. Deja claro por qué la conexión puede tardar más de lo habitual.

Si falla el proceso de la actualización requerida, Stripe comunica el error al hook `useStripeTerminal` con `onDidFinishInstallingUpdate`. No puedes volver a conectarte al lector después de que falle la actualización requerida, a menos que se cumplan las siguientes condiciones:

- El lector ejecuta la última versión del software disponible para la ubicación en los últimos 30 días.
- La versión del SDK de React Native es mayor o igual a `0.0.1-beta.18`.

Si se cumplen las condiciones, el proceso de conexión se realiza correctamente a pesar de una actualización incompleta. Stripe volverá a intentar realizar la actualización necesaria la próxima vez que te conectes a ese lector hasta que se instale correctamente.

```js
const terminal = useStripeTerminal({
  onDidReportReaderSoftwareUpdateProgress: (progress) => {
    setCurrentProgress((Number(progress) * 100).toFixed(0).toString());
  },
  onDidFinishInstallingUpdate: ({ error }) => {
  },
  onDidStartInstallingUpdate: (update) => {
  },
});
```

Puedes cancelar las actualizaciones obligatorias usando la API `cancelInstallingUpdate`, lo que también hace que falle la conexión con el lector. No puedes cancelar las actualizaciones incrementales en curso.

### Actualizaciones opcionales

Puedes aplazar las actualizaciones opcionales hasta la fecha especificada, después de la cual serán obligatorias. El SDK te avisa de las actualizaciones opcionales a través de la devolución de llamada `onDidReportAvailableUpdate` desde el hook `useStripeTerminal` cada vez que el lector está conectado pero no realiza una transacción. Si hay una actualización opcional disponible, el hook `useStripeTerminal` de tu aplicación recibe la devolución de llamada `onDidReportAvailableUpdate` con el objeto `SoftwareUpdate` que contiene los detalles de la actualización, entre los que se incluyen los siguientes:

- Tiempo estimado para completar la actualización (`estimatedUpdateTime`)
- Fecha a partir de la cual se requiere la actualización (`requiredAt`)

En tu aplicación, notifica a los usuarios que hay una actualización disponible y muestra un mensaje para continuar opcionalmente con la actualización.

Para continuar con la actualización previamente reportada con `onDidReportAvailableUpdate`, llama a `installAvailableUpdate` desde el hook `useStripeTerminal`.

La actualización disponible también se almacena en el objeto lector como `reader.availableUpdate`.

A medida que avanza la actualización, bloquea al usuario para que no abandone la página en tu aplicación e indícale que debe mantener el lector dentro del alcance y encendido hasta que se complete la actualización. Recomendamos también que le proporciones a tu usuario un indicador visual del progreso de la actualización. El hook `useStripeTerminal` informa del progreso de la actualización en el método `onDidReportReaderSoftwareUpdateProgress`.

Cuando haya pasado la fecha `requiredAt` de una actualización opcional, la actualización se instalará la próxima vez que se conecte el lector.

```js
const terminal = useStripeTerminal({
  onDidReportAvailableUpdate: (update) => {
    // An update is available for the connected reader. Show this update in your application.
    // Install this update using the `installAvailableUpdate` method from the `useStripeTerminal` hook.
  },
});
```

Para obtener más información sobre cómo asegurarse de que la aplicación gestiona los diferentes tipos de actualizaciones que puede tener un lector, consulta [Prueba de actualizaciones del lector](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates).


# Lectores USB

> This is a Lectores USB for when terminal-sdk-platform is android and reader-type is usb. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=usb.

Utiliza el Stripe Terminal Android SDK 3.0.0  (o posterior) para admitir conexiones USB para los lectores del [lector de Stripe M2](https://docs.stripe.com/terminal/payments/setup-reader/stripe-m2.md) y del [BBPOS WisePad 3](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepad3.md).

Debes usar un cable USB que acepta tanto transferencia de datos como carga, como el cable USB&nbsp;2.0 que se incluye con el Stripe Reader M2 y el BBPOS WisePad 3. Si el cable incluido con tu lector de Terminal solo es de carga, utiliza un cable USB&nbsp;2.0 de terceros que también pueda transferir datos.

Para conectar la aplicación a un lector de Terminal con un cable USB, haz lo siguiente:

1. [Detecta lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers).
1. [Conéctate a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader).

## Detectar lectores [Lado del cliente]

- [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html)
- [UsbDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-usb-discovery-configuration/index.html)

Asegúrate de que el lector esté encendido y conectado con un cable USB&nbsp;2.0 al dispositivo que ejecuta la aplicación, y de que se haya otorgado permiso para acceder al lector conectado a USB.

Si conectas el lector por primera vez, aparece un mensaje del sistema Android para conectarse al lector. Puedes seleccionar la casilla de verificación «Abrir siempre» para abrir la aplicación sin que se te solicite cuándo esté conectada a un lector.

Luego, desde tu aplicación, busca el lector conectado con el método `discoverReaders`, utilizando  `UsbDiscoveryConfiguration`.

#### Kotlin

```kotlin
class DiscoverReadersActivity : AppCompatActivity(), DiscoveryListener {
    // ...

    var discoverCancelable: Cancelable? = null

    // Action for a "Discover Readers" button
    fun discoverReadersAction() {
        val timeout = 0
        val isSimulated = false

        val config = UsbDiscoveryConfiguration(
            timeout = timeout,
            isSimulated = isSimulated
        )

        Terminal.getInstance().discoverReaders(
            config,
            this,
            object : Callback {
                override fun onSuccess() {
                    // Placeholder for handling successful operation
                }

                override fun onFailure(e: TerminalException) {
                    // Placeholder for handling exception
                }
            }
        )
    }

    override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
        // In your app, display the discovered readers to the user.
        // Call `connectReader` after the user selects a reader to connect to.
    }

    // ...
}
```

## Conectarse a un lector [Lado del cliente]

- [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html)
- [UsbConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-usb-connection-configuration/index.html)

Para conectarte a un lector detectado, llama al método `connectReader` desde tu aplicación.

Debes [registrar tu lector](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en una [ubicación](https://docs.stripe.com/api/terminal/locations.md) tras la conexión. Para hacerlo,  crea y usa una `UsbConnectionConfiguration` con el `locationId` establecido en el ID de ubicación relevante  al conectarte.

#### Kotlin

```kotlin
// Implement your MobileReaderListener
val mobileReaderListener = yourMobileReaderListener
val autoReconnectOnUnexpectedDisconnect = true

val connectionConfig = UsbConnectionConfiguration(
    ""{{LOCATION_ID}}"",
    autoReconnectOnUnexpectedDisconnect,
    mobileReaderListener
)

Terminal.getInstance().connectReader(
    selectedReader,
    connectionConfig,
    object : ReaderCallback {
        override fun onSuccess(reader: Reader) {
            // Placeholder for handling successful operation
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

> #### Usar el modo de espera
> 
> No programes tu aplicación para que llame a `disconnectReader` con el fin de ahorrar energía. El lector gestiona de forma eficiente la administración de energía usando su modo de espera.

## Gestiona las desconexiones del lector

- [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html)
- [DisconnectReason (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-disconnect-reason/index.html)

A veces pueden producirse desconexiones del lector entre tu aplicación y el lector. Por ejemplo, el lector puede desconectarse de tu aplicación si el cable USB que lo conecta a tu dispositivo está desconectado. Para simular una desconexión inesperada durante las pruebas, puedes apagar el lector.

El `MobileReaderListener` incluye una devolución de llamada `onDisconnect` que proporciona a tu aplicación el `DisconnectReason` para ayudar a identificar por qué se desconectó el lector.

Para gestionar las desconexiones del lector, puedes hacer lo siguiente:

1. Establece `autoReconnectOnUnexpectedDisconnect` en `false` durante la conexión.
1. Gestiona la devolución de llamada de desconexión para mostrar un mensaje en la aplicación que alerte al usuario de que el lector se ha desconectado inesperadamente, y que se inicia la detección y conexión del lector.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onDisconnect(reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

    // ...
}
```

### Reinicia el lector conectado

- [rebootReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/reboot-reader.html)

Stripe Reader M2 y BBPOS WisePad 3 se reinician automáticamente después de 24 horas de funcionamiento. Sin embargo, puedes forzar al lector a que se reinicie y restablezca su temporizador de 24 horas con la API `rebootReader`. Después de esta acción, el lector se desconecta del SDK y se reinicia. Si estás utilizando la reconexión automática, el SDK intenta restaurar la conexión con el lector.

#### Kotlin

```kotlin
Terminal.getInstance().rebootReader(
    object : Callback {
        override fun onSuccess() {
            // Reboot succeeded and the reader will disconnect.
            // If your app is using automatic reconnect the reconnect will begin.
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

#### Intenta la reconexión de forma automática

Cuando un lector se desconecta, intentamos reconectarlo automáticamente de forma predeterminada y te recomendamos que muestres notificaciones en tu aplicación que retransmitan el estado del lector durante todo el proceso.

Para mostrar notificaciones en tu aplicación durante la reconexión automática, haz lo siguiente:

1. Implementa las devoluciones de llamada de reconexión del lector en el `MobileReaderListener`.
1. Transfiere el `MobileReaderListener` a tu `UsbConnectionConfiguration`.
1. Cuando el SDK envía [onReaderReconnectStarted](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-started.html) a tu aplicación, muestra un mensaje anunciando que el lector ha perdido la conexión y que la reconexión está en curso.
   - Puedes usar el objeto `Cancelable` para detener el intento de reconexión en cualquier momento.
1. Cuando el SDK indique una reconexión exitosa enviando [`onReaderReconnectSucceeded`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-succeeded.html), muestra un mensaje anunciando que la conexión se ha restaurado y que se reanudará el funcionamiento con normalidad.
1. Si el SDK no puede volver a conectarse al lector y envía tanto [`onReaderReconnectFailed`](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-reconnection-listener/on-reader-reconnect-failed.html) como `onDisconnect`, muestra un mensaje que indique que se ha producido una desconexión inesperada.

#### Kotlin

```kotlin
class CustomMobileReaderListener : MobileReaderListener {
    // ...

    override fun onReaderReconnectStarted(reader: Reader, cancelReconnect: Cancelable, reason: DisconnectReason) {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
    }

    override fun onReaderReconnectSucceeded(reader: Reader) {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
    }

    override fun onReaderReconnectFailed(reader: Reader) {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
    }

    // ...
}
```

#### Reconexión automática al iniciar la aplicación

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

1. Cuando te conectes a un lector de forma satisfactoria, guarda su número de serie en una ubicación de almacenamiento persistente de datos, como la [API Shared Preferences](https://developer.android.com/training/data-storage/shared-preferences) (Android).

1. Cuando se inicie la aplicación, comprueba si hay un número de serie guardado en la ubicación de almacenamiento persistente de datos. Si se encuentra uno, llama al método `discoverReaders` para que tu aplicación pueda intentar encontrar ese lector nuevamente.
1. Si el número de serie guardado coincide con cualquiera de los lectores detectados, intenta conectarte a ese lector con el objeto de lector coincidente devuelto de la llamada a `discoverReaders`. Si no se encuentra el lector previamente conectado, detén el proceso de detección.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.

## Actualiza el software del lector [Lado del cliente]



- [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html)

Tu aplicación debe actualizar los lectores móviles para aplicar lo siguiente:

- Configuraciones regionales que te mantienen al día respecto a los requisitos de la red de tarjetas y del emisor
- Actualizaciones de seguridad

Las actualizaciones necesarias comienzan a instalarse cuando te conectas al lector. No puedes usar el lector hasta que se complete la actualización.

> Para instalar actualizaciones, el nivel de batería del lector debe ser superior al 50&nbsp;%.

### Actualizaciones necesarias

Cuando las actualizaciones urgentes están disponibles para el lector, el `MobileReaderListener` de la integración recibe `onStartInstallingUpdate` con un `ReaderSoftwareUpdate`.

El `ReaderSoftwareUpdate` proporciona los detalles necesarios de la actualización, incluida una estimación de la duración total de la actualización, indicada por `durationEstimate`.

Durante el proceso de instalación, el `connectionStatus` del Terminal pasa a `ConnectionStatus.CONNECTING` mientras la actualización se instala en el lector.

Tu aplicación debe avisar a los usuarios de que se está instalando una actualización y mostrar el progreso en tu interfaz de usuario. Deja claro por qué la conexión puede tardar más de lo habitual.

Si falla el proceso de la actualización necesaria, Stripe comunica el error al `MobileReaderListener` con `onFinishInstallingUpdate`. No puedes volver a conectarte al lector después de que falle la actualización requerida, a menos que se cumplan las siguientes condiciones:

- El lector ejecuta la última versión del software disponible para la ubicación en los últimos 30 días.
- La versión del SDK de Android es mayor o igual a `3.5.0`.

Si se cumplen las condiciones, el proceso de conexión se realiza correctamente a pesar de una actualización incompleta. Stripe volverá a intentar realizar la actualización necesaria la próxima vez que te conectes a ese lector hasta que se instale correctamente.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onStartInstallingUpdate(update: ReaderSoftwareUpdate, cancelable: Cancelable) {
        // Show UI communicating that a required update has started installing
    }

    override fun onReportReaderSoftwareUpdateProgress(progress: Float) {
        // Update the progress of the installation
    }

    override fun onFinishInstallingUpdate(update: ReaderSoftwareUpdate?, e: TerminalException?) {
        // Report success or failure of the update
    }

    // ...
}
```

Puedes cancelar las actualizaciones obligatorias usando el objeto `Cancelable`, lo que también hace que falle la conexión con el lector. No puedes cancelar las actualizaciones incrementales en curso.

### Actualizaciones opcionales

Puedes aplazar las actualizaciones opcionales hasta la fecha especificada, después de la cual serán obligatorias. El SDK te avisa de las actualizaciones opcionales a través del `MobileReaderListener` en cualquier momento en que el lector esté conectado pero no realizando una transacción. Si está disponible una actualización opcional, el `MobileReaderListener` de tu aplicación recibe la devolución de llamada `onReportAvailableUpdate` con el objeto `ReaderSoftwareUpdate` que contiene los detalles de la actualización, incluyendo:

- Tiempo estimado para que se complete la actualización (`durationEstimate`)
- Fecha a partir de la cual se requiere la actualización (`requiredAt`)

En tu aplicación, notifica a los usuarios que hay una actualización disponible y muestra un mensaje para continuar opcionalmente con la actualización.

Para proceder a la actualización previamente informada con `onReportAvailableUpdate`, llama a `Terminal.getInstance().installAvailableUpdate`.

La actualización disponible también se almacena en el objeto lector como `reader.availableUpdate`.

A medida que avanza la actualización, bloquea al usuario para que no abandone la página en tu aplicación e indícale que debe mantener el lector conectado hasta que se complete la actualización. Recomendamos también que le proporciones a tu usuario un indicador visual del progreso de la actualización. El `MobileReaderListener` informa del progreso de la actualización en el método `onReportReaderSoftwareUpdateProgress`.

Cuando haya pasado la fecha `requiredAt` de una actualización opcional, la actualización se instalará la próxima vez que se conecte el lector.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), MobileReaderListener {
    // ...

    override fun onReportAvailableUpdate(update: ReaderSoftwareUpdate) {
        // An update is available for the connected reader. Show this update in your application.
        // Install this update using `Terminal.getInstance().installAvailableUpdate`.
    }

    // ...
}
```

Para obtener más información sobre cómo asegurarse de que la aplicación gestiona los diferentes tipos de actualizaciones que puede tener un lector, consulta [Prueba de actualizaciones del lector](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates).


# Lectores USB

> This is a Lectores USB for when terminal-sdk-platform is react-native and reader-type is usb. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=usb.

> #### Compatibilidad con plataformas
> 
> Por el momento, la compatibilidad para conectarse a lectores móviles mediante el SDK para React Native está limitada a la plataforma Android.

Utiliza el Stripe Terminal  React Native SDK beta.13  (o posterior) para admitir conexiones USB para los lectores del [lector de Stripe M2](https://docs.stripe.com/terminal/payments/setup-reader/stripe-m2.md) y del [BBPOS WisePad 3](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepad3.md).

Debes usar un cable USB que acepta tanto transferencia de datos como carga, como el cable USB&nbsp;2.0 que se incluye con el Stripe Reader M2 y el BBPOS WisePad 3. Si el cable incluido con tu lector de Terminal solo es de carga, utiliza un cable USB&nbsp;2.0 de terceros que también pueda transferir datos.

Para conectar la aplicación a un lector de Terminal con un cable USB, haz lo siguiente:

1. [Detecta lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers).
1. [Conéctate a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader).

## Detectar lectores [Lado del cliente]

- [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverreaders-1)
- [DiscoveryReaderParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/types/DiscoverReadersParams.html)

Asegúrate de que el lector esté encendido y conectado con un cable USB&nbsp;2.0 al dispositivo que ejecuta la aplicación, y de que se haya otorgado permiso para acceder al lector conectado a USB.

Si conectas el lector por primera vez, aparece un mensaje del sistema Android para conectarse al lector. Puedes seleccionar la casilla de verificación «Abrir siempre» para abrir la aplicación sin que se te solicite cuándo esté conectada a un lector.

Luego, desde tu aplicación, busca el lector conectado con el método `discoverReaders`, utilizando  `usb` como `DiscoveryMethod` .

```js
function DiscoverReadersScreen() {
  const { discoverReaders, discoveredReaders } =
    useStripeTerminal({
      onUpdateDiscoveredReaders: (readers) => {
        // After the SDK discovers a reader, your app can connect to it.
      },
    });

  useEffect(() => {
    handleDiscoverReaders();
  }, []);

  const handleDiscoverReaders = async () => {
    // The list of discovered readers is reported in the `onUpdateDiscoveredReaders` method
    // within the `useStripeTerminal` hook.
    const { error } = await discoverReaders({
      discoveryMethod: 'usb',
    });

    if (error) {
      Alert.alert(
        'Discover readers error: ',
        `${error.code}, ${error.message}`
      );
    }
  };

  return <View />;
}
```

## Conectarse a un lector [Lado del cliente]

- [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1)
- [ConnectUsbReaderParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/ConnectUsbReaderParams.html)

Para conectarte a un lector detectado, llama al método `connectReader` desde tu aplicación.

Debes [registrar tu lector](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en una [ubicación](https://docs.stripe.com/api/terminal/locations.md) tras la conexión. Para hacerlo,  especifica el `locationId` relevante en `ConnectUsbReaderParams`  al conectarte.

```js
const handleConnectUsbReader = async (id) => {
  const { reader, error } = await connectReader({
    discoveryMethod: 'usb',
    reader: selectedReader,
    locationId: {{LOCATION_ID}},
  });

  if (error) {
    console.log('connectReader error', error);
    return;
  }

  console.log('Reader connected successfully', reader);
};
```

> #### Usar el modo de espera
> 
> No programes tu aplicación para que llame a `disconnectReader` con el fin de ahorrar energía. El lector gestiona de forma eficiente la administración de energía usando su modo de espera.

## Gestiona las desconexiones del lector

- [REPORT_UNEXPECTED_READER_DISCONNECT (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#REPORT_UNEXPECTED_READER_DISCONNECT)
- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks)
- [DisconnectReason (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/modules/Reader.html#DisconnectReason)

A veces pueden producirse desconexiones del lector entre tu aplicación y el lector. Por ejemplo, el lector puede desconectarse de tu aplicación si el cable USB que lo conecta a tu dispositivo está desconectado. Para simular una desconexión inesperada durante las pruebas, puedes apagar el lector.

`UserCallbacks` incluye `onDidDisconnect` que proporciona a tu aplicación el `DisconnectReason` para ayudar a identificar por qué se desconectó el lector.

Para gestionar las desconexiones del lector, puedes hacer lo siguiente:

1. Establece `autoReconnectOnUnexpectedDisconnect` en `false` durante la conexión.
1. Gestiona la devolución de llamada de desconexión para mostrar un mensaje en la aplicación que alerte al usuario de que el lector se ha desconectado inesperadamente, y que se inicia la detección y conexión del lector.

```js
const terminal = useStripeTerminal({
  onDidDisconnect: (result) => {
    // Consider displaying a UI to notify the user and start rediscovering readers
  },
});
```

### Reinicia el lector conectado

- [rebootReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#rebootReader)

Stripe Reader M2 y BBPOS WisePad 3 se reinician automáticamente después de 24 horas de funcionamiento. Sin embargo, puedes forzar al lector a que se reinicie y restablezca su temporizador de 24 horas con la API `rebootReader`. Después de esta acción, el lector se desconecta del SDK y se reinicia. Si estás utilizando la reconexión automática, el SDK intenta restaurar la conexión con el lector.

```js
const { error } = await rebootReader();

if (error) {
  console.log('rebootReader error:', error);
  return;
}

console.log('rebootReader succeeded');
```

#### Intenta la reconexión de forma automática

Cuando un lector se desconecta, intentamos reconectarlo automáticamente de forma predeterminada y te recomendamos que muestres notificaciones en tu aplicación que retransmitan el estado del lector durante todo el proceso.

Para mostrar notificaciones en tu aplicación durante la reconexión automática, haz lo siguiente:

1. Establece `autoReconnectOnUnexpectedDisconnect` en true en `ConnectUsbReaderParams`.
1. Implementa las devoluciones de llamada de reconexión automática que se encuentran en `UserCallbacks`.
1. Cuando el SDK envía `onDidStartReaderReconnect` a tu aplicación, muestra un mensaje que anuncie que el lector ha perdido la conexión y que la reconexión está en curso.
   - Puedes usar `cancelReaderReconnection` para detener el intento de reconexión en cualquier momento.
1. Cuando el SDK indique que se ha reconectado correctamente enviando `onDidSucceedReaderReconnect`, muestra un mensaje que indique que se ha restablecido la conexión y que se reanudará el funcionamiento con normalidad.
1. Si el SDK no puede volver a conectarse al lector y envía `onDidFailReaderReconnect`, muestra un mensaje que indique que se ha producido una desconexión inesperada.

#### Reconexión automática al iniciar la aplicación

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

1. Cuando te conectes a un lector de forma satisfactoria, guarda su número de serie en una ubicación de almacenamiento persistente de datos, como [Async Storage](https://github.com/react-native-async-storage/async-storage) (React Native).

1. Cuando se inicie la aplicación, comprueba si hay un número de serie guardado en la ubicación de almacenamiento persistente de datos. Si se encuentra uno, llama al método `discoverReaders` para que tu aplicación pueda intentar encontrar ese lector nuevamente.
1. Si el número de serie guardado coincide con cualquiera de los lectores detectados, intenta conectarte a ese lector con el objeto de lector coincidente devuelto de la llamada a `discoverReaders`. Si no se encuentra el lector previamente conectado, detén el proceso de detección.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.

## Actualiza el software del lector [Lado del cliente]



- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks)

Tu aplicación debe actualizar los lectores móviles para aplicar lo siguiente:

- Configuraciones regionales que te mantienen al día respecto a los requisitos de la red de tarjetas y del emisor
- Actualizaciones de seguridad

Las actualizaciones necesarias comienzan a instalarse cuando te conectas al lector. No puedes usar el lector hasta que se complete la actualización.

> Para instalar actualizaciones, el nivel de batería del lector debe ser superior al 50&nbsp;%.

### Actualizaciones necesarias

Cuando las actualizaciones urgentes están disponibles para el lector, la integración recibe `onDidStartInstallingUpdate` del hook `useStripeTerminal` con un `Reader.SoftwareUpdate`.

El `Reader.SoftwareUpdate` proporciona los detalles necesarios de la actualización, incluida una estimación de la duración total de la actualización, indicada por `estimatedUpdateTime`.

Durante el proceso de instalación, el `connectionStatus` del Terminal pasa a `"connecting"` mientras la actualización se instala en el lector.

Tu aplicación debe avisar a los usuarios de que se está instalando una actualización y mostrar el progreso en tu interfaz de usuario. Deja claro por qué la conexión puede tardar más de lo habitual.

Si falla el proceso de la actualización requerida, Stripe comunica el error al hook `useStripeTerminal` con `onDidFinishInstallingUpdate`. No puedes volver a conectarte al lector después de que falle la actualización requerida, a menos que se cumplan las siguientes condiciones:

- El lector ejecuta la última versión del software disponible para la ubicación en los últimos 30 días.
- La versión del SDK de React Native es mayor o igual a `0.0.1-beta.18`.

Si se cumplen las condiciones, el proceso de conexión se realiza correctamente a pesar de una actualización incompleta. Stripe volverá a intentar realizar la actualización necesaria la próxima vez que te conectes a ese lector hasta que se instale correctamente.

```js
const terminal = useStripeTerminal({
  onDidReportReaderSoftwareUpdateProgress: (progress) => {
    setCurrentProgress((Number(progress) * 100).toFixed(0).toString());
  },
  onDidFinishInstallingUpdate: ({ error }) => {
  },
  onDidStartInstallingUpdate: (update) => {
  },
});
```

Puedes cancelar las actualizaciones obligatorias usando la API `cancelInstallingUpdate`, lo que también hace que falle la conexión con el lector. No puedes cancelar las actualizaciones incrementales en curso.

### Actualizaciones opcionales

Puedes aplazar las actualizaciones opcionales hasta la fecha especificada, después de la cual serán obligatorias. El SDK te avisa de las actualizaciones opcionales a través de la devolución de llamada `onDidReportAvailableUpdate` desde el hook `useStripeTerminal` cada vez que el lector está conectado pero no realiza una transacción. Si hay una actualización opcional disponible, el hook `useStripeTerminal` de tu aplicación recibe la devolución de llamada `onDidReportAvailableUpdate` con el objeto `SoftwareUpdate` que contiene los detalles de la actualización, entre los que se incluyen los siguientes:

- Tiempo estimado para completar la actualización (`estimatedUpdateTime`)
- Fecha a partir de la cual se requiere la actualización (`requiredAt`)

En tu aplicación, notifica a los usuarios que hay una actualización disponible y muestra un mensaje para continuar opcionalmente con la actualización.

Para continuar con la actualización previamente reportada con `onDidReportAvailableUpdate`, llama a `installAvailableUpdate` desde el hook `useStripeTerminal`.

La actualización disponible también se almacena en el objeto lector como `reader.availableUpdate`.

A medida que avanza la actualización, bloquea al usuario para que no abandone la página en tu aplicación e indícale que debe mantener el lector dentro del alcance y encendido hasta que se complete la actualización. Recomendamos también que le proporciones a tu usuario un indicador visual del progreso de la actualización. El hook `useStripeTerminal` informa del progreso de la actualización en el método `onDidReportReaderSoftwareUpdateProgress`.

Cuando haya pasado la fecha `requiredAt` de una actualización opcional, la actualización se instalará la próxima vez que se conecte el lector.

```js
const terminal = useStripeTerminal({
  onDidReportAvailableUpdate: (update) => {
    // An update is available for the connected reader. Show this update in your application.
    // Install this update using the `installAvailableUpdate` method from the `useStripeTerminal` hook.
  },
});
```

Para obtener más información sobre cómo asegurarse de que la aplicación gestiona los diferentes tipos de actualizaciones que puede tener un lector, consulta [Prueba de actualizaciones del lector](https://docs.stripe.com/terminal/references/testing.md#simulated-reader-updates).


# Lectores de Internet

> This is a Lectores de Internet for when terminal-sdk-platform is server-driven and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=server-driven&reader-type=internet.

Los lectores inteligentes ejecutan el software del lector de Stripe para comunicarse directamente con Stripe a través de Internet. Antes de poder conectar tu aplicación a un lector inteligente, debes registrar el lector en tu cuenta de Stripe.

#### Dashboard

Puedes registrar tu lector directamente en el [Dashboard](https://dashboard.stripe.com/terminal).

#### Registro por código de registro

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. Introduce el código de registro y haz clic en **Siguiente**.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por número de serie

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Busca el número de serie en el dispositivo e introdúcelo. Para registrar varios dispositivos a la vez, puedes introducir varios números de serie separados por comas.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector. Solo puedes registrar lectores que tú o tu plataforma hayáis pedido.

#### Registro por pedido de hardware

1. En la página [Pedidos de hardware](https://dashboard.stripe.com/terminal/hardware_orders), busca un pedido con el estado «enviado» o «entregado». Haz clic en el menú de desbordamiento (⋯) que aparece al final de la fila y, luego, en **Registrar**.
1. En la página **Registrar lectores**, elige uno o más lectores del pedido de hardware para registrar y haz clic en **Registrar**.
1. Opcionalmente, elige un nombre para el lector. Si has elegido varios lectores, el nombre sirve como prefijo y nombramos los lectores secuencialmente (por ejemplo, para una entrada determinada de «Lector de prueba», nombramos a los lectores «Lector de prueba 1», «Lector de prueba 2» y así sucesivamente).
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tus lectores.

#### API

Para implementaciones más grandes, permite que los usuarios del campo reciban y configuren nuevos lectores por su cuenta. En tu aplicación, crea un flujo para [registrar](https://docs.stripe.com/api/terminal/readers/create.md) un lector con la API de Stripe.

1. Ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y luego pulsa **Generar código de emparejamiento**.
1. El usuario introduce el código en tu aplicación.
1. Tu aplicación envía el código a Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode "label=Alice's reader" \
  -d "location={{TERMINALLOCATION_ID}}"
```

Para confirmar que has registrado un lector correctamente, enumera todos los lectores que has registrado en esa ubicación:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

Después de registrar el lector, este está listo para usarse con la integración basada en el servidor. Te recomendamos que guardes el ID del lector (`tmr_xxx`) en tu aplicación para que sepas a qué lector enviar las transacciones desde tu punto de venta. Puedes recuperar los ID de los lectores mediante el punto de conexión de los [lectores de la lista](https://docs.stripe.com/api/terminal/readers/list.md).


# Lectores de Internet

> This is a Lectores de Internet for when terminal-sdk-platform is js and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=js&reader-type=internet.

> #### Recomendación para lectores inteligentes
> 
> Para lectores inteligentes, como el [lector BBPOS WisePOS E](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md), el [Stripe Reader S700/S710](https://docs.stripe.com/terminal/readers/stripe-reader-s700-s710.md) y los [lectores Verifone](https://docs.stripe.com/terminal/payments/setup-reader/verifone.md), recomendamos utilizar la [integración basada en servidor](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=server-driven) en vez del SDK de JavaScript.
> 
> El SDK de JavaScript requiere que tu sistema POS y tu lector estén en la misma red local con un DNS local operativo. La integración basada en servidor utiliza la API de Stripe, lo que puede resultar más sencillo en entornos de red complejos. Consulta nuestra [comparación de plataformas](https://docs.stripe.com/terminal/payments/setup-reader.md#sdk) para ayudarte a elegir la mejor plataforma para tus necesidades.

Los lectores inteligentes ejecutan el software del lector de Stripe para comunicarse directamente con Stripe a través de Internet. Conectar tu aplicación a un lector inteligente requiere tres pasos:

1. [Registrar un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) en tu cuenta de Stripe.
1. [Detectar lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) con el SDK.
1. [Conectar a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) con el SDK.

## Registra un lector [Lado del servidor]

Antes de poder conectar tu aplicación a un lector inteligente, debes registrar el lector en tu cuenta.

#### Dashboard

### Regístrate en el Dashboard

Puedes añadir tu lector directamente en el [Dashboard](https://dashboard.stripe.com/test/terminal).

#### Registro por código de registro

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. Introduce el código de registro y haz clic en **Siguiente**.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por número de serie

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Busca el número de serie en el dispositivo e introdúcelo. Para registrar varios dispositivos a la vez, puedes introducir varios números de serie separados por comas.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por pedido de hardware

1. En la página [Pedidos de hardware](https://dashboard.stripe.com/terminal/hardware_orders), busca un pedido con el estado «enviado» o «entregado». Haz clic en el menú de desbordamiento (⋯) que aparece al final de la fila y, luego, en **Registrar**.
1. En la página **Registrar lectores**, elige uno o más lectores del pedido de hardware para registrar y haz clic en **Registrar**.
1. Opcionalmente, elige un nombre para el lector. Si has elegido varios lectores, el nombre sirve como prefijo y nombramos los lectores secuencialmente (por ejemplo, para una entrada determinada de «Lector de prueba», nombramos a los lectores «Lector de prueba 1», «Lector de prueba 2» y así sucesivamente).
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tus lectores.

#### API

Para implementaciones más grandes, permite que los usuarios del campo reciban y configuren nuevos lectores por su cuenta. En tu aplicación, crea un flujo para [registrar](https://docs.stripe.com/api/terminal/readers/create.md) un lector con la API de Stripe.

1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. El usuario introduce el código en tu aplicación.
1. Tu aplicación envía el código a Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode "label=Alice's reader" \
  -d "location={{TERMINALLOCATION_ID}}"
```

Para confirmar que has registrado un lector correctamente, enumera todos los lectores que has registrado en esa ubicación:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Detectar lectores [Lado del cliente]

- [discoverReaders (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#discover-readers)

Tras registrar el lector en tu cuenta, busca los lectores registrados anteriormente para conectarlos a tu aplicación de punto de venta con `discoverReaders`, estableciendo `discoveryMethod` en `internet`.

Puedes determinar el alcance de tu descubrimiento utilizando la `location` en la que registraste al lector en el paso anterior.

```javascript
async function discoverReaders() {
  const config = {simulated: false, location: "{{LOCATION_ID}}"}
  const discoverResult = await terminal.discoverReaders(config);
  if (discoverResult.error) {
    console.log('Failed to discover: ', discoverResult.error);
  } else if (discoverResult.discoveredReaders.length === 0) {
    console.log('No available readers.');
  } else {
    // You should show the list of discoveredReaders to the
    // cashier here and let them select which to connect to (see below).
    connectReader(discoverResult);
  }
}
```

## Conectarse a un lector [Lado del cliente]

> Chrome 142 (lanzado el 28 de octubre de 2025) y las versiones posteriores requieren un permiso explícito antes de que los sitios web puedan acceder a los dispositivos de la red local (como los lectores de Terminal) cuando se utiliza el SDK de JavaScript de Stripe Terminal. Para conocer los pasos de configuración y la resolución de problemas, consulta las [instrucciones de Chrome 142+](https://support.stripe.com/questions/ensuring-stripe-terminal-javascript-sdk-functionality-on-chrome-142).

Para conectar tu aplicación de punto de venta a un lector, llama a [connectReader](https://docs.stripe.com/terminal/references/api/js-sdk.md#connect-reader) con el lector seleccionado.

```javascript
async function connectReader(discoverResult) {
  // Just select the first reader here.
  const selectedReader = discoverResult.discoveredReaders[0];

  const connectResult = await terminal.connectReader(selectedReader);
  if (connectResult.error) {
    console.log('Failed to connect:', connectResult.error);
  } else {
    console.log('Connected to reader:', connectResult.reader.label);
  }
}
```

- [connectReader (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#connect-reader)

### Múltiples conexiones

Solo una instancia del SDK de Stripe Terminal puede conectarse a un lector en un momento dado. De forma predeterminada, cuando llamas a `connectReader` desde otra aplicación, la conexión entrante reemplaza la conexión existente del SDK al lector y el SDK conectado previamente se desconecta del lector. El método `connectReader` toma un objeto de configuración con una propiedad `fail_if_in_use`, cuyo valor predeterminado es `false`. Cuando tu aplicación establece `fail_if_in_use` como verdadero, la llamada a `connectReader` tiene un comportamiento alternativo en el que la conexión entrante falla cuando el lector está en medio de una llamada `collectPaymentMethod` o `processPayment` iniciada por otro SDK. Si el lector está conectado a otro SDK pero está inactivo (muestra la pantalla de bienvenida antes de llamar a `collectPaymentMethod`), establecer `fail_if_in_use` no cambia el comportamiento de la conexión y la solicitud de conexión entrante siempre puede interrumpir la conexión existente del SDK al lector.

```javascript
const connectResult = await terminal.connectReader(reader, {fail_if_in_use: true});
```

|                                                                                              | fail_if_in_use es false (predeterminado)                                                                                                                                                                                                              | fail_if_in_use es true                                                                                                                                                                                                                                |
| -------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connectReader` llamado desde un nuevo SDK cuando el lector está inactivo.                   | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDisconnect` de esa aplicación. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDisconnect` de esa aplicación. |
| `connectReader` llamado desde un nuevo SDK cuando el lector está en medio de la transacción. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDisconnect` de esa aplicación. | La conexión entrante falla con un error del lector. La conexión existente del SDK al lector no se interrumpe y el comando en curso continúa.                                                                                                          |

Para una experiencia de conexión menos disruptiva en entornos de múltiples lectores, recomendamos establecer `fail_if_in_use` en `true` en el intento de conexión inicial de la aplicación. Luego, permite que los usuarios vuelvan a intentar la conexión con `fail_if_in_use` establecido en `false` si la conexión falla la primera vez.

Con esta configuración, ninguno de tus usuarios podrá interrumpir una transacción de forma accidental al conectarse por error a un lector en uso, pero podrá seguir conectándose si es necesario.

### Gestiona las desconexiones

- [StripeTerminal.create (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#stripeterminal-create)

Tu aplicación debe implementar la devolución de llamada `onUnexpectedReaderDisconnect` para gestionar la desconexión de un lector. Cuando implementes esta devolución de llamada, muestra una interfaz de usuario que avise a tu usuario del lector desconectado. Puedes llamar a `discoverReaders` para buscar lectores e iniciar la reconexión.

La aplicación puede intentar volver a conectarse automáticamente al lector desconectado o mostrar una interfaz de usuario que solicite al usuario que se vuelva a conectar a un lector diferente.

El lector puede desconectarse de tu aplicación si pierde la conexión a la red. Para simular una desconexión inesperada, apaga el lector.

```javascript
const terminal = StripeTerminal.create({
  onFetchConnectionToken: fetchConnectionToken,
  onUnexpectedReaderDisconnect: unexpectedDisconnect,
});

function unexpectedDisconnect() {
  // Consider displaying a UI to notify the user and start rediscovering readers
}
```

### Reconexión automática

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

1. Cuando te conectes correctamente a un lector, guarda su número de serie en una ubicación de almacenamiento persistente de datos, como la [API localStorage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage).
1. Cuando se inicie la aplicación, comprueba que el almacenamiento persistente tenga un número de serie guardado. Si encuentras uno, llama al método `discoverReaders` para que tu aplicación pueda intentar encontrar ese lector nuevamente.
1. Si el número de serie guardado coincide con cualquiera de los lectores detectados, intenta conectarte a ese lector con el objeto de lector coincidente devuelto de la llamada a `discoverReaders`. Si no se encuentra el lector previamente conectado, detén el proceso de detección.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.


# Lectores de Internet

> This is a Lectores de Internet for when terminal-sdk-platform is ios and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=internet.

Los lectores inteligentes ejecutan el software del lector de Stripe para comunicarse directamente con Stripe a través de Internet. Conectar tu aplicación a un lector inteligente requiere tres pasos:

1. [Registrar un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) en tu cuenta de Stripe.
1. [Detectar lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) con el SDK.
1. [Conectar a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) con el SDK.

## Registra un lector [Lado del servidor]

Antes de poder conectar tu aplicación a un lector inteligente, debes registrar el lector en tu cuenta.

#### Dashboard

### Regístrate en el Dashboard

Puedes añadir tu lector directamente en el [Dashboard](https://dashboard.stripe.com/test/terminal).

#### Registro por código de registro

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. Introduce el código de registro y haz clic en **Siguiente**.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por número de serie

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Busca el número de serie en el dispositivo e introdúcelo. Para registrar varios dispositivos a la vez, puedes introducir varios números de serie separados por comas.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por pedido de hardware

1. En la página [Pedidos de hardware](https://dashboard.stripe.com/terminal/hardware_orders), busca un pedido con el estado «enviado» o «entregado». Haz clic en el menú de desbordamiento (⋯) que aparece al final de la fila y, luego, en **Registrar**.
1. En la página **Registrar lectores**, elige uno o más lectores del pedido de hardware para registrar y haz clic en **Registrar**.
1. Opcionalmente, elige un nombre para el lector. Si has elegido varios lectores, el nombre sirve como prefijo y nombramos los lectores secuencialmente (por ejemplo, para una entrada determinada de «Lector de prueba», nombramos a los lectores «Lector de prueba 1», «Lector de prueba 2» y así sucesivamente).
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tus lectores.

#### API

Para implementaciones más grandes, permite que los usuarios del campo reciban y configuren nuevos lectores por su cuenta. En tu aplicación, crea un flujo para [registrar](https://docs.stripe.com/api/terminal/readers/create.md) un lector con la API de Stripe.

1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. El usuario introduce el código en tu aplicación.
1. Tu aplicación envía el código a Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode "label=Alice's reader" \
  -d "location={{TERMINALLOCATION_ID}}"
```

Para confirmar que has registrado un lector correctamente, enumera todos los lectores que has registrado en esa ubicación:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Detectar lectores [Lado del cliente]

- [discoverReaders (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:)
- [InternetDiscoveryConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPInternetDiscoveryConfiguration.html)

Después de registrar el lector en tu cuenta, busca lectores registrados previamente para conectarte a tu aplicación de punto de venta con `discoverReaders`, usando `InternetDiscoveryConfiguration`.

Puedes determinar el alcance de tu descubrimiento utilizando la `location` en la que registraste al lector en el paso anterior.

#### Swift

```swift
import StripeTerminal

class DiscoverReadersViewController: UIViewController, DiscoveryDelegate {
  func discoverReadersAction() throws {
      let config = try InternetDiscoveryConfigurationBuilder()
                          .setLocationId(""{{LOCATION_ID}}"")
                          .build()
      // In addition to Terminal's completion block methods, Swift async alternatives are available.
      // See our Example app for usage examples: https://github.com/stripe/stripe-terminal-ios/tree/master/Example
      self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in
          if let error = error {
              print("discoverReaders failed: \(error)")
          } else {
              print("discoverReaders succeeded")
          }
      }
  }
}
```

Al descubrir lectores inteligentes, el método `DiscoveryDelegate.didUpdateDiscoveredReaders` solo se llama una vez por llamada a `discoverReaders`. `didUpdateDiscoveredReaders`devuelve una lista vacía de lectores si no hay lectores registrados o si no hay lectores asociados con la ubicación dada. Si realizas una llamada posterior de `discoverReaders` para actualizar la lista, primero debes cancelar la llamada anterior con el `Cancelable` devuelto por `discoverReaders`.

La `InternetDiscoveryConfiguration` admite un valor opcional de `timeout` para descubrir lectores en Internet. Esto garantiza una alternativa más rápida a la detección del lector sin conexión si falla el intento en Internet.

## Conectarse a un lector [Lado del cliente]

> En la versión `5.1.0` del SDK de iOS, puedes utilizar el método `easyConnect` para combinar la detección y la conexión del lector en una única llamada a la API para simplificar la integración. Consulta la [guía de migración del SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage-ios) para obtener más información.

Para conectar tu aplicación de punto de venta a un lector, llama a `connectReader` con el lector seleccionado, usando `InternetConnectionConfiguration`.

#### Swift

```swift
let config: InternetConnectionConfiguration
do {
    config = try InternetConnectionConfigurationBuilder(delegate: yourInternetReaderDelegate)
        .build()
} catch {
    // Handle error building the connection configuration
    return
}

Terminal.shared.connectReader(selectedReader, connectionConfig: config) { reader, error in
    if let reader = reader {
        print("Successfully connected to reader: \(reader)")
    } else if let error = error {
        print("connectReader failed: \(error)")
    }
}
```

- [connectReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:connectionConfig:completion:)
- [InternetConnectionConfiguration](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPInternetConnectionConfiguration.html)

### Múltiples conexiones

Solo una instancia del SDK de Stripe Terminal puede conectarse a un lector en un momento dado. De forma predeterminada, cuando llamas a `connectReader` desde otra aplicación, la conexión entrante reemplaza la conexión existente del SDK al lector y el SDK conectado previamente se desconecta del lector. El método `connectReader` toma un objeto de configuración con una propiedad `failIfInUse`, cuyo valor predeterminado es `false`. Cuando tu aplicación establece `failIfInUse` en true, la llamada `connectReader` tiene un comportamiento alternativo en el que la conexión entrante falla cuando el lector está en medio de una llamada `collectPaymentMethod` o `confirmPaymentIntent` iniciada por otro SDK. Si el lector está conectado a otro SDK pero está inactivo (muestra la pantalla de bienvenida antes de llamar a `collectPaymentMethod`), establecer `failIfInUse` no tiene ningún cambio en el comportamiento de la conexión y la solicitud de conexión entrante siempre puede interrumpir la conexión existente del SDK al lector.

#### Swift

```swift
let internetReaderDelegate = yourInternetReaderDelegate // implement your internetReaderDelegate

let config: InternetConnectionConfiguration
do {
    config = try InternetConnectionConfigurationBuilder(delegate: internetReaderDelegate)
          .setFailIfInUse(true)
          .build()
} catch {
    // Handle error building the connection configuration
    return
}
Terminal.shared.connectReader(selectedReader, connectionConfig: config, completion: { reader, error in
    // ...
})
```

|                                                                                              | failIfInUse es false (predeterminado)                                                                                                                                                                                                                  | failIfInUse es true                                                                                                                                                                                                                                    |
| -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `connectReader` llamado desde un nuevo SDK cuando el lector está inactivo.                   | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `didDisconnect` de esa aplicación. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `didDisconnect` de esa aplicación. |
| `connectReader` llamado desde un nuevo SDK cuando el lector está en medio de la transacción. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `didDisconnect` de esa aplicación. | La conexión entrante falla con un error del lector. La conexión existente del SDK al lector no se interrumpe y el comando en curso continúa.                                                                                                           |

Para obtener la experiencia de conexión menos disruptiva en entornos de múltiples lectores, recomendamos establecer `failIfInUse` en `true` en el intento de conexión inicial de la aplicación. Luego, permite que los usuarios vuelvan a intentar la conexión con `failIfInUse` establecido en `false` si la conexión falla la primera vez.

Con esta configuración, ninguno de tus usuarios podrá interrumpir una transacción de forma accidental al conectarse por error a un lector en uso, pero podrá seguir conectándose si es necesario.

### Gestiona las desconexiones

- [didDisconnect (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)reader:didDisconnect:)

Tu aplicación debe implementar la devolución de llamada `reader(_, didDisconnect:)` para gestionar la desconexión de un lector. Cuando implementes esta devolución de llamada, muestra una interfaz de usuario que avise a tu usuario del lector desconectado. Puedes llamar a `discoverReaders` para buscar lectores e iniciar la reconexión.

La aplicación puede intentar volver a conectarse automáticamente al lector desconectado o mostrar una interfaz de usuario que solicite al usuario que se vuelva a conectar a un lector diferente.

El lector puede desconectarse de tu aplicación si pierde la conexión a la red. Para simular una desconexión inesperada, apaga el lector.

#### Swift

```swift
import StripeTerminal

class ReaderViewController: UIViewController, InternetReaderDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        // Set the reader delegate when connecting to a reader
    }

    // ...



    func reader(_ reader: Reader, didDisconnect reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }
}
```

### Reconexión automática

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

1. Cuando te conectes a un lector de forma satisfactoria, guarda su número de serie en una ubicación de almacenamiento persistente de datos, como la [API UserDefaults](https://developer.apple.com/documentation/foundation/userdefaults) (iOS)
1. Cuando se inicie la aplicación, comprueba que el almacenamiento persistente tenga un número de serie guardado. Si encuentras uno, llama al método `discoverReaders` para que tu aplicación pueda intentar encontrar ese lector nuevamente.
1. Si el número de serie guardado coincide con cualquiera de los lectores detectados, intenta conectarte a ese lector con el objeto de lector coincidente devuelto de la llamada a `discoverReaders`. Si no se encuentra el lector previamente conectado, detén el proceso de detección.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.


# Lectores de Internet

> This is a Lectores de Internet for when terminal-sdk-platform is android and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=internet.

Los lectores inteligentes ejecutan el software del lector de Stripe para comunicarse directamente con Stripe a través de Internet. Conectar tu aplicación a un lector inteligente requiere tres pasos:

1. [Registrar un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) en tu cuenta de Stripe.
1. [Detectar lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) con el SDK.
1. [Conectar a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) con el SDK.

## Registra un lector [Lado del servidor]

Antes de poder conectar tu aplicación a un lector inteligente, debes registrar el lector en tu cuenta.

#### Dashboard

### Regístrate en el Dashboard

Puedes añadir tu lector directamente en el [Dashboard](https://dashboard.stripe.com/test/terminal).

#### Registro por código de registro

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. Introduce el código de registro y haz clic en **Siguiente**.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por número de serie

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Busca el número de serie en el dispositivo e introdúcelo. Para registrar varios dispositivos a la vez, puedes introducir varios números de serie separados por comas.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por pedido de hardware

1. En la página [Pedidos de hardware](https://dashboard.stripe.com/terminal/hardware_orders), busca un pedido con el estado «enviado» o «entregado». Haz clic en el menú de desbordamiento (⋯) que aparece al final de la fila y, luego, en **Registrar**.
1. En la página **Registrar lectores**, elige uno o más lectores del pedido de hardware para registrar y haz clic en **Registrar**.
1. Opcionalmente, elige un nombre para el lector. Si has elegido varios lectores, el nombre sirve como prefijo y nombramos los lectores secuencialmente (por ejemplo, para una entrada determinada de «Lector de prueba», nombramos a los lectores «Lector de prueba 1», «Lector de prueba 2» y así sucesivamente).
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tus lectores.

#### API

Para implementaciones más grandes, permite que los usuarios del campo reciban y configuren nuevos lectores por su cuenta. En tu aplicación, crea un flujo para [registrar](https://docs.stripe.com/api/terminal/readers/create.md) un lector con la API de Stripe.

1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. El usuario introduce el código en tu aplicación.
1. Tu aplicación envía el código a Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode "label=Alice's reader" \
  -d "location={{TERMINALLOCATION_ID}}"
```

Para confirmar que has registrado un lector correctamente, enumera todos los lectores que has registrado en esa ubicación:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Detectar lectores [Lado del cliente]

- [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html)
- [InternetDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-internet-discovery-configuration/index.html)

Después de registrar el lector en tu cuenta, busca lectores registrados previamente para conectarte a tu aplicación de punto de venta con `discoverReaders`, usando `InternetDiscoveryConfiguration`.

Puedes determinar el alcance de tu descubrimiento utilizando la `location` en la que registraste al lector en el paso anterior.

#### Kotlin

```kotlin
var discoveryCancelable: Cancelable? = null

fun onDiscoverReaders() {
    val timeout = 0
    val isSimulated = false

    val config = InternetDiscoveryConfiguration(
        timeout = timeout,
        isSimulated = isSimulated,
        location = ""{{LOCATION_ID}}""
    )

    // Save this cancelable to an instance variable
    discoveryCancelable = Terminal.getInstance().discoverReaders(
        config,
        object : DiscoveryListener {
            override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
                // Display the discovered readers to the user
            }
        },
        object : Callback {
            override fun onSuccess() {
                // Placeholder for handling successful operation
            }

            override fun onFailure(e: TerminalException) {
                // Placeholder for handling exception
            }
        }
    )
}

override fun onStop() {
    super.onStop()

    // If you're leaving the activity or fragment without selecting a reader,
    // make sure you cancel the discovery process or the SDK will be stuck in
    // a discover readers phase.
    discoveryCancelable?.cancel(
        object : Callback {
            override fun onSuccess() {
                // Placeholder for handling successful operation
            }

            override fun onFailure(e: TerminalException) {
                // Placeholder for handling exception
            }
        }
    )
}
```

## Conectarse a un lector [Lado del cliente]

> En la versión `5.0.0` del SDK de Android, puedes utilizar el método `easyConnect` para combinar la detección y la conexión del lector en una única llamada a la API y así simplificar la integración. Consulta la [guía de migración del SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage) para obtener más información.

Para conectar tu aplicación de punto de venta a un lector, llama a `connectReader` con el lector seleccionado, usando `InternetConnectionConfiguration`.

#### Kotlin

```kotlin
val internetReaderListener = yourInternetReaderListener

val config = InternetConnectionConfiguration(internetReaderListener)
Terminal.getInstance().connectReader(
    firstReader,
    config,
    object : ReaderCallback {
        override fun onSuccess(reader: Reader) {
            // Placeholder for handling successful operation
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

- [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html)
- [InternetConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-internet-connection-configuration/index.html)

### Múltiples conexiones

Solo una instancia del SDK de Stripe Terminal puede conectarse a un lector en un momento dado. De forma predeterminada, cuando llamas a `connectReader` desde otra aplicación, la conexión entrante reemplaza la conexión existente del SDK al lector y el SDK conectado previamente se desconecta del lector. El método `connectReader` toma un objeto de configuración con una propiedad `failIfInUse`, cuyo valor predeterminado es `false`. Cuando tu aplicación establece `failIfInUse` en true, la llamada `connectReader` tiene un comportamiento alternativo en el que la conexión entrante falla cuando el lector está en medio de una llamada `collectPaymentMethod` o `confirmPaymentIntent` iniciada por otro SDK. Si el lector está conectado a otro SDK pero está inactivo (muestra la pantalla de bienvenida antes de llamar a `collectPaymentMethod`), establecer `failIfInUse` no tiene ningún cambio en el comportamiento de la conexión y la solicitud de conexión entrante siempre puede interrumpir la conexión existente del SDK al lector.

#### Kotlin

```kotlin
val failIfInUse = true
val internetReaderListener = yourInternetReaderListener

val config = InternetConnectionConfiguration(internetReaderListener, failIfInUse)
Terminal.getInstance().connectReader(
    reader,
    config,
    object : ReaderCallback {
        override fun onSuccess(reader: Reader) {
            // Placeholder for handling successful operation
        }

        override fun onFailure(e: TerminalException) {
            // Placeholder for handling exception
        }
    }
)
```

|                                                                                              | failIfInUse es false (predeterminado)                                                                                                                                                                                                                 | failIfInUse es true                                                                                                                                                                                                                                   |
| -------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connectReader` llamado desde un nuevo SDK cuando el lector está inactivo.                   | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDisconnect` de esa aplicación. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDisconnect` de esa aplicación. |
| `connectReader` llamado desde un nuevo SDK cuando el lector está en medio de la transacción. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDisconnect` de esa aplicación. | La conexión entrante falla con un error del lector. La conexión existente del SDK al lector no se interrumpe y el comando en curso continúa.                                                                                                          |

Para obtener la experiencia de conexión menos disruptiva en entornos de múltiples lectores, recomendamos establecer `failIfInUse` en `true` en el intento de conexión inicial de la aplicación. Luego, permite que los usuarios vuelvan a intentar la conexión con `failIfInUse` establecido en `false` si la conexión falla la primera vez.

Con esta configuración, ninguno de tus usuarios podrá interrumpir una transacción de forma accidental al conectarse por error a un lector en uso, pero podrá seguir conectándose si es necesario.

### Gestiona las desconexiones

- [onDisconnect (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-reader-disconnect-listener/on-disconnect.html)

Tu aplicación debe implementar la devolución de llamada `onDisconnect` para gestionar la desconexión de un lector. Cuando implementes esta devolución de llamada, muestra una interfaz de usuario que avise a tu usuario del lector desconectado. Puedes llamar a `discoverReaders` para buscar lectores e iniciar la reconexión.

La aplicación puede intentar volver a conectarse automáticamente al lector desconectado o mostrar una interfaz de usuario que solicite al usuario que se vuelva a conectar a un lector diferente.

El lector puede desconectarse de tu aplicación si pierde la conexión a la red. Para simular una desconexión inesperada, apaga el lector.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), InternetReaderListener {
    // ...

    override fun onDisconnect(reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

    // ...
}
```

### Reconexión automática

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

1. Cuando te conectes a un lector de forma satisfactoria, guarda su número de serie en una ubicación de almacenamiento persistente de datos, como la [API Shared Preferences](https://developer.android.com/training/data-storage/shared-preferences) (Android).
1. Cuando se inicie la aplicación, comprueba que el almacenamiento persistente tenga un número de serie guardado. Si encuentras uno, llama al método `discoverReaders` para que tu aplicación pueda intentar encontrar ese lector nuevamente.
1. Si el número de serie guardado coincide con cualquiera de los lectores detectados, intenta conectarte a ese lector con el objeto de lector coincidente devuelto de la llamada a `discoverReaders`. Si no se encuentra el lector previamente conectado, detén el proceso de detección.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.


# Lectores de Internet

> This is a Lectores de Internet for when terminal-sdk-platform is react-native and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=internet.

Los lectores inteligentes ejecutan el software del lector de Stripe para comunicarse directamente con Stripe a través de Internet. Conectar tu aplicación a un lector inteligente requiere tres pasos:

1. [Registrar un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) en tu cuenta de Stripe.
1. [Detectar lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) con el SDK.
1. [Conectar a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) con el SDK.

## Registra un lector [Lado del servidor]

Antes de poder conectar tu aplicación a un lector inteligente, debes registrar el lector en tu cuenta.

#### Dashboard

### Regístrate en el Dashboard

Puedes añadir tu lector directamente en el [Dashboard](https://dashboard.stripe.com/test/terminal).

#### Registro por código de registro

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. Introduce el código de registro y haz clic en **Siguiente**.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por número de serie

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Busca el número de serie en el dispositivo e introdúcelo. Para registrar varios dispositivos a la vez, puedes introducir varios números de serie separados por comas.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por pedido de hardware

1. En la página [Pedidos de hardware](https://dashboard.stripe.com/terminal/hardware_orders), busca un pedido con el estado «enviado» o «entregado». Haz clic en el menú de desbordamiento (⋯) que aparece al final de la fila y, luego, en **Registrar**.
1. En la página **Registrar lectores**, elige uno o más lectores del pedido de hardware para registrar y haz clic en **Registrar**.
1. Opcionalmente, elige un nombre para el lector. Si has elegido varios lectores, el nombre sirve como prefijo y nombramos los lectores secuencialmente (por ejemplo, para una entrada determinada de «Lector de prueba», nombramos a los lectores «Lector de prueba 1», «Lector de prueba 2» y así sucesivamente).
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tus lectores.

#### API

Para implementaciones más grandes, permite que los usuarios del campo reciban y configuren nuevos lectores por su cuenta. En tu aplicación, crea un flujo para [registrar](https://docs.stripe.com/api/terminal/readers/create.md) un lector con la API de Stripe.

1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. El usuario introduce el código en tu aplicación.
1. Tu aplicación envía el código a Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode "label=Alice's reader" \
  -d "location={{TERMINALLOCATION_ID}}"
```

Para confirmar que has registrado un lector correctamente, enumera todos los lectores que has registrado en esa ubicación:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Detectar lectores [Lado del cliente]

- [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders)

Tras registrar el lector en tu cuenta, busca los lectores registrados anteriormente para conectarlos a tu aplicación de punto de venta con `discoverReaders`, estableciendo `discoveryMethod` en `internet`.

Puedes determinar el alcance de tu descubrimiento utilizando la `location` en la que registraste al lector en el paso anterior.

```js
export default function DiscoverScreen() {
  const { discoverReaders, discoveredReaders } =
    useStripeTerminal({
      onUpdateDiscoveredReaders: (readers) => {
        // After the SDK discovers a reader, your app can connect to it.
      },
    });

  useEffect(() => {
    const fetchReaders = async () => {
      const { error } = await discoverReaders({
        discoveryMethod: 'internet',
      });
    }

    fetchReaders();
  }, [discoverReaders]);

  return <View />;
}
```

## Conectarse a un lector [Lado del cliente]

> En la versión `0.0.1-beta.29` del SDK de React Native, puedes usar el método [easyConnect](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#easyconnect) para combinar la detección y conexión del lector en una única llamada a la API para simplificar la experiencia de integración.

Para conectar tu aplicación de punto de venta a un lector, llama a `connectReader` con el lector seleccionado.

```js
const { reader, error } = await connectReader({
  discoveryMethod: 'internet',
  reader,
});

if (error) {
  console.log('connectReader error:', error);
  return;
}

console.log('Reader connected successfully', reader);
```

- [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1)

### Múltiples conexiones

Solo una instancia del SDK de Stripe Terminal puede conectarse a un lector en un momento dado. De forma predeterminada, cuando llamas a `connectReader` desde otra aplicación, la conexión entrante reemplaza la conexión existente del SDK al lector y el SDK conectado previamente se desconecta del lector. El método `connectReader` toma un objeto de configuración con una propiedad `failIfInUse`, cuyo valor predeterminado es `false`. Cuando tu aplicación establece `failIfInUse` en true, la llamada `connectReader` tiene un comportamiento alternativo en el que la conexión entrante falla cuando el lector está en medio de una llamada `collectPaymentMethod` o `confirmPaymentIntent` iniciada por otro SDK. Si el lector está conectado a otro SDK pero está inactivo (muestra la pantalla de bienvenida antes de llamar a `collectPaymentMethod`), establecer `failIfInUse` no tiene ningún cambio en el comportamiento de la conexión y la solicitud de conexión entrante siempre puede interrumpir la conexión existente del SDK al lector.

```js
const { reader: connectedReader, error } = await connectReader({
  discoveryMethod: 'internet',
  reader,
  failIfInUse: true,
});
```

|                                                                                                      | failIfInUse es false (predeterminado)                                                                                                                                                                                                                    | failIfInUse es true                                                                                                                                                                                                                                      |
| ---------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connectInternetReader` llamado desde un nuevo SDK cuando el lector está inactivo.                   | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDidDisconnect` de esa aplicación. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDidDisconnect` de esa aplicación. |
| `connectInternetReader` llamado desde un nuevo SDK cuando el lector está en medio de la transacción. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDidDisconnect` de esa aplicación. | La conexión entrante falla con un error del lector. La conexión existente del SDK al lector no se interrumpe y el comando en curso continúa.                                                                                                             |

Para obtener la experiencia de conexión menos disruptiva en entornos de múltiples lectores, recomendamos establecer `failIfInUse` en `true` en el intento de conexión inicial de la aplicación. Luego, permite que los usuarios vuelvan a intentar la conexión con `failIfInUse` establecido en `false` si la conexión falla la primera vez.

Con esta configuración, ninguno de tus usuarios podrá interrumpir una transacción de forma accidental al conectarse por error a un lector en uso, pero podrá seguir conectándose si es necesario.

### Gestiona las desconexiones

- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks)

Tu app debe implementar la devolución de llamada `onDidDisconnect` para cuando un lector se desconecta. Al implementar esta devolución de llamada, muestra una interfaz de usuario que notifique al usuario sobre el lector desconectado. Puedes llamar a `discoverReaders` para buscar lectores e iniciar la reconexión.

La aplicación puede intentar volver a conectarse automáticamente al lector desconectado o mostrar una interfaz de usuario que solicite al usuario que se vuelva a conectar a un lector diferente.

El lector puede desconectarse de tu aplicación si pierde la conexión a la red. Para simular una desconexión inesperada, apaga el lector.

```js
const terminal = useStripeTerminal({
  onDidDisconnect: (result) => {
    // Consider displaying a UI to notify the user and start rediscovering readers
  },
});
```

### Reconexión automática

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.


# Lectores de Internet

> This is a Lectores de Internet for when terminal-sdk-platform is java and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=java&reader-type=internet.

Los lectores inteligentes ejecutan el software del lector de Stripe para comunicarse directamente con Stripe a través de Internet. Conectar tu aplicación a un lector inteligente requiere tres pasos:

1. [Registrar un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) en tu cuenta de Stripe.
1. [Detectar lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) con el SDK.
1. [Conectar a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) con el SDK.

## Registra un lector [Lado del servidor]

Antes de poder conectar tu aplicación a un lector inteligente, debes registrar el lector en tu cuenta.

#### Dashboard

### Regístrate en el Dashboard

Puedes añadir tu lector directamente en el [Dashboard](https://dashboard.stripe.com/test/terminal).

#### Registro por código de registro

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. Introduce el código de registro y haz clic en **Siguiente**.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por número de serie

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Busca el número de serie en el dispositivo e introdúcelo. Para registrar varios dispositivos a la vez, puedes introducir varios números de serie separados por comas.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por pedido de hardware

1. En la página [Pedidos de hardware](https://dashboard.stripe.com/terminal/hardware_orders), busca un pedido con el estado «enviado» o «entregado». Haz clic en el menú de desbordamiento (⋯) que aparece al final de la fila y, luego, en **Registrar**.
1. En la página **Registrar lectores**, elige uno o más lectores del pedido de hardware para registrar y haz clic en **Registrar**.
1. Opcionalmente, elige un nombre para el lector. Si has elegido varios lectores, el nombre sirve como prefijo y nombramos los lectores secuencialmente (por ejemplo, para una entrada determinada de «Lector de prueba», nombramos a los lectores «Lector de prueba 1», «Lector de prueba 2» y así sucesivamente).
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tus lectores.

#### API

Para implementaciones más grandes, permite que los usuarios del campo reciban y configuren nuevos lectores por su cuenta. En tu aplicación, crea un flujo para [registrar](https://docs.stripe.com/api/terminal/readers/create.md) un lector con la API de Stripe.

1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. El usuario introduce el código en tu aplicación.
1. Tu aplicación envía el código a Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode "label=Alice's reader" \
  -d "location={{TERMINALLOCATION_ID}}"
```

Para confirmar que has registrado un lector correctamente, enumera todos los lectores que has registrado en esa ubicación:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Detectar lectores [Lado del cliente]

- [discoverReaders (Java)](https://stripe.dev/stripe-terminal-java/core/com.stripe.stripeterminal/-terminal/discover-readers.html)
- [InternetDiscoveryConfiguration (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-internet-discovery-configuration/index.html)

Después de registrar el lector en tu cuenta, busca lectores registrados previamente para conectarte a tu aplicación de punto de venta con `discoverReaders`, usando `InternetDiscoveryConfiguration`.

Puedes determinar el alcance de tu descubrimiento utilizando la `location` en la que registraste al lector en el paso anterior.

```java
private Cancelable discoveryCancelable;

public void onDiscoverReaders() {
    int timeout = 0;
    boolean isSimulated = false;

    InternetDiscoveryConfiguration config = new InternetDiscoveryConfiguration(
        timeout,
        ""{{LOCATION_ID}}"",
        isSimulated,
        DiscoveryFilter.None.INSTANCE
    );

    // Save this cancelable to an instance variable
    discoveryCancelable = Terminal.getInstance().discoverReaders(
        config,
        readers -> {
            // Display the discovered readers to the user
        },
        new Callback() {
            @Override
            public void onSuccess() {
                // Placeholder for handling successful operation
            }

            @Override
            public void onFailure(@NotNull TerminalException e) {
                // Placeholder for handling exception
            }
        }
    );
}
```

## Conectarse a un lector [Lado del cliente]

> En la versión `1.0.0-b15` del SDK de Java, puedes usar el método [easyConnect](https://stripe.dev/stripe-terminal-java/core/com.stripe.stripeterminal/-terminal/easy-connect.html) para combinar la detección y conexión del lector en una única llamada a la API para simplificar la integración.

Para conectar tu aplicación de punto de venta a un lector, llama a `connectReader` con el lector seleccionado, usando `InternetConnectionConfiguration`.

```java
InternetReaderListener internetReaderListener = yourInternetReaderListener;

InternetConnectionConfiguration config = new InternetConnectionConfiguration(internetReaderListener);

Terminal.getInstance().connectReader(
    reader,
    config,
    new ReaderCallback() {
        @Override
        public void onSuccess(@NotNull Reader reader) {
            // Placeholder for handling successful operation
        }

        @Override
        public void onFailure(@NotNull TerminalException e) {
            // Placeholder for handling exception
        }
    }
);
```

- [connectReader (Java)](https://stripe.dev/stripe-terminal-java/core/com.stripe.stripeterminal/-terminal/connect-reader.html)
- [InternetConnectionConfiguration (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.models/-connection-configuration/-internet-connection-configuration/index.html)

### Múltiples conexiones

Solo una instancia del SDK de Stripe Terminal puede conectarse a un lector en un momento dado. De forma predeterminada, cuando llamas a `connectReader` desde otra aplicación, la conexión entrante reemplaza la conexión existente del SDK al lector y el SDK conectado previamente se desconecta del lector. El método `connectReader` toma un objeto de configuración con una propiedad `failIfInUse`, cuyo valor predeterminado es `false`. Cuando tu aplicación establece `failIfInUse` en true, la llamada `connectReader` tiene un comportamiento alternativo en el que la conexión entrante falla cuando el lector está en medio de una llamada `collectPaymentMethod` o `confirmPaymentIntent` iniciada por otro SDK. Si el lector está conectado a otro SDK pero está inactivo (muestra la pantalla de bienvenida antes de llamar a `collectPaymentMethod`), establecer `failIfInUse` no tiene ningún cambio en el comportamiento de la conexión y la solicitud de conexión entrante siempre puede interrumpir la conexión existente del SDK al lector.

```java
boolean failIfInUse = true;
InternetReaderListener internetReaderListener = yourInternetReaderListener;

InternetConnectionConfiguration config =
    new InternetConnectionConfiguration(internetReaderListener, failIfInUse);

Terminal.getInstance().connectReader(
    reader,
    config,
    new ReaderCallback() {
        @Override
        public void onSuccess(@NotNull Reader reader) {
            // Placeholder for handling successful operation
        }

        @Override
        public void onFailure(@NotNull TerminalException e) {
            // Placeholder for handling exception
        }
    }
);
```

|                                                                                              | failIfInUse es false (predeterminado)                                                                                                                                                                                                                 | failIfInUse es true                                                                                                                                                                                                                                   |
| -------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `connectReader` llamado desde un nuevo SDK cuando el lector está inactivo.                   | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDisconnect` de esa aplicación. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDisconnect` de esa aplicación. |
| `connectReader` llamado desde un nuevo SDK cuando el lector está en medio de la transacción. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `onDisconnect` de esa aplicación. | La conexión entrante falla con un error del lector. La conexión existente del SDK al lector no se interrumpe y el comando en curso continúa.                                                                                                          |

Para obtener la experiencia de conexión menos disruptiva en entornos de múltiples lectores, recomendamos establecer `failIfInUse` en `true` en el intento de conexión inicial de la aplicación. Luego, permite que los usuarios vuelvan a intentar la conexión con `failIfInUse` establecido en `false` si la conexión falla la primera vez.

Con esta configuración, ninguno de tus usuarios podrá interrumpir una transacción de forma accidental al conectarse por error a un lector en uso, pero podrá seguir conectándose si es necesario.

### Gestiona las desconexiones

- [onDisconnect (Java)](https://stripe.dev/stripe-terminal-java/external/com.stripe.stripeterminal.external.callable/-reader-disconnect-listener/on-disconnect.html)

Tu aplicación debe implementar la devolución de llamada `onDisconnect` para gestionar la desconexión de un lector. Cuando implementes esta devolución de llamada, muestra una interfaz de usuario que avise a tu usuario del lector desconectado. Puedes llamar a `discoverReaders` para buscar lectores e iniciar la reconexión.

La aplicación puede intentar volver a conectarse automáticamente al lector desconectado o mostrar una interfaz de usuario que solicite al usuario que se vuelva a conectar a un lector diferente.

El lector puede desconectarse de tu aplicación si pierde la conexión a la red. Para simular una desconexión inesperada, apaga el lector.

```java
public class CustomReaderListener implements InternetReaderListener {
    // ...

    @Override
    public void onDisconnect(@NotNull DisconnectReason reason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

    // ...
}
```

### Reconexión automática

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

1. Cuando se conecte correctamente a un lector, guarde su número de serie en una ubicación de almacenamiento de datos persistente, como la [API Preferences](https://docs.oracle.com/javase/8/docs/api/java/util/prefs/Preferences.html).
1. Cuando se inicie la aplicación, comprueba que el almacenamiento persistente tenga un número de serie guardado. Si encuentras uno, llama al método `discoverReaders` para que tu aplicación pueda intentar encontrar ese lector nuevamente.
1. Si el número de serie guardado coincide con cualquiera de los lectores detectados, intenta conectarte a ese lector con el objeto de lector coincidente devuelto de la llamada a `discoverReaders`. Si no se encuentra el lector previamente conectado, detén el proceso de detección.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.


# Lectores de Internet

> This is a Lectores de Internet for when terminal-sdk-platform is dotnet and reader-type is internet. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=dotnet&reader-type=internet.

Los lectores inteligentes ejecutan el software del lector de Stripe para comunicarse directamente con Stripe a través de Internet. Conectar tu aplicación a un lector inteligente requiere tres pasos:

1. [Registrar un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#register-reader) en tu cuenta de Stripe.
1. [Detectar lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) con el SDK.
1. [Conectar a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) con el SDK.

## Registra un lector [Lado del servidor]

Antes de poder conectar tu aplicación a un lector inteligente, debes registrar el lector en tu cuenta.

#### Dashboard

### Regístrate en el Dashboard

Puedes añadir tu lector directamente en el [Dashboard](https://dashboard.stripe.com/test/terminal).

#### Registro por código de registro

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. Introduce el código de registro y haz clic en **Siguiente**.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por número de serie

1. En la página [Lectores](https://dashboard.stripe.com/terminal/readers), haz clic en **Registrar lector**.
1. Busca el número de serie en el dispositivo e introdúcelo. Para registrar varios dispositivos a la vez, puedes introducir varios números de serie separados por comas.
1. Opcionalmente, elige un nombre para el lector.
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tu lector.

#### Registro por pedido de hardware

1. En la página [Pedidos de hardware](https://dashboard.stripe.com/terminal/hardware_orders), busca un pedido con el estado «enviado» o «entregado». Haz clic en el menú de desbordamiento (⋯) que aparece al final de la fila y, luego, en **Registrar**.
1. En la página **Registrar lectores**, elige uno o más lectores del pedido de hardware para registrar y haz clic en **Registrar**.
1. Opcionalmente, elige un nombre para el lector. Si has elegido varios lectores, el nombre sirve como prefijo y nombramos los lectores secuencialmente (por ejemplo, para una entrada determinada de «Lector de prueba», nombramos a los lectores «Lector de prueba 1», «Lector de prueba 2» y así sucesivamente).
1. Si ya has creado una Ubicación, elige la nueva Ubicación del lector. De lo contrario, haz clic en **+ Añadir nueva** para crear una.
1. Haz clic en **Registrar** para terminar de registrar tus lectores.

#### API

Para implementaciones más grandes, permite que los usuarios del campo reciban y configuren nuevos lectores por su cuenta. En tu aplicación, crea un flujo para [registrar](https://docs.stripe.com/api/terminal/readers/create.md) un lector con la API de Stripe.

1. Si tienes un [lector inteligente](https://docs.stripe.com/terminal/smart-readers.md), introduce la secuencia de teclas `0-7-1-3-9` para mostrar un código de registro único. Si tienes un BBPOS WisePOS E o Stripe Reader S700/S710, ve a la [configuración del lector](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md#settings) y pulsa **Generar código de emparejamiento**.
1. El usuario introduce el código en tu aplicación.
1. Tu aplicación envía el código a Stripe:

```curl
curl https://api.stripe.com/v1/terminal/readers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d registration_code={{READER_REGISTRATION_CODE}} \
  --data-urlencode "label=Alice's reader" \
  -d "location={{TERMINALLOCATION_ID}}"
```

Para confirmar que has registrado un lector correctamente, enumera todos los lectores que has registrado en esa ubicación:

#### curl

```bash
curl https://api.stripe.com/v1/terminal/readers \
  -u <<YOUR_SECRET_KEY>>:
```

## Detectar lectores [Lado del cliente]

- [DiscoverReadersAsync (.NET)](https://docs.stripe.com/terminal/payments/connect-reader.md#TODO-DOTNET-FIXME)

Después de registrar el lector en tu cuenta, busca lectores registrados previamente para conectarte a tu aplicación de punto de venta utilizando el método `DiscoverReadersAsync`.

Puedes determinar el alcance de tu descubrimiento utilizando la `location` en la que registraste al lector en el paso anterior.

```csharp
public async Task<IImmutableList<Reader>> DiscoverReadersAsync()
{

    try
    {
        var config = new DiscoveryConfiguration.Builder()
          .SetIsSimulated(false)
          .SetLocation("{{LOCATION_ID}}")
          .Build();

        Console.WriteLine("Discovered readers");
        return await Terminal.Instance.DiscoverReadersAsync(config);
    }
    catch (TerminalException ex)
    {
        // Placeholder for handling exception
        throw;
    }

}
```

## Conectarse a un lector [Lado del cliente]

Para conectar tu aplicación de punto de venta a un lector, llama a `ConnectInternetReaderAsync` con el lector seleccionado.

```csharp
// after selecting a reader to connect to
Reader connectedReader;
try
{
    var config = new InternetConnectionConfiguration.Builder()
        .Build();
    connectedReader = await Terminal.Instance.ConnectInternetReaderAsync(selectedReader, config);
    Console.WriteLine("Connected to reader");
}
catch (TerminalException ex)
{
    // Placeholder for handling exception
    throw;
}
```

- [ConnectInternetReaderAsync (.NET)](https://docs.stripe.com/terminal/payments/connect-reader.md#TODO-DOTNET-FIXME)

### Múltiples conexiones

Solo una instancia del SDK de Stripe Terminal puede conectarse a un lector en un momento dado. De forma predeterminada, cuando llamas a `ConnectInternetReaderAsync` desde otra aplicación, la conexión entrante reemplaza la conexión existente del SDK al lector y el SDK conectado previamente se desconecta del lector. El método `ConnectInternetReaderAsync` toma un objeto de configuración con una propiedad `failIfInUse`, cuyo valor predeterminado es `false`. Cuando tu aplicación establece `failIfInUse` en true, la llamada `ConnectInternetReaderAsync` tiene un comportamiento alternativo en el que la conexión entrante falla cuando el lector está en medio de una llamada `CollectPaymentMethodAsync` o `ConfirmPaymentIntentAsymc` iniciada por otro SDK. Si el lector está conectado a otro SDK pero está inactivo (muestra la pantalla de bienvenida antes de llamar a `CollectPaymentMethodAsync`), establecer `failIfInUse` no cambia el comportamiento de la conexión y la solicitud de conexión entrante siempre puede interrumpir la conexión existente del SDK al lector.

```csharp
// after selecting a reader to connect to
Reader connectedReader;
try
{
    var config = new InternetConnectionConfiguration.Builder()
        .SetFailIfInUse(true)
        .Build();
    connectedReader = await Terminal.Instance.ConnectInternetReaderAsync(selectedReader, config);
    Console.WriteLine("Connected to reader");
}
catch (TerminalException ex)
{
    // Placeholder for handling exception
    throw;
}
```

|                                                                                                           | FailIfInUse es false (predeterminado)                                                                                                                                                                                                                                 | FailIfInUse es true                                                                                                                                                                                                                                                   |
| --------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ConnectInternetReaderAsync` llamado desde un nuevo SDK cuando el lector está inactivo.                   | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `OnUnexpectedReaderDisconnect` de esa aplicación. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `OnUnexpectedReaderDisconnect` de esa aplicación. |
| `ConnectInternetReaderAsync` llamado desde un nuevo SDK cuando el lector está en medio de la transacción. | La conexión existente del SDK al lector se interrumpe, y el nuevo SDK se conecta al lector. Se produce un error en el siguiente comando del SDK conectado anteriormente con un error de lector y se llama al método `OnUnexpectedReaderDisconnect` de esa aplicación. | La conexión entrante falla con un error del lector. La conexión existente del SDK al lector no se interrumpe y el comando en curso continúa.                                                                                                                          |

Para obtener la experiencia de conexión menos disruptiva en entornos de múltiples lectores, recomendamos establecer `failIfInUse` en `true` en el intento de conexión inicial de la aplicación. Luego, permite que los usuarios vuelvan a intentar la conexión con `failIfInUse` establecido en `false` si la conexión falla la primera vez.

Con esta configuración, ninguno de tus usuarios podrá interrumpir una transacción de forma accidental al conectarse por error a un lector en uso, pero podrá seguir conectándose si es necesario.

### Gestiona las desconexiones

- [TerminalListener (.NET)](https://docs.stripe.com/terminal/payments/connect-reader.md#TODO-DOTNET-FIXME)

Tu aplicación debe implementar la devolución de llamada `OnUnexpectedReaderDisconnect` para gestionar la desconexión de un lector. Cuando implementes esta devolución de llamada, muestra una interfaz de usuario que avise a tu usuario del lector desconectado. Puedes llamar a `DiscoverReadersAsync` para buscar lectores e iniciar la reconexión.

La aplicación puede intentar volver a conectarse automáticamente al lector desconectado o mostrar una interfaz de usuario que solicite al usuario que se vuelva a conectar a un lector diferente.

El lector puede desconectarse de tu aplicación si pierde la conexión a la red. Para simular una desconexión inesperada, apaga el lector.

```csharp
public class TerminalListener : ITerminalListener
{

    // ...

    Terminal.InitTerminal(
        connectionTokenProvider: connectionTokenProvider,
        terminalListener: this,
        offlineListener: offlineListener,
        applicationInformation: applicationInformation
    );

    // ITerminalListener
    public void OnUnexpectedReaderDisconnect(Reader reader)
    {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

}
```

### Reconexión automática

Stripe Terminal no se vuelve a conectar automáticamente a un lector cuando se inicia la aplicación. En su lugar, puedes crear un flujo de reconexión almacenando los ID del lector e intentando conectarte a un lector conocido al iniciarse.

Muestra alguna interfaz de usuario durante el proceso de detección y conexión para indicar que se está produciendo una reconexión automática.


# Tap to Pay en el iPhone

> This is a Tap to Pay en el iPhone for when terminal-sdk-platform is ios and reader-type is tap-to-pay. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=ios&reader-type=tap-to-pay.

Tap to Pay en iPhone permite a los usuarios aceptar pagos sin contacto en persona con un [iPhone compatible](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=ios#supported-devices) y el [SDK de Stripe Terminal](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=ios). Tap to Pay en iPhone también es compatible con las tarjetas sin contacto de Visa, Mastercard, American Express y Discover y monederos móviles basados en NFC (Apple Pay, Google Pay y Samsung Pay). Tap to Pay en iPhone está incluido en el SDK de Terminal iOS y habilita los pagos directamente en tu aplicación móvil para iOS.

## Detectar lectores

- [discoverReaders (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:)
- [TapToPayDiscoveryConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Reader%20Discovery%20%26%20Connection.html#/c:objc\(cs\)SCPTapToPayDiscoveryConfiguration)

Utiliza el método [discoverReaders](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)discoverReaders:delegate:completion:) para determinar si tu iPhone es compatible con Tap to Pay.

El controlador `completion` invoca con un error si la aplicación se ejecuta en un dispositivo que no cumple los [criterios de dispositivo admitido](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=ios#supported-devices).

#### Swift

```swift
import StripeTerminal

class DiscoverReadersViewController: UIViewController, DiscoveryDelegate {

    var discoverCancelable: Cancelable?

    // ...

    // Action for a "Discover Readers" button
    func discoverReadersAction() throws {
        let config = try TapToPayDiscoveryConfigurationBuilder().build()
        // In addition to Terminal's completion block methods, Swift async alternatives are available.
        // See our Example app for usage examples: https://github.com/stripe/stripe-terminal-ios/tree/master/Example
        self.discoverCancelable = Terminal.shared.discoverReaders(config, delegate: self) { error in
            if let error = error {
                print("discoverReaders failed: \(error)")
            } else {
                print("discoverReaders succeeded")
            }
        }
    }

    // ...

    // MARK: DiscoveryDelegate

    func terminal(_ terminal: Terminal, didUpdateDiscoveredReaders readers: [Reader]) {
        // In your app, display the ability to use your phone as a reader
        // Call `connectReader` to initiate a session with the phone
    }
}
```

## Conectarse a un lector

> En la versión `5.1.0` del SDK de iOS, puedes utilizar el método `easyConnect` para combinar la detección y la conexión del lector en una única llamada a la API para simplificar la integración. Consulta la [guía de migración del SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage-ios) para obtener más información.

- [connectReader (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)connectReader:connectionConfig:completion:)
- [TapToPayConnectionConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTapToPayConnectionConfiguration.html)

Para comenzar a aceptar pagos de Tap to Pay en iPhone, proporciona el lector detectado al método `connectReader`. También debes [crear un delegado](https://docs.stripe.com/terminal/payments/connect-reader.md#device-setup) para gestionar las posibles actualizaciones necesarias del lector.

Debes [registrar tu lector](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en una [ubicación](https://docs.stripe.com/api/terminal/locations.md) tras la conexión. Para hacerlo, crea y usa un `SCPTapToPayConnectionConfiguration` con el `locationId` establecido en el ID de ubicación relevante al conectar.

Establece el `display_name` para representar el nombre del negocio al crear una ubicación. Tu cliente verá el `display_name` de la ubicación en la pantalla táctil del dispositivo, a menos que indiques explícitamente el nombre del negocio al conectar con un lector. Puedes editar las ubicaciones existentes según sea necesario para ajustar este texto.

Si utilizas [cargos de destino con on_behalf_of](https://docs.stripe.com/terminal/features/connect.md#destination-payment-intents), también debes proporcionar el ID de la cuenta conectada en `SCPTapToPayConnectionConfiguration`.

#### Swift

```swift
// Call `connectReader` with the selected reader and a connection config
// to register to a location as set by your app.
let connectionConfig = try TapToPayConnectionConfigurationBuilder.init(locationId: ""{{LOCATION_ID}}"")
.delegate(yourTapToPayReaderDelegate)
.build()
Terminal.shared.connectReader(selectedReader, connectionConfig: connectionConfig) { reader, error in
    if let reader = reader {
        print("Successfully connected to reader: \(reader)")
    } else if let error = error {
        print("connectReader failed: \(error)")
    }
}
```

### Gestionar la configuración de dispositivos

Al conectarse a un lector compatible con Tap to Pay en iPhone, es posible que se requiera una actualización de configuración, que puede tardar hasta unos minutos. Te recomendamos que te conectes con el lector con antelación en segundo plano para reducir el tiempo de espera de las empresas.

Asegúrate de que tu aplicación implemente `SCPTapToPayReaderDelegate` para gestionar los pasos de configuración y mostrar mensajes a tu empresa con el fin de que se mantenga a la espera. Verás los pasos de configuración como una actualización de software para que puedas mostrar el progreso a tus empresas según corresponda.

#### Swift

```swift
class APPReaderViewController: TapToPayReaderDelegate {

    // MARK: TapToPayReaderDelegate

    // ...

    func tapToPayReader(_ reader: Reader, didStartInstallingUpdate update: ReaderSoftwareUpdate, cancelable: Cancelable?) {
        // In your app, let the user know that an update is being installed on the reader
    }

    func tapToPayReader(_ reader: Reader, didReportReaderSoftwareUpdateProgress progress: Float) {
        // The update or configuration process has reached the specified progress (0.0 to 1.0)
        // If you are displaying a progress bar or percentage, this can be updated here
    }

    func tapToPayReader(_ reader: Reader, didFinishInstallingUpdate update: ReaderSoftwareUpdate?, error: Error?) {
        // The reader has finished installing an update
        // If `error` is nil, it is safe to proceed and start collecting payments
        // Otherwise, check the value of `error` for more information on what went wrong
    }

    func tapToPayReader(_ reader: Reader, didRequestReaderDisplayMesage displayMessage: ReaderDisplayMessage) {
        // This is called to request that a prompt be displayed in your app.
        // Use Terminal.stringFromReaderDisplayMessage(:) to get a user-facing string for the prompt
    }

    func tapToPayReader(_ reader: Reader, didRequestReaderInput inputOptions: ReaderInputOptions = []) {
        // This is called when the reader begins waiting for input
        // Use Terminal.stringFromReaderInputOptions(:) to get a user-facing string for the input options
    }

    // ...
}
```

### Vinculación de la cuenta y condiciones generales de Apple

Todos los usuarios deben aceptar las condiciones generales Tap to Pay en iPhone de Apple antes de aceptar pagos por primera vez. Para los usuarios Connect, cada cuenta conectada debe aceptar individualmente las condiciones generales cuando:

- Un usuario de Connect cree cargos directos
- Un usuario de Connect crea un cargo de destino y especifica una cuenta `on_behalf_of`

Los usuarios pueden aceptar los Términos y condiciones de Tap to Pay en iPhone de Apple en la web antes de conectarse al lector por primera vez mediante [enlaces de activación](https://docs.stripe.com/api/terminal/onboarding-link.md?api-version=2025-07-30.preview). Alternativamente, se mostrarán a los usuarios los Términos y condiciones de Tap to Pay en iPhone de Apple la primera vez que se conecten al lector dentro de una aplicación móvil. Para aceptar los Términos y condiciones de Apple, el usuario debe proporcionar un ID de Apple válido que represente a la empresa. Una vez que los usuarios aceptan los términos y condiciones de Tap to Pay en iPhone de Apple, no se les volverá a solicitar en conexiones posteriores con la misma cuenta de Stripe, incluso en otros dispositivos móviles.
![Procesamiento en tres pasos que muestra el inicio de sesión en el ID de Apple, las condiciones aceptadas y la confirmación de éxito de Tap to Pay en iPhone](https://b.stripecdn.com/docs-statics-srv/assets/ttpoi-account-linking-steps.56bc5c0bb037a98f788a7e8d43d0c87e.png)

Vincula tu cuenta de Apple ID para aceptar pagos con Tap to Pay

Cualquier iPhone puede usar hasta 3 cuentas únicas de Stripe en todas las aplicaciones dentro de un período continuo de 24 horas al llamar a `connectReader` para Tap to Pay en iPhone. Si se utilizan más cuentas para el dispositivo dentro del mismo período de 24 horas, el método `connectReader` genera un error [SCPErrorTapToPayReaderMerchantBlocked](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPError.html#/c:@E@SCPError@SCPErrorTapToPayReaderMerchantBlocked).

Obtén más información sobre la vinculación de cuentas en la sección de Información empresarial de Tap to Pay en el iPhone de las [preguntas frecuentes sobre Tap to Pay en el iPhone de Apple](https://register.apple.com/tap-to-pay-on-iphone/faq.html).

## Gestiona las desconexiones

El lector se desconecta cuando la aplicación entra en segundo plano o cuando el iPhone pierde la conectividad. Hay dos maneras de gestionarlo:

- [TapToPayReaderDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPTapToPayReaderDelegate.html)

#### Gestiona la desconexión de forma manual

Tu aplicación debe implementar el método delegado [SCPTapToPayReaderDelegate reader: didDisconnect:](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDelegate.html#/c:objc\(pl\)SCPReaderDelegate\(im\)reader:didDisconnect:) para gestionar esta desconexión. Puedes usar esta devolución de llamada como una oportunidad para notificar al usuario que algo ha salido mal y que necesitas conectividad a Internet para continuar. Además, puedes volver a conectarte manualmente al lector cuando la aplicación vuelva a entrar en primer plano.

#### Swift

```swift
import StripeTerminal

class ReaderViewController: UIViewController, TapToPayReaderDelegate {
    override func viewDidLoad() {
        super.viewDidLoad()
        // Set the reader delegate when connecting to a reader
    }

    // ...



    func reader(_ reader: Reader, didDisconnect reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }
}
```

#### Intenta la reconexión de forma automática

Implementa los métodos de reconexión automática en el `SCPTapToPayReaderDelegate`. A continuación, debes pasar el `SCPTapToPayReaderDelegate` a tu `SCPTapToPayConnectionConfiguration`.

#### Swift

```swift
let connectionConfig = try TapToPayConnectionConfigurationBuilder(locationId: locationId)
  .delegate(yourTapToPayReaderDelegate)
  .build()

Terminal.shared.connectReader(
  reader,
  connectionConfig: connectionConfig,
  completion: connectCompletion
)
```

Si intentas la reconexión de forma automática, ocurre lo siguiente:

1. Cuando se produce una desconexión, el SDK intenta reconectarse automáticamente y te notifica a través de `onReaderReconnectStarted`. Asegúrate de que la app indique que se ha perdido la conexión y que se está realizando una reconexión.
   - Puedes usar el objeto `Cancelable` para detener el intento de reconexión en cualquier momento.
1. Si el SDK se reconecta correctamente al lector, Stripe te notifica a través de `onReaderReconnectSucceeded`. Asegúrate de que la aplicación indique que se ha restablecido la conexión y de que se reanudan las operaciones normales.
1. Si el SDK no puede reconectarse al lector, Stripe te notifica a través de `onReaderReconnectFailed` y `reader:didDisconnect:`. Asegúrate de que la aplicación indique que se ha producido una desconexión inesperada.

#### Swift

```swift
import StripeTerminal

extension ReaderViewController: TapToPayReaderDelegate {
    // MARK: ReconnectionDelegate

    func reader(_ reader: Reader, didStartReaderReconnect cancelable: Cancelable) {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
    }

    func readerDidSucceedReaderReconnect(_ reader: Reader) {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
    }
    func readerDidFailReaderReconnect(_ reader: Reader) {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
    }
}
```


# Tap to Pay en Android

> This is a Tap to Pay en Android for when terminal-sdk-platform is android and reader-type is tap-to-pay. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=android&reader-type=tap-to-pay.

Tap to Pay en Android (TTPA) permite a los usuarios aceptar pagos sin contacto en persona con [dispositivos Android compatibles con NFC](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=android#supported-devices). TTPA requiere la última versión del [SDK de Terminal Android](https://stripe.dev/stripe-terminal-android/). TTPA es compatible con las tarjetas sin contacto de Visa, Mastercard y American Express y los monederos móviles basados en NFC (Apple Pay, Google Pay y Samsung Pay). TTPA es una extensión del SDK de Terminal Android y permite realizar pagos directamente en tu aplicación de Android.

Para conectar la aplicación al lector Tap to Pay en un dispositivo Android compatible, sigue estos pasos:

1. [Inicializar el SDK](https://docs.stripe.com/terminal/payments/connect-reader.md#initialize) para TTPA.
1. [Detecta lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) usando el SDK para confirmar la compatibilidad del dispositivo.
1. [Conéctate a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) usando el SDK para aceptar pagos.
1. [Gestiona desconexiones inesperadas](https://docs.stripe.com/terminal/payments/connect-reader.md#handling-disconnects) para asegurarse de que el usuario pueda seguir aceptando pagos si el lector se desconecta inesperadamente.

Si la aplicación se ejecuta en un dispositivo que no cumple con los [criterios de compatibilidad de dispositivos](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=android#supported-devices), el SDK devuelve una `TerminalException` que proporciona un contexto adicional en una devolución de llamada `onFailure`.

## Inicializar el SDK

- [TapToPay (Android)](https://stripe.dev/stripe-terminal-android/cots/com.stripe.stripeterminal.taptopay/-tap-to-pay/-companion/is-in-tap-to-pay-process.html)

TTPA opera en un proceso dedicado para hacer que las transacciones sean más seguras. En este proceso, se crea una segunda instancia de tu `Application`. Para evitar errores inesperados causados por la ejecución de tu código en este proceso, puedes omitir la inicialización en tu `Application` en este proceso marcando `TapToPay.isInTapToPayProcess()`.

```kotlin
// Substitute with your application name, and remember to keep it the same as your AndroidManifest.xml
class StripeTerminalApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // Skip initialization if running in the TTPA process.
        if (TapToPay.isInTapToPayProcess()) return

        // For example, this will be skipped.
        TerminalApplicationDelegate.onCreate(this)
    }
}
```

## Detectar lectores

- [discoverReaders (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/discover-readers.html)
- [TapToPayDiscoveryConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-discovery-configuration/-tap-to-pay-discovery-configuration/index.html)

Utiliza el método `discoverReaders` para determinar el soporte de hardware para Tap to Pay en el dispositivo Android. `discoverReaders` verifica los siguientes requisitos del dispositivo Android:

- Cuenta con un sensor NFC integrado y funcional y un procesador basado en ARM
- Funciona con Android 13 o posterior
- Tiene un almacén de claves con soporte de hardware para ECDH (la versión de [`FEATURE_HARDWARE_KEYSTORE`](https://developer.android.com/reference/android/content/pm/PackageManager#FEATURE_HARDWARE_KEYSTORE) debe ser 100 o posterior).
- Para la versión no simulada del lector Tap to Pay, la aplicación no se puede depurar.

Tu aplicación *debe* estar en primer plano para que el servicio del lector Tap to Pay se inicie correctamente.

Si la aplicación se ejecuta en un dispositivo que no cumple con los requisitos anteriores, la devolución de llamada `onFailure` regresa con una `TerminalException` que contiene un [TerminalErrorCode](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html) y contexto adicional. Los fallos en esta etapa no puede procesarlos el usuario final.

No puedes usar la versión de producción no simulada del lector Tap to Pay con aplicaciones procesables ni con las opciones de desarrollador del dispositivo habilitadas. Para probar tu integración con el lector Tap to Pay en Android, establece `TapToPayDiscoveryConfiguration.isSimulated` en `true` durante el descubrimiento del lector. Debes establecer este valor en `false` en la versión de liberación de tu aplicación.

#### Kotlin

```kotlin
var discoverCancelable: Cancelable? = null

fun onDiscoverReaders() {
    val isApplicationDebuggable = 0 != applicationInfo.flags and ApplicationInfo.FLAG_DEBUGGABLE
    val config = TapToPayDiscoveryConfiguration(isSimulated = isApplicationDebuggable)

    // Save this cancelable to an instance variable
    discoverCancelable = Terminal.getInstance().discoverReaders(
        config,
        object : DiscoveryListener {
            override fun onUpdateDiscoveredReaders(readers: List<Reader>) {
                // Automatically connect to supported mobile readers
            }
        },
        object : Callback {
            override fun onSuccess() {
                // Placeholder for handling successful operation
            }

            override fun onFailure(e: TerminalException) {
                // Placeholder for handling exception
            }
        }
    )
}

override fun onStop() {
    super.onStop()

    // If you're leaving the activity or fragment without selecting a reader,
    // make sure you cancel the discovery process or the SDK will be stuck in
    // a discover readers phase
    discoverCancelable?.cancel(
        object : Callback {
            override fun onSuccess() {
                // Placeholder for handling successful operation
            }

            override fun onFailure(e: TerminalException) {
                // Placeholder for handling exception
            }
        }
    )
}
```

Para comprobar si un dispositivo cumple con los requisitos de hardware y sistema operativo de Tap to Pay en tiempo de ejecución, utiliza la función [Terminal.supportsReadersOfType](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/supports-readers-of-type.html). Como parte de la inicialización del SDK de Terminal, esta función requiere que tu usuario final acepte solicitudes de permiso para acceder a la ubicación y al Bluetooth. Esta función tarda aproximadamente 10 milisegundos en ejecutarse en la mayoría de los dispositivos.

## Conectarse a un lector

> En la versión `5.0.0` del SDK de Android, puedes utilizar el método `easyConnect` para combinar la detección y la conexión del lector en una única llamada a la API para simplificar la integración. Consulta la [guía de migración del SDK](https://docs.stripe.com/terminal/references/sdk-migration-guide.md#update-your-reader-connection-usage) para obtener más información.

- [connectReader (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/connect-reader.html)
- [TapToPayConnectionConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-connection-configuration/-tap-to-pay-connection-configuration/index.html)

Para aceptar pagos de Tap to Pay, proporciona el lector detectado del paso anterior al método `connectReader`.

`connectReader` verifica que el dispositivo Android cumpla con los siguientes requisitos:

- No está rooteado y el cargador de arranque del dispositivo está bloqueado y permanece sin cambios
- Tiene una actualización de seguridad instalada de los últimos 12 meses
- Utiliza los servicios móviles de Google y tiene instalada la aplicación Google Play Store.
- Tiene una conexión estable a Internet
- Funciona con el sistema operativo proporcionado por el fabricante sin modificaciones
- La aplicación utiliza Tap to Pay SDK versión 2.20.0 o posterior
- Las opciones de desarrollador están desactivadas para la versión no simulada del lector Tap to Pay.

Si tu aplicación se ejecuta en un dispositivo que no cumple con los requisitos anteriores, la devolución de llamada `onFailure`’ regresa con una `TerminalException` que contiene un [TerminalErrorCode](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html) y contexto adicional. El usuario final puede tomar medidas en algunos de los [motivos de error](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-error-code/index.html). Por ejemplo:

- `STRIPE_API_CONNECTION_ERROR`: el usuario puede conectarse a una fuente de Internet estable.
- `TAP_TO_PAY_UNSUPPORTED_ANDROID_VERSION`: el usuario puede actualizar su sistema operativo si hay una actualización disponible del fabricante del dispositivo.

Debes [registrar tu lector](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en una [ubicación](https://docs.stripe.com/api/terminal/locations.md) tras la conexión. Para hacerlo, crea y usa un `TapToPayConnectionConfiguration` con el `locationId` establecido en el ID de ubicación relevante al conectar.

#### Kotlin

```kotlin
val tapToPayReaderListener = yourTapToPayReaderListener
val autoReconnectOnUnexpectedDisconnect = true

val config = TapToPayConnectionConfiguration(
  ""{{LOCATION_ID}}"",
  autoReconnectOnUnexpectedDisconnect,
  tapToPayReaderListener
),
Terminal.getInstance().connectReader(
  firstReader,
  config,
  object : ReaderCallback {
      override fun onSuccess(reader: Reader) {
          // Placeholder for handling successful operation
      }

      override fun onFailure(e: TerminalException) {
          // Placeholder for handling exception
      }
  }
)
```

## Gestionar las desconexiones inesperadas

- [TapToPayReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-tap-to-pay-reader-listener/index.html)

Pueden producirse desconexiones inesperadas entre tu aplicación y el lector. Por ejemplo, el lector Tap to Pay podría desconectarse inesperadamente porque:

- Android OS finaliza el servicio del lector Tap to Pay debido a limitaciones de memoria.
- El dispositivo pierde la conexión a Internet.

Hay dos maneras de gestionarlo:

#### Intenta la reconexión de forma automática

Puedes establecer `autoReconnectOnUnexpectedDisconnect` como `true` para permitir que el SDK intente automáticamente volver a conectarse cuando se produzca una desconexión inesperada. El SDK adopta este comportamiento de forma predeterminada si omite esta configuración. De forma opcional, también puedes implementar `TapToPayReaderListener` para las devoluciones de llamada de reconexión automática en tu aplicación.

#### Kotlin

```kotlin
val tapToPayReaderListener = yourTapToPayReaderListener
val autoReconnectOnUnexpectedDisconnect = true

Terminal.getInstance().connectReader(
    reader,
    TapToPayConnectionConfiguration(
        ""{{LOCATION_ID}}"",
        autoReconnectOnUnexpectedDisconnect,
        tapToPayReaderListener
    ),
    readerCallback,
)
```

Cuando el SDK intenta la reconexión de forma automática, ocurre lo siguiente:

1. Cuando se produce una desconexión, el SDK intenta reconectarse automáticamente y te notifica a través de `onReaderReconnectStarted`. Asegúrate de que la app indique que se ha perdido la conexión y que se está realizando una reconexión.
   - Puedes usar el objeto `Cancelable` para detener el intento de reconexión en cualquier momento.
1. Si el SDK se reconecta correctamente al lector, Stripe te notifica a través de `onReaderReconnectSucceeded`. Asegúrate de que la aplicación indique que se ha restablecido la conexión y de que se reanudan las operaciones normales.
1. Si el SDK no puede reconectarse al lector, Stripe te notifica a través de `onReaderReconnectFailed` y `TapToPayReaderListener.onDisconnect`. Asegúrate de que la aplicación indique que se ha producido una desconexión inesperada.

#### Kotlin

```kotlin
class CustomTapToPayReaderListener : TapToPayReaderListener {
    override fun onReaderReconnectStarted(reader: Reader, cancelReconnect: Cancelable, reason: DisconnectReason) {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
    }

    override fun onReaderReconnectSucceeded(reader: Reader) {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
    }

    override fun onReaderReconnectFailed(reader: Reader) {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
    }
}
```

#### Gestiona la desconexión de forma manual

Para gestionar la desconexión por tu cuenta, debes:

1. Establece `autoReconnectOnUnexpectedDisconnect` como `false` para deshabilitar la reconexión automática predeterminada.
1. Implementa `TapToPayReaderListener` para su devolución de llamada `onDisconnect`.

Esto permite que tu aplicación se vuelva a conectar al lector de Tap to Pay y, cuando corresponda, notificar al usuario qué ha pasado y cómo puede habilitar el acceso a Tap to Pay. Los usuarios finales pueden resolver ciertos errores, como problemas de conexión a Internet.

#### Kotlin

```kotlin
class ReaderActivity : AppCompatActivity(), TapToPayReaderListener {
    // ...

    override fun onDisconnect(reason: DisconnectReason) {
        // Consider displaying a UI to notify the user and start rediscovering readers
    }

    // ...
}
```

> Si gestionas la desconexión manualmente sin desactivar la reconexión automática, pueden producirse conflictos que interrumpan la sesión del lector.


# Tap to Pay en React Native

> This is a Tap to Pay en React Native for when terminal-sdk-platform is react-native and reader-type is tap-to-pay. View the full page at https://docs.stripe.com/terminal/payments/connect-reader?terminal-sdk-platform=react-native&reader-type=tap-to-pay.

Tap to Pay permite a los usuarios aceptar pagos sin contacto en persona con [dispositivos Android compatibles con NFC](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=android#supported-devices) o [iPhones compatibles](https://docs.stripe.com/terminal/payments/setup-reader/tap-to-pay.md?platform=ios#supported-devices). Tap to Pay es compatible con las tarjetas sin contacto de Visa, Mastercard, American Express y los monederos móviles basados en NFC (Apple Pay, Google Pay y Samsung Pay). El soporte de Tap to Pay en iPhone y en Android está incluido en los SDK nativos de Terminal y permite los pagos directamente en tu aplicación móvil.

> En la versión `0.0.1-beta.29` del SDK de React Native, puedes usar el método [easyConnect](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#easyconnect) para combinar la detección y conexión del lector en una única llamada a la API para simplificar la integración.

Para conectar la aplicación al lector Tap to Pay en un dispositivo compatible, sigue estos pasos:

- [Inicializa el SDK](https://docs.stripe.com/terminal/payments/connect-reader.md#initialize) para TTPA si estás usando el SDK en un dispositivo Android.
- [Detecta lectores](https://docs.stripe.com/terminal/payments/connect-reader.md#discover-readers) usando el SDK para confirmar la compatibilidad del dispositivo.
- [Conéctate a un lector](https://docs.stripe.com/terminal/payments/connect-reader.md#connect-reader) usando el SDK para aceptar pagos.
- [Gestiona desconexiones inesperadas](https://docs.stripe.com/terminal/payments/connect-reader.md#handling-disconnects) para asegurarse de que el usuario pueda seguir aceptando pagos si el lector se desconecta inesperadamente.

## Inicializar el SDK

Tap to Pay en Android funciona en un proceso dedicado para que las transacciones sean más seguras. En este proceso, se crea una segunda instancia de tu `Application`. Para evitar errores inesperados causados por la ejecución de tu código en un dispositivo Android, puedes omitir la inicialización en tu `Application` en este proceso marcando `TapToPay.isInTapToPayProcess()`.

```kotlin
class MainApplication : Application(), ReactApplication {
    override fun onCreate() {
        super.onCreate()

        // Skip initialization if running in the TTPA process.
        if (TapToPay.isInTapToPayProcess()) return

        // For example, this will be skipped.
        TerminalApplicationDelegate.onCreate(this)
    }
}
```

## Detectar lectores

- [discoverReaders (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#discoverReaders)

Utiliza el método `discoverReaders` para determinar el soporte de hardware para Tap to Pay en tu dispositivo.

Si tu aplicación se ejecuta en un dispositivo que no cumple con los requisitos anteriores, el método `discoverReaders` devolverá un error.

```js
export default function DiscoverReadersScreen() {
  const { discoverReaders, discoveredReaders } =
    useStripeTerminal({
      onUpdateDiscoveredReaders: (readers) => {
        // The `readers` variable will contain an array of all the discovered readers.
      },
    });

  useEffect(() => {
    const { error } = await discoverReaders({
      discoveryMethod: 'tapToPay',
    });
  }, [discoverReaders]);

  return <View />;
}
```

## Conectarse a un lector

- [connectReader (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#connectreader-1)

Para aceptar pagos de Tap to Pay, proporciona el lector detectado del paso anterior al método `connectReader`.

Debes [registrar tu lector](https://docs.stripe.com/terminal/fleet/locations-and-zones.md) en una [ubicación](https://docs.stripe.com/api/terminal/locations.md) tras la conexión. Para hacerlo, debes pasar el ID de ubicación correspondiente a `connectReader`.

Cuando utilices [cargos indirectos con on_behalf_of](https://docs.stripe.com/terminal/features/connect.md?connect-charge-type=destination) en iPhones, también deberás proporcionar el ID de la cuenta conectada.

```js
const { reader, error } = await connectReader({
    discoveryMethod: 'tapToPay',
    reader: selectedReader,
    locationId: "{{LOCATION_ID}}",
});

if (error) {
  console.log('connectTapToPayReader error:', error);
  return;
}

console.log('Reader connected successfully', reader);
```

### Vinculación de la cuenta y condiciones generales de Apple

Verás los términos y condiciones de Tap to Pay de Apple en el iPhone la primera vez que te conectes al lector. Para registrarte en Apple, deberás especificar un ID de Apple válido que represente a tu empresa antes de aceptar las condiciones presentadas por Apple. Solo necesitas realizar esto una vez por cada cuenta de Stripe. La cuenta no necesita repetir este proceso en conexiones posteriores, incluyendo en otros dispositivos móviles.

Cada cuenta conectada debe aceptar las condiciones generales cuando:

- Un usuario de Connect cree cargos directos
- Un usuario de Connect crea un cargo de destino y especifica una cuenta `on_behalf_of`
![Procesamiento en tres pasos que muestra el inicio de sesión en el ID de Apple, las condiciones aceptadas y la confirmación de éxito de Tap to Pay en iPhone](https://b.stripecdn.com/docs-statics-srv/assets/ttpoi-account-linking-steps.56bc5c0bb037a98f788a7e8d43d0c87e.png)

Vincula tu cuenta de Apple ID para aceptar pagos con Tap to Pay

Cualquier iPhone puede usar hasta 3 cuentas únicas de Stripe en todas las aplicaciones dentro de un período continuo de 24 horas al llamar a `connectReader` para Tap to Pay en iPhone. Si se utilizan más cuentas para el dispositivo dentro del mismo período de 24 horas, el método `connectReader` genera un error [SCPErrorTapToPayReaderMerchantBlocked](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPError.html#/c:@E@SCPError@SCPErrorTapToPayReaderMerchantBlocked).

Obtén más información sobre la vinculación de cuentas en la sección de Información empresarial de Tap to Pay en el iPhone de las [preguntas frecuentes sobre Tap to Pay en el iPhone de Apple](https://register.apple.com/tap-to-pay-on-iphone/faq.html).

## Gestionar las desconexiones inesperadas

- [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#REPORT_UNEXPECTED_READER_DISCONNECT)

Pueden producirse desconexiones inesperadas entre tu aplicación y el lector. Por ejemplo, es posible que el lector Tap to Pay se desconecte inesperadamente porque el dispositivo pierda la conectividad a Internet y cuando el sistema operativo Android finaliza el servicio del lector Tap to Pay debido a limitaciones de memoria.

Durante las pruebas, puedes simular una desconexión inesperada desactivando el acceso a Internet en tu dispositivo.

#### Intenta la reconexión de forma automática

Puedes establecer `autoReconnectOnUnexpectedDisconnect` como `true` para permitir que el SDK intente automáticamente volver a conectarse cuando se produzca una desconexión inesperada. El SDK adopta este comportamiento de forma predeterminada si omite esta configuración.

```js
const { reader, error } = await connectReader({
    discoveryMethod: 'tapToPay',
    reader,
    autoReconnectOnUnexpectedDisconnect: true, // default setting
});

if (error) {
  console.log('connectReader error:', error);
  return;
}

console.log('Reader connected successfully', reader);
```

Cuando el SDK intenta la reconexión de forma automática, ocurre lo siguiente:

1. El SDK te notifica a través de `onDidStartReaderReconnect`. Asegúrate de que la aplicación indique que se ha perdido la conexión y que se está intentando reconectar.
   - Puedes utilizar el método `cancelReaderReconnection` para detener el intento de reconexión en cualquier momento.
1. Si el SDK se vuelve a conectar correctamente al lector, Stripe te notifica a través de `onDidSucceedReaderReconnect`. Asegúrate de que la aplicación indique que se ha restablecido la conexión y de que continúe con el funcionamiento normal.
1. Si el SDK no puede reconectarse al lector, Stripe te notifica a través de `onDidFailReaderReconnect` y `onDidDisconnect`. Asegúrate de que la app indique que se ha producido una desconexión inesperada.

```js
const { discoverReaders, connectedReader, discoveredReaders } =
    useStripeTerminal({
      onDidStartReaderReconnect: (disconnectReason) => {
        // 1. Notified at the start of a reconnection attempt
        // Use cancelable to stop reconnection at any time
      },
      onDidSucceedReaderReconnect: () => {
        // 2. Notified when reader reconnection succeeds
        // App is now connected
      },
      onDidFailReaderReconnect: () => {
        // 3. Notified when reader reconnection fails
        // App is now disconnected
      }
    });
```

#### Gestiona la desconexión de forma manual

Para gestionar la desconexión por tu cuenta, debes:

1. Establece `autoReconnectOnUnexpectedDisconnect` como `false` para deshabilitar la reconexión automática predeterminada.
1. Implementa la devolución de llamada `onDidReportUnexpectedReaderDisconnect`.

Esto permite que tu aplicación se vuelva a conectar al lector de Tap to Pay y, cuando corresponda, notificar al usuario qué ha pasado y cómo puede habilitar el acceso a Tap to Pay. Los usuarios finales pueden resolver ciertos errores, como problemas de conexión a Internet.

```js
const { discoverReaders, connectedReader, discoveredReaders } =
    useStripeTerminal({
      onDidReportUnexpectedReaderDisconnect: (readers) => {
        // Consider displaying a UI to notify the user and start rediscovering readers
      },
    });
```

> Si gestionas la desconexión manualmente sin desactivar la reconexión automática, pueden producirse conflictos que interrumpan la sesión del lector.


## Próximos pasos

Has conectado tu aplicación al lector. A continuación, [recoge tu primer pago de Stripe Terminal](https://docs.stripe.com/terminal/payments/collect-card-payment.md).

El nombre y el logotipo de BBPOS y Chipper™ son marcas comerciales o marcas registradas de BBPOS Limited en los Estados Unidos y/u otros países. El nombre y el logotipo de Verifone® son marcas comerciales o marcas registradas de Verifone en los Estados Unidos y/u otros países. El uso de las marcas comerciales no implica la aprobación por parte de BBPOS o Verifone.