Programación

Guardar y Leer en Android

Guardar y Leer datos de un archivo en Android

Android dispone de distintos métodos para crear, almacenar y leer archivos además de distintos tipos de almacenamiento, para ello es recomendable distinguir el almacenamiento interno del almacenamiento externo. 

ALMACENAMIENTO INTERNO

El sistema Android dispone de varios métodos para que el manejo de los distintos tipos de archivo se realice en el almacenamiento interno. A continuación se exponen algunos ejemplos de creación, lectura y escritura de archivos realizados en el almacenamiento interno.

Archivo binario

El siguiente ejemplo es una aplicación básica, basada en dos botones. Un botón "Guardar", que al pulsarlo acciona un evento que crea un archivo y escribe datos,  y un segundo botón "Leer" que acciona el evento realizando el proceso de lectura y mostrándolo en pantalla.

La parte relevante de este código se apoya en las clases FileInputStream y FileOutputStream que están diseñadas para manejar archivos de tipo binario y los métodos abstractos openFileOutput y openFileInput que permiten asignar y obtener la ruta y el nombre del archivo en el almacenamiento interno.

activity_main.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="//schemas.android.com/apk/res/android"
  3.     xmlns:app="//schemas.android.com/apk/res-auto"
  4.     xmlns:tools="//schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     android:orientation="vertical"
  8.     tools:context="xip.midominio.com.guardaryleer.MainActivity">
  10.     <TextView
  11.         android:id="@+id/archivo"
  12.         android:layout_width="match_parent"
  13.         android:layout_height="wrap_content"
  14.         android:hint="elemento"
  15.          />
  16.     <Button
  17.         android:id="@+id/read"
  18.         android:layout_width="match_parent"
  19.         android:layout_height="wrap_content"
  20.         android:text="Leer"
  21.         />
  22.     <Button
  23.         android:id="@+id/save"
  24.         android:layout_width="match_parent"
  25.         android:layout_height="wrap_content"
  26.         android:text="Guardar"
  27.         />
  28. </LinearLayout>

MainActivity.java

  1. package xip.midominio.com.sharedpreferences;
  3. import android.content.Context;
  4. import android.content.SharedPreferences;
  5. import android.support.v7.app.AppCompatActivity;
  6. import android.os.Bundle;
  7. import android.view.View;
  8. import android.widget.Button;
  9. import android.widget.EditText;
  10. import android.widget.TextView;
  12. import java.io.BufferedReader;
  13. import java.io.FileInputStream;
  14. import java.io.FileNotFoundException;
  15. import java.io.FileOutputStream;
  16. import java.io.IOException;
  17. import java.io.InputStreamReader;
  18. import java.io.UnsupportedEncodingException;
  20. public class MainActivity extends AppCompatActivity {
  21.     TextView archivo;
  22.     Button save,read;
  23.     @Override
  24.     protected void onCreate(Bundle savedInstanceState) {
  25.         super.onCreate(savedInstanceState);
  26.         setContentView(R.layout.activity_main);
  28.         archivo= (TextView)findViewById(R.id.archivo);
  29.         read = (Button) findViewById(R.id.read);
  30.         save = (Button)findViewById(R.id.save);
  32.         save.setOnClickListener(new View.OnClickListener() {
  33.             @Override
  34.             public void onClick(View view) {
  35.                 String fileName = "Archivo";
  36.                 String content = "Cadena";
  37.                 FileOutputStream outputStream = null;
  38.                 try{
  39.                     outputStream = openFileOutput(fileName,Context.MODE_PRIVATE);
  40.                     outputStream.write(content.getBytes());
  41.                     outputStream.close();
  42.                 }catch(Exception e){
  43.                     e.printStackTrace();
  44.                 }
  45.             }
  46.         });
  48.         read.setOnClickListener(new View.OnClickListener() {
  49.             @Override
  50.             public void onClick(View view) {
  51.                 try {
  52.                     FileInputStream fileInputStream = getApplicationContext().openFileInput("Archivo");
  53.                     InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"UTF-8");
  54.                     BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
  55.                     StringBuilder sb = new StringBuilder();
  56.                     String line;
  58.                     while((line = bufferedReader.readLine()) != null){
  59.                         sb.append(line).append("\n");
  60.                     }
  61.                     archivo.setText(sb.toString());
  62.                 }catch(FileNotFoundException f){
  64.                 }catch(UnsupportedEncodingException e){
  66.                 }catch(IOException ioe){
  68.                 }
  69.             }
  70.         });
  71.     }
  72. }

