PDM Avanzado Procesar arquivos XML

De MediaWiki
Saltar a: navegación, buscar

Introdución

O XML é unha linguaxe de marcas en formato de texto moi útil para o intercambio de información entre diferentes plataformas.


Un exemplo de arquivo XML pode ser o seguinte:

  1. <contactos>
  2.     <contacto>
  3.             <nome>Angel</nome>
  4.             <dir>C/ de Ala nº 12</dir>
  5.             <tel tipo="fixo">981111111</tel>
  6.             <tel tipo="mobil">691111111</tel>
  7.     </contacto>
  8.     <contacto>
  9.             <nome>Luis</nome>
  10.             <dir>C/ de Acola nº 55</dir>
  11.             <tel tipo="fixo">982222222</tel>
  12.             <tel tipo="mobil">692222222</tel>
  13.     </contacto>
  14. </contactos>

Nesta unidade imos aprender como podemos ler o contido do arquivo e trasladar os datos ó noso programa (poden ser elementos gráficos coma listas ou bases de datos, como xa vimos).

Procesando arquivos XML

Para ler un arquivo XML temos dúas aproximacións:

  • DOM: Document Object Model. Ten coma principal desvantaxe que é necesario gardar todo o documento en memoria e coma principal vantaxe que podemos acceder a calquera parte do documento indo cara adiante ou cara atrás.
  • SAX, que ven a ser usar XmlPullParser en Android: non podemos movernos pola estrutura xml e só gardamos en memoria o que imos lendo.

Os pasos que temos que dar para ler e procesar un arquivo XML son:

  • Paso 1: Crear un obxecto da clase XmlPullParser e asinarlle o InputStream do arquivo que queremos ler.
  1. InputStream is = getAssets().open("ArquivoXML.xml");
  2.                
  3. XmlPullParser parser = Xml.newPullParser();
  4. parser.setInput(is, "UTF-8");

Xa vimos nas unidades anteriores como obter un InputStream.

O método setInput espera recibir o InputStream como primeiro parámetro e o xogo de caracteres como segundo. Pode producir unha excepción 'XmlPullParserException' polo que a engadimos as excepcións que pode producir a execución do método (throws ou try).

  • Paso 2: Agora necesitamos avanzar polo 'árbol' xml. Neste punto podemos utilizar os seguintes métodos:
  • Chamando ó método next(). Cada vez que chamamos a dito método avanzamos de elemento e ó mesmo tempo 'producimos' eventos como son: principio de documento, fin de documento, apertura de etiquete, pecha de etiqueta,....


Aviso: Poderíamos ler todo o documento utilizando este método, pero hai que ter coidado xa que o documento xml non debería ter saltos de liña (como está no exemplo) xa que eses caracteres tamén son lidos.


Para saber o evento que se produce facemos o seguinte:
       int evento = parser.next();
Se queremos percorrer todo a árbore ata chegar ó fin do documento:
  1.        int evento = parser.next();
  2.        while(evento != XmlPullParser.END_DOCUMENT) {
  3.                
  4.                 evento = parser.next();
  5.        }
  • Chamando ó método nextTag(): Neste caso chama a next() e devolve un evento se estamos situados nun START_TAG ou END_TAG. En caso contrario devolve unha excepción.
  • Chamando ó método nextText(): Se estamos situados nun START_TAG, ó chamar a dito método devolve a cadea (o texto) que se atopa entre o START_TAG e o END_TAG.
  • Paso 3: Neste intre, dependendo da flexibilidade que queiramos ter á hora de ler o arquivo, faremos o programa máis ou menos complexo.
A idea e ir lendo pola árbore e analizando cando chegamos a un principio de etiqueta (por exemplo <nome>) Nese intre temos que avanzar na árbore e obter o texto (Angel).
A variable 'evento' pode valer (entre outros valores):
  • XmlPullParser.START_TAG; Comezo de etiqueta.
  • XmlPullParser.END_TAG: Fin de etiqueta.
  • XmlPullParser.TEXT: Texto
  • XmlPullParser.END_DOCUMENT: Fin de documento.
