Alternativas para leer y escribir XML (y otros ficheros) en Android

Un artículo rápido antes de seguir con más temas del Curso de Programación Android.

Hace ya algún tiempo dedicamos varios artículos (I, II, III, IV) al tratamiento de ficheros XML en Android y vimos varias alternativas a la hora de leer (parsear) ficheros de este tipo. En todos los ejemplos decidí utilizar como entrada un fichero online, que obteníamos desde una determinada URL, porque pensé que sería el caso más típico que íbamos a necesitar en la mayoría de aplicaciones. Sin embargo, desde entonces han sido muchas las consultas que me han llegado relativas a cómo utilizar estos métodos para leer un fichero XML que se encuentre en un recurso local. Adicionalmente también he recibido muchos comentarios consultando las alternativas existentes para escribir ficheros XML. Pues bien, aunque las alternativas son muchas, voy a dedicar este pequeño artículo a intentar resolver ambas dudas.

Escribir ficheros XML en Android

Para escribir ficheros XML sin meternos en muchas complicaciones innecesarias se me ocurren básicamente dos formas. La primera de ellas, y la más sencilla y directa, es construir manualmente el XML utilizando por ejemplo un objeto StringBuilder y tras esto escribir el resultado a un fichero en memoria interna o externa tal como ya vimos en los artículos dedicados a tratamiento de ficheros (I y II). Esto quedaría de una forma similar a la siguiente:

//Creamos un fichero en la memoria interna
OutputStreamWriter fout =
	new OutputStreamWriter(
		openFileOutput("prueba.xml",
			Context.MODE_PRIVATE));

StringBuilder sb = new StringBuilder();

//Construimos el XML
sb.append("");
sb.append("" + "Usuario1" + "");
sb.append("" + "ApellidosUsuario1" + "");
sb.append("");

//Escribimos el resultado a un fichero
fout.write(sb.toString());
fout.close();

Como método alternativo también podemos utilizar el serializador XML incluido con la API XmlPull. Aunque no es un método tan directo como el anterior no deja de ser bastante intuitivo. Los pasos para conseguir esto serán crear el objeto XmlSerializer, crear el fichero de salida, asignar el fichero como salida del serializador y construir el XML mediante los métodos startTag(), text() y endTag() pasándoles los nombres de etiqueta y contenidos de texto correspondientes (aunque existen más métodos, por ejemplo para escribir atributos de una etiqueta, éstos tres son los principales). Finalmente deberemos llamar a endDocument() para finalizar y cerrar nuestro documento XML. Un ejemplo equivalente al anterior utilizando este método sería el siguiente:

//Creamos el serializer
XmlSerializer ser = Xml.newSerializer();

//Creamos un fichero en memoria interna
OutputStreamWriter fout =
	new OutputStreamWriter(
		openFileOutput("prueba_pull.xml",
			Context.MODE_PRIVATE));

//Asignamos el resultado del serializer al fichero
ser.setOutput(fout);

//Construimos el XML
ser.startTag("", "usuario");

ser.startTag("", "nombre");
ser.text("Usuario1");
ser.endTag("", "nombre");

ser.startTag("", "apellidos");
ser.text("ApellidosUsuario1");
ser.endTag("", "apellidos");

ser.endTag("", "usuario");

ser.endDocument();

fout.close();

Así de sencillo, no merece la pena complicarse la vida con otros métodos más complicados.


Leer ficheros XML en Android desde recursos locales

Para leer ficheros XML desde un recurso local se me ocurren varias posibilidades, por ejemplo leerlo desde la memoria interna/externa del dispositivo, leer un XML desde un recurso XML (carpeta /res/xml), desde un recurso Raw (carpeta /res/raw), o directamente desde la carpeta /assets de nuestro proyecto. Salvo en el segundo caso (recurso XML), en todos los demás la solución va a pasar por conseguir una referencia de tipo InputStream (os recuerdo que cualquiera de los métodos que vimos para leer un XML partían de una referencia de este tipo) a partir de nuestro fichero o recurso XML, sea cual sea su localización.

Así, por ejemplo, si el fichero XML está almacenado en la memoria interna de nuestro dispositivo, podríamos acceder a él mediante el método openFileInput() tal como vimos en los artículos dedicados a tratamiento de ficheros. Este método devuelve un objeto de tipo FileInputStream, que al derivar de InputStream podemos utilizarlo como entrada a cualquiera de los mecanismos de lectura de XML (SAX, DOM, XmlPull).

//Obtenemos la referencia al fichero XML de entrada
FileInputStream fil = openFileInput("prueba.xml");

//DOM (Por ejemplo)
DocumentBuilderFactory factory =
    DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();
Document dom = builder.parse(fil);

//A partir de aquí se trataría el árbol DOM como siempre.
//Por ejemplo:
Element root = dom.getDocumentElement();

//...

En el caso de encontrarse el fichero como recurso Raw, es decir, en la carpeta /res/raw, tendríamos que obtener la referencia al fichero mediante el método getRawResource() pasándole como parámetro el ID de recurso del fichero. Esto nos devuelve directamente el stream de entrada en forma de InputStream.

//Obtenemos la referencia al fichero XML de entrada
InputStream is = getResources().openRawResource(R.raw.prueba);

//DOM (Por ejemplo)
DocumentBuilderFactory factory =
    DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();
Document dom = builder.parse(is);

//A partir de aquí se trataría el árbol DOM como siempre.
//Por ejemplo:
Element root = dom.getDocumentElement();

//...

Por último, si el XML se encontrara en la carpeta /assets de nuestra aplicación, accederíamos a él a través del AssetManager, el cual podemos obtenerlo con el método getAssets() de nuestra actividad. Sobre este AssetManager tan sólo tendremos que llamar al método open() con el nombre del fichero para obtener una referencia de tipo InputStream a nuestro XML.

//Obtenemos la referencia al fichero XML de entrada
AssetManager assetMan = getAssets();
InputStream is = assetMan.open("prueba_asset.xml");

//DOM (Por ejemplo)
DocumentBuilderFactory factory =
    DocumentBuilderFactory.newInstance();

DocumentBuilder builder = factory.newDocumentBuilder();
Document dom = builder.parse(is);

//A partir de aquí se trataría el árbol DOM como siempre.
//Por ejemplo:
Element root = dom.getDocumentElement();

//...

El último caso, algo distinto a los anteriores, pasaría por leer el XML desde un recurso XML localizado en la carpeta /res/xml de nuestro proyecto. Para acceder a un recurso de este tipo debemos utilizar el método getXml() al cual debemos pasarle como parámetro el ID de recurso del fichero XML. Esto nos devolverá un objeto XmlResourceParser, que no es más que un parser de tipo XmlPull como el que ya comentamos en su momento. Por tanto, la forma de trabajar con este parser será idéntica a la que ya conocemos, por ejemplo:

//Obtenemos un parser XmlPull asociado a nuestro XML
XmlResourceParser xrp = getResources().getXml(R.xml.prueba);

//A partir de aquí utilizamos la variable 'xrp' como
//cualquier otro parser de tipo XmlPullParser. Por ejemplo:

int evento = xrp.getEventType();

if(evento == XmlPullParser.START_DOCUMENT)
	Log.i("XmlTips", "Inicio del documento");

//...

Por último, indicar que todas estas formas de acceder a un fichero en Android no se limitan únicamente a los de tipo XML, sino que pueden utilizarse para leer cualquier otro tipo de ficheros.

Como siempre, podéis descargar el código fuente completo de un sencillo programa de ejemplo que utiliza cada una de las alternativas comentadas.