Archivo de texto

Este código, basado en el mismo layout, es muy similar al anterior pero apoyándose en las clases FileWriter y FileReader que son clases diseñadas para el manejo de archivos de caracteres. A diferencia del ejemplo anterior, los eventos de los botones "Guardar" y "Leer" se apoyan en los métodos creatFile() y readFile() respectivamente.

Otra diferencia es que se escoge el almacenamiento interno mediante el método getFilesdir() y la clase File() obteniendo un resultado de tipo File, en lugar de los dos métodos anteriores (openFileInput() y openFileOutput()), que devuelven un resultado de tipo FileOutputStream.

  1. package xip.midominio.com.guardaryleersd;
  2. import android.Manifest;
  3. import android.content.pm.PackageManager;
  4. import android.os.Environment;
  5. import android.support.v4.app.ActivityCompat;
  6. import android.support.v7.app.AppCompatActivity;
  7. import android.os.Bundle;
  8. import android.util.Log;
  9. import android.view.View;
  10. import android.widget.Button;
  11. import android.widget.TextView;
  12. import java.io.BufferedReader;
  13. import java.io.File;
  14. import java.io.FileNotFoundException;
  15. import java.io.FileReader;
  16. import java.io.FileWriter;
  17. import java.io.IOException;
  18. public class MainActivity extends AppCompatActivity {
  19.     TextView texto;
  20.     Button botonS,botonR;
  21.     @Override
  22.     protected void onCreate(Bundle savedInstanceState) {
  23.         super.onCreate(savedInstanceState);
  24.         setContentView(R.layout.activity_main);
  25.         texto = (TextView)findViewById(R.id.texto);
  26.         botonS = (Button)findViewById(R.id.save);
  27.         botonR = (Button)findViewById(R.id.read);
  28.         botonS.setOnClickListener(new View.OnClickListener() {
  29.             @Override
  30.             public void onClick(View view) {
  31.                 creatFile();
  32.             }
  33.         });
  34.         botonR.setOnClickListener(new View.OnClickListener() {
  35.             @Override
  36.             public void onClick(View view) {
  37.                 readFile();
  38.             }
  39.         });
  40.     }
  41.     public void creatFile(){
  42.         try{
  43.             File file = new File(getFilesDir(), "/archivoSD.txt");
  44.             FileWriter fileWriter = new FileWriter(file);
  45.             fileWriter.write("Esto es una prueba");
  46.             fileWriter.close();        
  47.         } catch (IOException e) {
  48.                 Log.e("Archivos","Error al escribir el archivo");
  49.         }        
  50.     }
  51.     
  52.     public void readFile(){
  53.         try {
  54.         File file = new File(getFilesDir()+"/archivoSD.txt");
  55.         BufferedReader bufferedReader = new      BufferedReader(new FileReader(file));
  56.             String linea="";
  57.             String bufer="";
  58.             while((linea = bufferedReader.readLine()) != null){
  59.                 bufer +=linea;
  60.             }
  61.             texto.setText(bufer.toString());
  62.             bufferedReader.close();
  63.         }catch(FileNotFoundException e){
  64.             e.printStackTrace();
  65.         }catch(IOException f){
  66.             f.printStackTrace();
  67.         }
  68.     }
  69. }

ALMACENAMIENTO EXTERNO

Android dispone de métodos para que el manejo de archivos se realice en el almacenamiento externo. Este tipo de almacenamiento permite dos tipos de rutas o directorios: públicos y privados.

Los públicos permiten el acceso a los archivos desde otras aplicaciones o desde otros dispositivos, principalmente para archivos de audio, imagen o vídeo. Los privados se establecen en directorios predefinidos por Android para cada aplicación.

A diferencia del almacenamiento interno, éste requiere de la configuración de permisos en el archivo AndroidManifest.xml. A continuación algunos ejemplos de creación, escritura y lectura de archivos en el almacenamiento externo.

PERMISOS

Permisos requeridos para el acceso al almacenamiento externo (AndroidManifest.xml).

  1. <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
  2. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

ARCHIVO BINARIO (directorio privado)

