> For the complete documentation index, see [llms.txt](https://docs.payments.thalescloud.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.payments.thalescloud.io/nfc-wallet-sdk-android/es/additional-features/collect-logs-with-secure-logger.md).

# Recopilar registros con LogService

## Resumen

El SDK NFC Wallet recopila registros de tiempo de ejecución y los almacena en la zona protegida de la aplicación.

Tu aplicación de cartera digital puede recuperar archivos de registro y compartirlos con Thales para la resolución de problemas.

A partir de NFC Wallet SDK 6.14.0, el registro se habilita automáticamente con la configuración predeterminada.

## Integración del SDK

### Obtener el servicio de registro

{% hint style="warning" %}
La API de Secure Logger está obsoleta. Debes usar LogService.

Ver [Migrar desde la API de secure logger](#migrate-from-secure-logger-api) para más detalles.
{% endhint %}

Recupera la instancia de `LogService` :

{% tabs %}
{% tab title="Java" %}

```java
LogService logService = SDKInitializer.getLogService(context);
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val logService = SDKInitializer.getLogService(context)
```

{% endtab %}
{% endtabs %}

El SDK aplica automáticamente la configuración predeterminada durante la inicialización del SDK.

###

{% tabs %}
{% tab title="Java" %}

```java
// Antes de 6.14.0
SecureLog secureLog = SDKInitializer.INSTANCE.configureSecureLog(
        new SecureLogConfig.Builder(context)
                .build()
);

secureLog.setLevel(SecureLogLevel.INFO);
List<File> files = secureLog.getFiles();
secureLog.deleteFiles();

// Desde 6.14.0
LogService logService = SDKInitializer.getLogService(context);

logService.setLevel(LogService.Level.INFO);
List<File> files = logService.getFiles();
logService.deleteFiles();
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
// Antes de 6.14.0
val secureLog = SDKInitializer.INSTANCE.configureSecureLog(
    SecureLogConfig.Builder(context).build()
)

secureLog.setLevel(SecureLogLevel.INFO)
val files = secureLog.files
secureLog.deleteFiles()

// Desde 6.14.0
val logService = SDKInitializer.getLogService(context)

logService.setLevel(LogService.Level.INFO)
val files = logService.files
logService.deleteFiles()
```

{% endtab %}
{% endtabs %}

### Cambiar el nivel de registro

Usa `setLevel(...)` para cambiar el nivel de registro. El nivel de registro predeterminado es `Level.WARN`.

{% tabs %}
{% tab title="Java" %}

```java
LogService logService = SDKInitializer.getLogService(context);
logService.setLevel(LogService.Level.INFO);
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val logService = SDKInitializer.getLogService(context)
logService.setLevel(LogService.Level.INFO)
```

{% endtab %}
{% endtabs %}

Establece el nivel en `OFF` para dejar de escribir nuevas entradas de registro.

### Niveles de registro

Usa el nivel más bajo que admita tu caso de uso.

| Nivel   | Valor numérico | Usa                                                                                     |
| ------- | -------------- | --------------------------------------------------------------------------------------- |
| `ALL`   | 7              | Captura todas las entradas de registro. Equivalente a `DEBUG`.                          |
| `DEBUG` | 7              | Captura registros detallados para la resolución de problemas. Úsalo solo temporalmente. |
| `INFO`  | 6              | Captura registros operativos de rutina.                                                 |
| `ERROR` | 3              | Captura errores de tiempo de ejecución que requieren investigación.                     |
| `WARN`  | 4              | Captura advertencias. Este es el nivel predeterminado.                                  |
| `FATAL` | 2              | Captura solo errores irrecuperables de tiempo de ejecución.                             |
| `OFF`   | 0              | Desactiva el registro.                                                                  |

{% hint style="info" %}
Usa `DEBUG` solo para sesiones cortas de resolución de problemas.

Para el funcionamiento normal, mantén el nivel predeterminado `WARN`.
{% endhint %}

### Desactivar el registro

A partir de NFC Wallet SDK 6.14.0, el registro está habilitado de forma predeterminada.

Establece el nivel en `OFF` para desactivarlo:

{% tabs %}
{% tab title="Java" %}

```java
LogService logService = SDKInitializer.getLogService(context);
logService.setLevel(LogService.Level.OFF);
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val logService = SDKInitializer.getLogService(context)
logService.setLevel(LogService.Level.OFF)
```

{% endtab %}
{% endtabs %}

### Recuperar archivos de registro

Después de recuperar la instancia de `LogService` , llama a `getFiles()`:

{% tabs %}
{% tab title="Java" %}

```java
LogService logService = SDKInitializer.getLogService(context);

// Devuelve la lista de archivos
List<File> files = logService.getFiles();
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val logService = SDKInitializer.getLogService(context)

// Devuelve la lista de archivos
val files = logService.files
```

{% endtab %}
{% endtabs %}

Llama a `deleteFiles()` para eliminar los archivos de registro:

{% tabs %}
{% tab title="Java" %}

```java
LogService logService = SDKInitializer.getLogService(context);
logService.deleteFiles();
```

{% endtab %}

{% tab title="Kotlin" %}

```kotlin
val logService = SDKInitializer.getLogService(context)
logService.deleteFiles()
```

{% endtab %}
{% endtabs %}

### Ejemplo completo

Este ejemplo recupera la instancia del servicio de registro, comprime todos los archivos de registro y los comparte mediante la hoja de compartir de Android.

{% tabs %}
{% tab title="Java" %}
{% code title="LogServiceHelper.java" expandable="true" %}

```java
public class LogServiceHelper {

    private static LogService getLogService(Context context) {
        return SDKInitializer.getLogService(context);
    }

    public static void setDebugLogLevel(Context context) {
        LogService logService = getLogService(context);
        logService.setLevel(LogService.Level.DEBUG);
    }

    public static void shareLogs(Activity activity) {
        LogService logService = getLogService(activity.getApplicationContext());
        List<File> files = logService.getFiles();
        if (files == null || files.isEmpty()) {
            // No hay registros para compartir
            return;
        }

        File directory = files.get(0).getParentFile();
        String outputZipPath = activity.getCacheDir().getAbsolutePath() + "/temp.zip";

        Thread zipTask = new Thread(new Runnable() {
            @Override
            public void run() {
                File file = new File(outputZipPath);
                if (file.exists()) {
                    file.delete();
                }

                zipFolder(directory.getAbsolutePath(), outputZipPath);

                if (!file.exists() || !file.canRead()) {
                    return;
                }

                // Si usas un FileProvider, decláralo en el manifiesto de la aplicación.
                Uri uri = FileProvider.getUriForFile(activity, "your.fileprovider.authority", file);

                Intent shareIntent = new Intent(Intent.ACTION_SEND);
                shareIntent.setType("application/zip");
                shareIntent.putExtra(Intent.EXTRA_SUBJECT, "Archivos de registro");
                shareIntent.putExtra(Intent.EXTRA_STREAM, uri);
                shareIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

                activity.startActivity(Intent.createChooser(shareIntent, "Compartir registros"));
            }
        });

        zipTask.start();
    }

    private static void zipFolder(String inputFolderPath, String outZipPath) {
        try {
            FileOutputStream fos = new FileOutputStream(outZipPath);
            ZipOutputStream zos = new ZipOutputStream(fos);
            File srcFile = new File(inputFolderPath);
            File[] files = srcFile.listFiles();

            for (int i = 0; i < files.length; i++) {
                byte[] buffer = new byte[1024];
                FileInputStream fis = new FileInputStream(files[i]);
                zos.putNextEntry(new ZipEntry(files[i].getName()));
                int length;
                while ((length = fis.read(buffer)) > 0) {
                    zos.write(buffer, 0, length);
                }
                zos.closeEntry();
                fis.close();
            }
            zos.close();
        } catch (IOException ioe) {
            Log.e("", ioe.getMessage());
        }
    }
}
```

{% endcode %}
{% endtab %}

{% tab title="Kotlin" %}
{% code title="LogServiceHelper.kt" expandable="true" %}

```kotlin
object LogServiceHelper {

    private fun getLogService(context: Context): LogService {
        return SDKInitializer.getLogService(context)
    }

    fun setDebugLogLevel(context: Context) {
        val logService = getLogService(context)
        logService.setLevel(LogService.Level.DEBUG)
    }

    fun shareLogs(activity: Activity) {
        val logService = getLogService(activity.applicationContext)
        val files = logService.files
        if (files.isNullOrEmpty()) {
            // No hay registros para compartir
            return
        }

        val directory = files[0].parentFile
        val outputZipPath = activity.cacheDir.absolutePath + "/temp.zip"

        val zipTask = Thread {
            val file = File(outputZipPath)
            if (file.exists()) {
                file.delete()
            }

            zipFolder(directory.absolutePath, outputZipPath)

            if (!file.exists() || !file.canRead()) {
                return@Thread
            }

            // Si usas un FileProvider, decláralo en el manifiesto de la aplicación.
            val uri = FileProvider.getUriForFile(activity, "your.fileprovider.authority", file)

            val shareIntent = Intent(Intent.ACTION_SEND).apply {
                type = "application/zip"
                putExtra(Intent.EXTRA_SUBJECT, "Archivos de registro")
                putExtra(Intent.EXTRA_STREAM, uri)
                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
            }

            activity.startActivity(Intent.createChooser(shareIntent, "Compartir registros"))
        }

        zipTask.start()
    }

    private fun zipFolder(inputFolderPath: String, outZipPath: String) {
        try {
            val fos = FileOutputStream(outZipPath)
            val zos = ZipOutputStream(fos)
            val srcFile = File(inputFolderPath)
            val files = srcFile.listFiles() ?: return

            for (currentFile in files) {
                val buffer = ByteArray(1024)
                val fis = FileInputStream(currentFile)
                zos.putNextEntry(ZipEntry(currentFile.name))
                var length: Int
                while (fis.read(buffer).also { length = it } > 0) {
                    zos.write(buffer, 0, length)
                }
                zos.closeEntry()
                fis.close()
            }
            zos.close()
        } catch (ioe: IOException) {
            Log.e("", ioe.message ?: "")
        }
    }
}
```

{% endcode %}
{% endtab %}
{% endtabs %}

### Migrar desde la API de secure logger

Elimina el código de configuración obsoleto.

Luego recupera la instancia de `LogService` cuando la necesites.

| API obsoleta                                                  | Reemplazo                                                     |
| ------------------------------------------------------------- | ------------------------------------------------------------- |
| `SDKInitializer.INSTANCE.configureSecureLog(SecureLogConfig)` | `SDKInitializer.getLogService(Context)`                       |
| `SecureLogConfig.Builder(...)`                                | No hay reemplazo. El SDK usa la configuración predeterminada. |
| `secureLog.setLevel(SecureLogLevel.X)`                        | `logService.setLevel(LogService.Level.X)`                     |
| `secureLog.getFiles()`                                        | `logService.getFiles()`                                       |
| `secureLog.deleteFiles()`                                     | `logService.deleteFiles()`                                    |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.payments.thalescloud.io/nfc-wallet-sdk-android/es/additional-features/collect-logs-with-secure-logger.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.