No caso que nos ocupa, se queremos ler esta parte do documento xml:
  1.     <contacto>
  2.             <nome>Angel</nome>
  3.             <dir>C/ de Ala nº 12</dir>
  4.             <tel tipo="fixo">981111111</tel>
  5.             <tel tipo="mobil">691111111</tel>
  6.     </contacto>
Unha posible forma de facelo sería:
  1.                         if (parser.getName().equals("contacto")) {      // Un novo contacto
  2.                                 evento = parser.nextTag();      // Pasamos a <nome>
  3.                                 Log.i("XML","NOME:" + parser.nextText());
  4.                                 evento = parser.nextTag();      // Pasamos a <dir>
  5.                                 Log.i("XML","DIR:" + parser.nextText());
  6.                                 evento = parser.nextTag();      // Pasamos a <tel>
  7.                                 Log.i("XML","Tel fixo:" + parser.nextText());
  8.                                 evento = parser.nextTag();      // Pasamos a <tel>
  9.                                 Log.i("XML","Tel móbil:" + parser.nextText());
  10.                                
  11.                         }


Fixarse como estamos a ler un único contacto. Si isto o poñemos dentro do while indicado anteriormente, no que lemos o documento ata que remate, leríamos todos dando como resultado:
  1. 12-11 18:54:59.481: I/XML(14112): NOME:Angel
  2. 12-11 18:54:59.481: I/XML(14112): DIR:C/ de Ala nº 12
  3. 12-11 18:54:59.481: I/XML(14112): Tel fixo:981111111
  4. 12-11 18:54:59.481: I/XML(14112): Tel mobil:691111111
  5. 12-11 18:54:59.481: I/XML(14112): NOME:Luis
  6. 12-11 18:54:59.481: I/XML(14112): DIR:C/ de Acola nº 55
  7. 12-11 18:54:59.491: I/XML(14112): Tel fixo:982222222
  8. 12-11 18:54:59.491: I/XML(14112): Tel mobil:692222222


Aquí entra en xogo o comentado anteriormente da flexibilidade. Esta forma de ler o documento funciona sempre que enviemos os datos de nome, dir, tel1, tel2, pero, que pasa se un ven sen teléfono móbil ? Ó analizar o arquivo xml daría un erro ou traeríamos datos erróneos.
Polo tanto teremos que ter en conta as posibilidades que poda traer o arquivo xml para realizar unha análise máis completa e complexa.


Se queremos obter os atributos dentro dunha etiqueta teremos que facer uso do métodos:
  • getAtributeCount: Devolve o número de atributos
  • getAtributeName(int cont): Accede ó nome do atributo indicado por count.
  • getAtributeValue(int cont): Obtemos o valor do atributo indicando por count.
No exemplo anterior, temos un atributo 'tipo' na liña do teléfono:
            <tel tipo="fixo">981111111</tel>
            <tel tipo="mobil">691111111</tel>