Esta aplicación está basada en el mismo ejemplo binario del almacenamiento interno, pero manejando los archivos en el almacenamiento externo, apoyándose para ello en la clase File y el método getExternalFilesDir(). 

Como característica añadida, se incluye una solicitud de permisos que exige al usuario la confirmación de permisos de escritura. Este tipo de solicitud de permisos se ejecuta solo la primera vez que se realiza la acción y viene ya definido y diseñado por el sistema, que según la versión de Android instalada puede tener ciertas variaciones.

activity_main.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="//schemas.android.com/apk/res/android"
  3.     xmlns:app="//schemas.android.com/apk/res-auto"
  4.     xmlns:tools="//schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     android:orientation="vertical"
  8.     tools:context="xip.midominio.com.guardaryleer.MainActivity">
  10.     <Button
  11.         android:id="@+id/save"
  12.         android:layout_width="match_parent"
  13.         android:layout_height="wrap_content"
  14.         android:text="Guardar"
  15.         />
  16.     <Button
  17.         android:id="@+id/read"
  18.         android:layout_width="match_parent"
  19.         android:layout_height="wrap_content"
  20.         android:text="Leer"
  21.         />
  22.     <TextView
  23.         android:id="@+id/texto"
  24.         android:layout_width="match_parent"
  25.         android:layout_height="wrap_content"
  26.         android:text="Archivo"
  27.         />
  28. </LinearLayout>

MainActivity.java

  1. package xip.midominio.com.savereadsd;
  3. import android.support.v7.app.AppCompatActivity;
  4. import android.os.Bundle;
  5. import android.view.View;
  6. import android.widget.Button;
  7. import android.widget.TextView;
  8. import java.io.BufferedReader;
  9. import java.io.File;
  10. import java.io.FileInputStream;
  11. import java.io.FileNotFoundException;
  12. import java.io.FileOutputStream;
  13. import java.io.IOException;
  14. import java.io.InputStreamReader;
  15. import java.io.OutputStreamWriter;
  16. public class MainActivity extends AppCompatActivity {
  17.     TextView texto;
  18.     Button botonS,botonR;
  19.     @Override
  20.     protected void onCreate(Bundle savedInstanceState) {
  21.         super.onCreate(savedInstanceState);
  22.         setContentView(R.layout.activity_main);
  23.         texto = (TextView)findViewById(R.id.texto);
  24.         botonS = (Button)findViewById(R.id.save);
  25.         botonR = (Button)findViewById(R.id.read);
  26.         botonS.setOnClickListener(new View.OnClickListener() {
  27.             @Override
  28.             public void onClick(View view) {
  29.                 creatFile();
  30.             }
  31.         });
  32.         botonR.setOnClickListener(new View.OnClickListener() {
  33.             @Override
  34.             public void onClick(View view) {
  35.                 readFile();
  36.             }
  37.         });
  38.     }
  39.     public void creatFile(){
  40.         try {
  41.             if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
  42.                 ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
  43.                 return;
  44.             }            
  45.             File file = new File(getExternalFilesDir(null),"/archivoSD.txt");
  46.             FileOutputStream fileOutputStream = new FileOutputStream(file);
  47.             OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream);
  48.             outputStreamWriter.append("Archivo guardado en SD");
  49.             outputStreamWriter.close();
  50.             fileOutputStream.close();
  51.         }catch(IOException e){
  52.             e.printStackTrace();
  53.         }
  54.     }
  55.     public void readFile(){
  56.         try {
  57.             File file = new File(getExternalFilesDir(null)+"/archivoSD.txt");
  58.             FileInputStream fileInputStream = new FileInputStream(file);
  59.             BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(fileInputStream));
  60.             String linea="";
  61.             String bufer="";
  62.             while((linea = bufferedReader.readLine()) != null){
  63.                 bufer +=linea;
  64.             }
  65.             texto.setText(bufer.toString());
  66.             fileInputStream.close();
  67.             bufferedReader.close();
  68.         }catch(FileNotFoundException e){
  69.             e.printStackTrace();
  70.         }catch(IOException f){
  71.             f.printStackTrace();
  72.         }
  73.     }
  74. }

Archivo de texto (directorio privado)

Este aplicación basada en el mismo layout y los mismos métodos para leer y escribir que el anterior ejemplo de texto expuesto en el almacenamiento interno. Sin embargo, se han añadido dos funcionalidades a destacar.

