Almacenamiento de datos en un archivo de texto en la memoria interna

En este apartado se muestra cómo almacenar y recuperar información en un archivo de texto dentro de la memoria interna de la aplicación.
Se trabajará mediante un ejemplo guiado, utilizando una interfaz sencilla y código en Kotlin, con UI clásica basada en XML.

En la actualidad

El almacenamiento en archivos sigue siendo válido para datos simples y no estructurados (notas, logs locales, borradores).
Para datos estructurados o reactivos, se recomienda posteriormente DataStore o Room.

Objetivo del ejemplo

Se desarrollará una aplicación que:

• Permita escribir texto en un EditText (modo multilínea).
• Al pulsar un botón, guarde el contenido en un archivo de texto llamado notas.txt en la memoria interna.

• Cada vez que se inicie la aplicación:

  • Compruebe si existe el archivo notas.txt.
  • Si existe, lea su contenido y lo muestre automáticamente en el EditText.

Diseño de la interfaz

La interfaz será muy simple:

• Un EditText multilínea ocupando la parte superior de la pantalla.
• Un Button situado en la parte inferior para guardar los datos.

Configuraciones destacadas del EditText:

• background con el color amarillo (#FFFF00).
• Texto alineado en la parte superior izquierda mediante gravity.
• Altura suficiente para permitir la escritura de varias líneas.

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <EditText
        android:id="@+id/etNotas"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:background="#FFFF00"
        android:gravity="top|start"
        android:hint="Escribe tus notas aquí"
        android:inputType="textMultiLine"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toTopOf="@id/btnGuardar"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        android:padding="12dp"/>

    <Button
        android:id="@+id/btnGuardar"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Guardar"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginBottom="16dp"/>

</androidx.constraintlayout.widget.ConstraintLayout>

Código de la aplicación

El archivo se almacenará en la memoria interna, accesible únicamente por la aplicación.
No se requieren permisos especiales.

MainActivity.kt

import android.app.Activity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import java.io.BufferedReader
import java.io.IOException
import java.io.InputStreamReader
import java.io.OutputStreamWriter

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val botonGuardar = findViewById<Button>(R.id.btnGuardar)
        val editTextNotas = findViewById<EditText>(R.id.etNotas)

        // Lectura del archivo si existe
        if (fileList().contains("notas.txt")) {
            try {
                val archivo = InputStreamReader(openFileInput("notas.txt"))
                val br = BufferedReader(archivo)
                val contenido = StringBuilder()
                var linea: String? = br.readLine()

                while (linea != null) {
                    contenido.append(linea).append("\n")
                    linea = br.readLine()
                }

                br.close()
                archivo.close()
                editTextNotas.setText(contenido.toString())

            } catch (e: IOException) {
                e.printStackTrace()
            }
        }

        // Escritura del archivo
        botonGuardar.setOnClickListener {
            try {
                val archivo = OutputStreamWriter(
                    openFileOutput("notas.txt", Activity.MODE_PRIVATE)
                )
                archivo.write(editTextNotas.text.toString())
                archivo.flush()
                archivo.close()

                Toast.makeText(this, "Los datos fueron grabados", Toast.LENGTH_SHORT).show()

            } catch (e: IOException) {
                e.printStackTrace()
            }
        }
    }
}

Funcionamiento del ejemplo

• openFileOutput() crea o sobrescribe el archivo en la memoria interna.
• openFileInput() permite leer el archivo si existe.
• fileList() devuelve un array con los archivos almacenados por la app.
• El archivo notas.txt solo es accesible por esta aplicación.

Ventajas de este enfoque

• No requiere permisos adicionales.
• Ideal para texto libre o datos no estructurados.
• Fácil de implementar y comprender.

Limitaciones

• No es adecuado para grandes volúmenes de datos.
• No permite consultas estructuradas.
• No es reactivo ni observable.

Actividad

• AC602. Realiza el ejemplo en Compose, realiza una investigación para poder replicarlo.