datos

UNIVERSIDAD TECNONOLÓGICA DEL ESTADO DE ZACATECAS UNIDAD ACADÉMICA DE PINOS

TECNOLOGÍAS DE LA INFORMACIÓN Y COMUNICACIÓN

Materia: Desarrollo de aplicaciones III

Tema: Interfaz Almacenamiento De Datos.

Nombre completo del Alumno : Edgar Eduardo Renovato Contreras,

Grado: 5 Grupo: B Nombre del Docente : Eloy Contreras de Lira Fecha de entrega : 25/03/2014



Después de que tengamos nuestro proyecto realizado se comenzará a trabajar.

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:

http://schemas.android.com/apk/res/android

http://schemas.android.com/tools



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.

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 leído textBox.setText(s);

Después podemos ejecutar la aplicación:



1 Escribir Datos: aquí podemos Escribir los datos que sean necesarios.

2 Guardar Datos: Aquí podemos Guardar los Datos que se decidan agregar ya

que tengamos escritos los datos presionamos el boton “Guardar”



3 Despues e presionar el boton Guardar aparecera un mensaje que diga

“Guardado”

4 Para poder consultar un dato Presionamos el Botón “Cargar” Después aparecerá

un mensaje que diga Cargado.



5 Al haber cargado los datos podemos modificarlos y después guardando con el

botón Guardar. Al mismo tiempo podemos eliminar los datos.

6 después nos muestra el mensaje que los datos editados fueron guardados

datos

Documents