Por una parte, se han incluido dos métodos (isExternalStorageWritable() y isExternalStorageReadable()) que comprueban si el almacenamiento externo está disponible, y por otra parte al método getExternalFilesDir() se le ha añadido un nuevo parámetro que representa un directorio de documentos predefinido. 

  1.  File file = new File(getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS) + "/archivoSD.txt");

Se puede optar por uno de los múltiples campos de la clase Environment() que representan un subdirectorio y que pueden ser consultados en su documentación oficial.

O se puede prescindir de la clase Environment() y añadir un subdirectorio  personalizado.

  1. File file = new File(getExternalFilesDir("/nuevoDirectorio")+"/archivoSD.txt");

    MainActivity.java

    1. package xip.midominio.com.guardaryleersd;
    2. import android.Manifest;
    3. import android.content.Context;
    4. import android.content.pm.PackageManager;
    5. import android.os.Environment;
    6. import android.support.v4.app.ActivityCompat;
    7. import android.support.v4.content.ContextCompat;
    8. import android.support.v7.app.AppCompatActivity;
    9. import android.os.Bundle;
    10. import android.util.Log;
    11. import android.view.View;
    12. import android.widget.Button;
    13. import android.widget.TextView;
    14. import java.io.BufferedReader;
    15. import java.io.File;
    16. import java.io.FileNotFoundException;
    17. import java.io.FileReader;
    18. import java.io.FileWriter;
    19. import java.io.IOException;
    20. public class MainActivity extends AppCompatActivity {
    21.     TextView texto;
    22.     Button botonS,botonR;
    23.     Context context;
    24.     File[] sd;
    25.     @Override
    26.     protected void onCreate(Bundle savedInstanceState) {
    27.         super.onCreate(savedInstanceState);
    28.         setContentView(R.layout.activity_main);
    29.         context=this;
    30.         texto = (TextView)findViewById(R.id.texto);
    31.         botonS = (Button)findViewById(R.id.save);
    32.         botonR = (Button)findViewById(R.id.read);
    33.         botonS.setOnClickListener(new View.OnClickListener() {
    34.             @Override
    35.             public void onClick(View view) {
    36.                 creatFile(view);
    37.             }
    38.         });
    39.         botonR.setOnClickListener(new View.OnClickListener() {
    40.             @Override
    41.             public void onClick(View view) {
    42.                 readFile();
    43.             }
    44.         });
    45.     }
    46.     public void creatFile(View view){
    47.         if(isExternalStorageWritable()) {
    48.             try {
    49.                 File file = new File(getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS) + "/archivoSD.txt");    
    50.                 File file = new File(getFilesDir(), "/archivoSD.txt");                
    51.                 FileWriter fileWriter = new FileWriter(file);
    52.                 fileWriter.write("Esto es una prueba");
    53.                 fileWriter.close();
    54.             } catch (IOException e) {                
    55.                 Log.e("Archivos","Error al escribir el archivo");
    56.             }
    57.         }
    58.     }
    59.     public void readFile(){
    60.         if(isExternalStorageReadable()){
    61.             try {
    62.             File file = new File(getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS)+"/archivoSD.txt");
    63.                 BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
    64.                 String linea="";
    65.                 String bufer="";
    66.                 while((linea = bufferedReader.readLine()) != null){
    67.                     bufer +=linea;
    68.                 }
    69.                 texto.setText(bufer.toString());
    70.                 bufferedReader.close();
    71.             }catch(FileNotFoundException e){
    72.                 e.printStackTrace();
    73.             }catch(IOException f){
    74.                 f.printStackTrace();
    75.             }
    76.         }
    77.     }
    78.     public boolean isExternalStorageWritable() {
    79.         String state = Environment.getExternalStorageState();
    80.         if (Environment.MEDIA_MOUNTED.equals(state)) {
    81.             return true;
    82.         }
    83.         return false;
    84.     }
    85.     public boolean isExternalStorageReadable() {
    86.         String state = Environment.getExternalStorageState();
    87.         if (Environment.MEDIA_MOUNTED.equals(state) ||
    88.                 Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
    89.             return true;
    90.         }
    91.         return false;
    92.     }    
    93. }


    Comentarios: 0

    Para poder comentar es necesario iniciar sesión


    Este dominio utiliza cookies de terceros para crear estadísticas y publicidad personalizada. Si continúa navegando está aceptando su uso