Guardar Datos de Texto en Memoria Interna con Android

Buenas tardes, en esta entrada vamos a ver como podemos guardar texto en la memoria interna de nuestro teléfono.

---

Muchas veces se nos puede presentar un problema en nuestra aplicación, por ejemplo, en la que queramos guardar una cadena de texto en nuestra memoria interna y quizás veamos que no sea necesario hacer una base de datos SQLite para la aplicación, por lo cual optamos por guardarlo en un archivo de texto, en la memoria interna, ya que este texto no ocupará demasiado y vemos que es viable. Además, al contrario que con la memoria externa, este dato es privado y solo nuestra aplicación podría tener acceso a el.

Dicho esto, podemos ponernos manos a la obra:

• Creación del Proyecto

  Para comenzar a crear nuestro proyecto, nos vamos a dirigir a File -> New -> Android Application Projecto. Si por algún caso no nos aparece “Android Application Project” en la lista, vamos a pinchar en “Other”. Se nos desplegará entonces una lista en la que podremos encontrarlo, y podemos también introducir la palabra “Android” en la caja de texto, con lo que podremos filtrar los resultados para que nos sea mas fácil.

  Una vez lo hayamos localizado, aceptamos y nos aparecerá el asistente de creación del proyecto, donde empezaremos estableciendo un nombre al proyecto, en mi caso lo he llamado “EjemploGuardarDatos”, aunque podeis poner el nombre que deseeis. El resto de opciones podeis dejarlas igual.

  Mas adelante nos aparecerá, en una de las ventanas, que establezcamos un nombre para nuestra Activity principal, en mi caso la he llamado FilesActivity, y su archivo layout activity_files.xml, aunque los nombres podeis poner el que querais, no afecta al funcionamiento de la aplicación, pero si conviene que sea intuitivos para que al verlos sepamos en que consiste su contenido rápidamente.

  Cuando terminemos el asistente, tendremos nuestro proyecto creado y podremos ponernos manos a la obra