Unha forma de obter o valor deses atributos:


  1.                 if(evento == XmlPullParser.START_TAG) {
  2.                         if (parser.getName().equals("contacto")) {      // Un novo contacto
  3.                                 evento = parser.nextTag();      // Pasamos a <nome>
  4.                                 Log.i("XML","NOME:" + parser.nextText());
  5.                                 evento = parser.nextTag();      // Pasamos a <dir>
  6.                                 Log.i("XML","DIR:" + parser.nextText());
  7.                                 evento = parser.nextTag();      // Pasamos a <tel>
  8.                                 // Estamos no tag <tel>=> obtemos o nome e valor do atributo tipo
  9.                                 Log.i("XML","Tel:" + parser.getAttributeName(0) + "-->" + parser.getAttributeValue(0)+":"+parser.nextText());
  10.                                 evento = parser.nextTag();      // Pasamos a <tel móbil>
  11.                                 Log.i("XML","Tel:" + parser.getAttributeName(0) + "-->" + parser.getAttributeValue(0)+":"+parser.nextText());
  12.                                
  13.                         }


Dando como resultado:
  1. 12-11 18:57:26.641: I/XML(14198): NOME:Angel
  2. 12-11 18:57:26.641: I/XML(14198): DIR:C/ de Ala nº 12
  3. 12-11 18:57:26.641: I/XML(14198): Tel:tipo-->fixo:981111111
  4. 12-11 18:57:26.641: I/XML(14198): Tel:tipo-->mobil:691111111
  5. 12-11 18:57:26.641: I/XML(14198): NOME:Luis
  6. 12-11 18:57:26.641: I/XML(14198): DIR:C/ de Acola nº 55
  7. 12-11 18:57:26.641: I/XML(14198): Tel:tipo-->fixo:982222222
  8. 12-11 18:57:26.641: I/XML(14198): Tel:tipo-->mobil:692222222


Caso práctico

O obxectivo desta práctica é ver un exemplo de procesamento dun arquivo XML.

O arquivo terá de contido unha lista de contactos como vimos ó principio desta unidade. O que fará o activity será ler ese contido, pasar os datos lidos a obxectos dunha clase Contactos e amosará o contido do array de Contactos creados nun TextView.

PDM Avanzada XML 1.jpg

Por que introducimos o modelo de clases neste apartado ?

Lembrar que isto xa o usamos na unidade de bases de datos.

Normalmente os datos lidos dende un arquivo XML os imos querer gardar nunha base de datos. Como xa vimos como facelo utilizando clases que modelizan os datos, por iso o facemos así.


Preparación

  • Media:Ud4_01_arquivo.xml: Gardade este arquivo (todo o nome con letras minúsculas) no cartafol /assets/ do voso proxecto Android.

Creamos a activity

  • Nome do proxecto: UD8_01_XML
  • Nome da activity: UD8_01_XML.java


Código do layout xml

  1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  2.    xmlns:tools="http://schemas.android.com/tools"
  3.    android:layout_width="match_parent"
  4.    android:layout_height="match_parent"
  5.    android:paddingBottom="@dimen/activity_vertical_margin"
  6.    android:paddingLeft="@dimen/activity_horizontal_margin"
  7.    android:paddingRight="@dimen/activity_horizontal_margin"
  8.    android:paddingTop="@dimen/activity_vertical_margin"
  9.    tools:context=".UD8_01_XML" >
  10.  
  11.     <TextView
  12.        android:id="@+id/UD8_01_txtDatos"
  13.        android:layout_width="match_parent"
  14.        android:layout_height="wrap_content"
  15.        android:layout_centerHorizontal="true"
  16.        android:layout_centerVertical="true"
  17.        />
  18.  
  19. </RelativeLayout>


Código da clase UD8_01_XML
Obxectivo: Ler un arquivo XML e procesalo.

  1. import java.io.IOException;
  2. import java.io.InputStream;
  3. import java.util.ArrayList;
  4.  
  5. import org.xmlpull.v1.XmlPullParser;
  6. import org.xmlpull.v1.XmlPullParserException;
  7.  
  8. import android.app.Activity;
  9. import android.os.Bundle;
  10. import android.util.Xml;
  11. import android.widget.TextView;
  12. import android.widget.Toast;
  13.  
  14. public class UD8_01_XML extends Activity {
  15.        
  16.         private ArrayList<Contacto>contactos = new ArrayList<Contacto>();
  17.  
  18.        
  19.         private void lerArquivo() throws IOException, XmlPullParserException {
  20.        
  21.                 InputStream is = getAssets().open("ud8_01_arquivo.xml");
  22.                
  23.                 XmlPullParser parser = Xml.newPullParser();
  24.                 parser.setInput(is, "UTF-8");
  25.        
  26.                 int evento = parser.nextTag();
  27.                 Contacto contacto = null;
  28.        
  29.                 while(evento != XmlPullParser.END_DOCUMENT) {
  30.                   if(evento == XmlPullParser.START_TAG) {
  31.                         if (parser.getName().equals("contacto")) {      // Un novo contacto
  32.                                 contacto = new Contacto();
  33.                                 evento = parser.nextTag();      // Pasamos a <nome>
  34.                           contacto.setNome(parser.nextText());
  35.                                 evento = parser.nextTag();      // Pasamos a <dir>
  36.                           contacto.setDireccion(parser.nextText());
  37.                                 evento = parser.nextTag();      // Pasamos a <tel>
  38.                           contacto.setTelefono_fixo(parser.nextText());
  39.                                 evento = parser.nextTag();      // Pasamos a <tel móbil>
  40.                           contacto.setTelefono_mobil(parser.nextText());
  41.                         }
  42.                    }
  43.                    if(evento == XmlPullParser.END_TAG) {
  44.                         if (parser.getName().equals("contacto")) {      // Un novo contacto
  45.                                 contactos.add(contacto);
  46.                         }
  47.                    }
  48.                                
  49.                    evento = parser.next();
  50.                  }
  51.                
  52.                  is.close();
  53.         }
  54.        
  55.         @Override
  56.         protected void onCreate(Bundle savedInstanceState) {
  57.                 super.onCreate(savedInstanceState);
  58.                 setContentView(R.layout.activity_ud8_01__xml);
  59.                
  60.                 try {
  61.                         lerArquivo();
  62.                         TextView caixa = (TextView)findViewById(R.id.UD8_01_txtDatos);
  63.                         for (Contacto contacto : contactos){
  64.                                
  65.                                 caixa.append("\nNOVO CONTACTO:");
  66.                                 caixa.append(contacto.getNome()+"\n");
  67.                                 caixa.append(contacto.getDireccion()+"\n");
  68.                                 caixa.append("FIXO:" + contacto.getTelefono_fixo()+"\n");
  69.                                 caixa.append("MOBIL:" + contacto.getTelefono_mobil()+"\n");
  70.                         }
  71.                 } catch (IOException e) {
  72.                          // TODO Auto-generated catch block
  73.                         e.printStackTrace();
  74.                         Toast.makeText(this, "ERRO:"+ e.getMessage(), Toast.LENGTH_LONG).show();
  75.                 } catch (XmlPullParserException e) {
  76.                         // TODO Auto-generated catch block
  77.                         e.printStackTrace();
  78.                         Toast.makeText(this, "ERRO:"+ e.getMessage(), Toast.LENGTH_LONG).show();
  79.                 }
  80.         }
  81.  
  82.  
  83. }
  • Liña 16: Definimos o array que vai gardar os contactos do arquivo XML.
  • Liñas 19-54: Método que vai ler o arquivo XML e gardara no array anterior a lista de contactos.
  • Liña 32: Comprobamos se o inicio de etiqueta é <contacto>. Nese intre se crea un novo obxecto Contacto para engadir ó array.
  • Liñas 33-40: Lemos o contido do xml e imos enchendo o obxecto da clase Contacto creado previamente.
  • Liñas 44-45: Se atopamos o fin de etiqueta </contacto> engadimos o novo contacto ó array.
  • Liña 61: Chamamos ó método que le o arquivo.
  • Liñas 63-70: Percorremos o array de contactos e imos engadindo ó TextView os datos.


  • Creamos a clase que vai modelizar os Contactos:

Código da clase Contacto

  1. public class Contacto {
  2.         private String nome;
  3.         private String direccion;
  4.         private String telefono_fixo;
  5.         private String telefono_mobil;
  6.        
  7.         public Contacto(String nome, String direccion, String tel_fixo, String tel_mobil){
  8.                 this.nome=nome;
  9.                 this.direccion=direccion;
  10.                 this.telefono_fixo=tel_fixo;
  11.                 this.telefono_mobil=tel_mobil;
  12.         }
  13.        
  14.         public Contacto(){
  15.                
  16.         }
  17.  
  18.         public String getNome() {
  19.                 return nome;
  20.         }
  21.  
  22.         public void setNome(String nome) {
  23.                 this.nome = nome;
  24.         }
  25.  
  26.         public String getDireccion() {
  27.                 return direccion;
  28.         }
  29.  
  30.         public void setDireccion(String direccion) {
  31.                 this.direccion = direccion;
  32.         }
  33.  
  34.         public String getTelefono_fixo() {
  35.                 return telefono_fixo;
  36.         }
  37.  
  38.         public void setTelefono_fixo(String telefono_fixo) {
  39.                 this.telefono_fixo = telefono_fixo;
  40.         }
  41.  
  42.         public String getTelefono_mobil() {
  43.                 return telefono_mobil;
  44.         }
  45.  
  46.         public void setTelefono_mobil(String telefono_mobil) {
  47.                 this.telefono_mobil = telefono_mobil;
  48.         }
  49.        
  50.        
  51. }




-- Ángel D. Fernández González e Carlos Carrión Álvarez -- (2014).