• FilesActivity

  Una vez nuestro proyecto esté creado, vamos a tener una Activity la cuál hemos denominado FilesActivity.java, y su archivo layour en la carpeta res/layout con el nombre activity_files.xml. En este archivo encontraremos la interfaz gráfica de nuestra Activity, el cuál modificaremos para que sea como el siguiente:

  		<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  		    xmlns:tools="http://schemas.android.com/tools"
  		    android:layout_width="match_parent"
  		    android:layout_height="match_parent"
  		    android:orientation="vertical"
  		    tools:context=".FilesActivity" >
  		
  		    <TextView
  		        android:layout_width="fill_parent"
  		        android:layout_height="wrap_content"
  		        android:text="Introduzca algún texto" />
  		
  		    <EditText
  		        android:id="@+id/txtText1"
  		        android:layout_width="fill_parent"
  		        android:layout_height="wrap_content" />
  		
  		    <Button
  		        android:id="@+id/btnGuardar"
  		        android:layout_width="fill_parent"
  		        android:layout_height="wrap_content"
  		        android:onClick="onClickGuardar"
  		        android:text="Guardar" />
  		
  		    <Button
  		        android:id="@+id/btnCargar"
  		        android:layout_width="fill_parent"
  		        android:layout_height="wrap_content"
  		        android:onClick="onClickCargar"
  		        android:text="Cargar" />
  		
  		</LinearLayout>
  		

  Podemos apreciar los siguientes elementos:

  • TextView:Este TextView se encargará de un proceso meramente descriptivo, para que introduzcamos algo en nuestro EditText.
  • EditText – @id/txtText1: En este EditText vamos a escribir un texto que posteriormente será guardado en el archivo.
  • Button – @id/btnGuardar: Cuando pulsemos este bóton, se ejecutará el método onClickGuardar(), recogiendo el texto del EditText y guardandolo en un fichero.
  • Button – @id/btnCargar: Cuando pulsemos este botón, se ejecutará el método onClickCargar(), donde se recogerá el texto que hay dentro del fichero y se establecerá en el EditText.

  Explicado esto, vamos a abrir nuestra Activity, llamada en mi caso FilesACtivity.java que se encuentra en el package sekth.droid.Files, de nuevo, así lo he llamado yo:

  		package sekth.droid.Files;
  
  		import java.io.FileInputStream;
  		import java.io.FileOutputStream;
  		import java.io.IOException;
  		import java.io.InputStreamReader;
  		import java.io.OutputStreamWriter;
  		
  		import android.app.Activity;
  		import android.os.Bundle;
  		import android.view.View;
  		import android.widget.EditText;
  		import android.widget.Toast;
  		
  		public class FilesActivity extends Activity {
  			private EditText textBox;
  			static final int READ_BLOCK_SIZE = 100;
  		
  			@Override
  			protected void onCreate(Bundle savedInstanceState) {
  				super.onCreate(savedInstanceState);
  				setContentView(R.layout.activity_files);
  		
  				textBox = (EditText) findViewById(R.id.txtText1);
  			}
  		
  			public void onClickGuardar(View v){
  				String str = textBox.getText().toString();
  				try{
  					FileOutputStream fos = openFileOutput("textFile.txt", MODE_PRIVATE);
  					OutputStreamWriter osw = new OutputStreamWriter(fos);
  					
  					// Escribimos el String en el archivo
  					osw.write(str);
  					osw.flush();
  					osw.close();
  					
  					// Mostramos que se ha guardado
  					Toast.makeText(getBaseContext(), "Guardado", Toast.LENGTH_SHORT).show();
  					
  					textBox.setText("");
  				}catch (IOException ex){
  					ex.printStackTrace();
  				}
  				
  			}
  			
  			public void onClickCargar(View v){
  				try{
  					FileInputStream fis = openFileInput("textFile.txt");
  					InputStreamReader isr = new InputStreamReader(fis);
  					
  					char[] inputBuffer = new char[READ_BLOCK_SIZE];
  					String s = "";
  					
  					int charRead;
  					while((charRead = isr.read(inputBuffer)) > 0){
  						// Convertimos los char a String
  						String readString = String.copyValueOf(inputBuffer, 0, charRead);
  						s += readString;
  						
  						inputBuffer = new char[READ_BLOCK_SIZE];
  					}
  					
  					// Establecemos en el EditText el texto que hemos leido
  					textBox.setText(s);
  					
  					// Mostramos un Toast con el proceso completado
  					Toast.makeText(getBaseContext(), "Cargado", Toast.LENGTH_SHORT).show();
  					
  					isr.close();
  				}catch (IOException ex){
  					ex.printStackTrace();
  				}
  			}
  		}
  		

  Según vemos, hemos creado 2 variables de instancia, una es el EditText que usaremos de manera global en la Activity, y otra variable de instancia es un int llamado READ_BLOCK_SIZE, el cual explicaremos luego su función.

  En el método onCreate hemos inicializado la variable textBox, que al fín y al cabo es el EditText que hemos declarado anteriormente. Ahora ya podemos usar el EditText en cualquier parte de nuestra actividad.

  		@Override
  		protected void onCreate(Bundle savedInstanceState) {
  			super.onCreate(savedInstanceState);
  			setContentView(R.layout.activity_files);
  	
  			textBox = (EditText) findViewById(R.id.txtText1);
  		}
  		

  Ahora vamos a explicar que hace cada uno de los métodos que hemos definido a continuación:

  • public void onClickGuardar(View v)

    Vamos a estudiar su código:

    				public void onClickGuardar(View v){
    					String str = textBox.getText().toString();
    					try{
    						FileOutputStream fos = openFileOutput("textFile.txt", MODE_PRIVATE);
    						OutputStreamWriter osw = new OutputStreamWriter(fos);
    						
    						// Escribimos el String en el archivo
    						osw.write(str);
    						osw.flush();
    						osw.close();
    						
    						// Mostramos que se ha guardado
    						Toast.makeText(getBaseContext(), "Guardado", Toast.LENGTH_SHORT).show();
    						
    						textBox.setText("");
    					}catch (IOException ex){
    						ex.printStackTrace();
    					}
    					
    				}
    				

    En este método obtenemos el valor del EditText y lo guardamos en la variable de referencia str, que es un String. A continuación abrimos un bloque try/catch, ya que los procesos de I/O son operaciones arriesgadas y podemos obtener una excepción del tipo IOException. Ahora creamos un objeto de la clase FileOutputStream, el cual va a crear un archivo cuyo nombre será “textFile.txt” y lo abrimos con el argumento MODE_PRIVATE, para que solo sea accesible por nuestra aplicación. Seguidamente vamos a crear un objeto de la clase OutputStreamReader el cual vamos a usar para escribir en el archivo. Una vez que ya hayamos escrito todo, vamos a cerrar el objeto osw, pero no sin antes ejecutar el método flush() para asegurarnos que todo ha sido grabado en el archivo. Si todo ha ido bien, un mensaje gracias a la clase Toast será mostrado.

  • public void onClickCargar(View v)

    Vamos a ver su código para estudiar lo que hace:

    				public void onClickCargar(View v){
    					try{
    						FileInputStream fis = openFileInput("textFile.txt");
    						InputStreamReader isr = new InputStreamReader(fis);
    						
    						char[] inputBuffer = new char[READ_BLOCK_SIZE];
    						String s = "";
    						
    						int charRead;
    						while((charRead = isr.read(inputBuffer)) > 0){
    							// Convertimos los char a String
    							String readString = String.copyValueOf(inputBuffer, 0, charRead);
    							s += readString;
    							
    							inputBuffer = new char[READ_BLOCK_SIZE];
    						}
    						
    						// Establecemos en el EditText el texto que hemos leido
    						textBox.setText(s);
    						
    						// Mostramos un Toast con el proceso completado
    						Toast.makeText(getBaseContext(), "Cargado", Toast.LENGTH_SHORT).show();
    						
    						isr.close();
    					}catch (IOException ex){
    						ex.printStackTrace();
    					}
    				}
    				

    En este método vamos a cargar todo el texto que haya en el fichero para meterlo en nuestro EditText. Para ello vamos a crear un objeto de la clase FileInputStream, al cual le pasamos como argumento el nombre del archivo que queremos abrir. A continuación vamos a crear otro objeto de la clase InputStreamReader el cual acepta como argumento el objeto fis, de la clase FileInputStream.

    				FileInputStream fis = openFileInput("textFile.txt");
    				InputStreamReader isr = new InputStreamReader(fis);
    				

    Ahora creamos un array de char[], al cual le vamos a establecer un tamaño de la constante que hemos definido antes. En este caso vamos a leer en bloques de 100 caracteres, y luego lo volcaremos en un String. Para lograr esto, vamos a crear un bucle que se repetirá mientras el array de caracteres sea mayor que 0, cuando sea 0, significará que no tenemos nada mas que leer.

    				char[] inputBuffer = new char[READ_BLOCK_SIZE];
    				String s = "";
    				int charRead;
    				

    Dentro del bucle vamos a pasar el array de caracteres a un String, mediante el método String.copyValueOf(), el cual como primer argumento acepta el array, como segundo argumento por donde comenzará, y como último argumento la cantidad de elementos que hemos leido. Ahora vamos a ir concatenando estas String a la String que luego mostraremos.

    				while((charRead = isr.read(inputBuffer)) > 0){
    					// Convertimos los char a String
    					String readString = String.copyValueOf(inputBuffer, 0, charRead);
    					s += readString;
    					...
    				}
    				

    Por último, volvemos a reinicializar el array para volver a repetir el proceso anterior:

    				inputBuffer = new char[READ_BLOCK_SIZE];
    				

    Al salir del bucle, vamos a establecer el texto que hemos leido en el EditText, y avisamos mediante un mensaje que ha sido cargado.

    				// Establecemos en el EditText el texto que hemos leido
    				textBox.setText(s);
    				

Con todo esto, nuestra aplicación ya sería funcional, y podemos ejecutarla para ver como queda finalmente.

A continuación un vídeo para ver la aplicación ejecutandose en tiempo real:

---

Con esta entrada hemos podido ver una de las mil maneras de las que podemos guardar un texto en nuestra memoria interna del dispositivo, a la cuál solo es accesible de modo privado por nuestra aplicación y no puede ser abierta por otras aplicaciones.

El código del ejemplo podeis descargarlo de aquí.

Sin más, cualquier aporte o corrección es bienvenido.

Saludos!!!