Realizzare un Parser XML con ANDROID
Ciao,
vi riporto questo utilissimo tutorial ANDROID relativo al parsing XML con android. E' utilissimo anche nel caso in cui vogliate realizzare un vostro RSS reader personalizzato.
Fonte: http://www.anddev.it/index.php?topic=180.0
Salve a tutti,
vorrei mostrarvi come è possibile fare il parsing di un documento XML tramite il Document Object Model.
A differenza del parsing tramite SAX, che legge il documento e fa scattare degli eventi (metodi dell'handler) ad ogni tag incontrato, il parsing tramite DOM legge la struttura ad albero di un XML. A discrezione dell'utente (programmatore) la struttura letta potrà essere direttamente interrogata (nel codice si capisce meglio di cosa si tratta).
Per documenti XML relativamente semplici, questo tipo di parsing risulta sicuramente più immediato e semplice da implementare.
Tuttavia, per strutture con albero xml troppo profondo, questo metodo potrebbe risultare scomodo, e sarebbe quindi meglio optare per il sax parsing.
Vorrei osservare, che queste operazioni (DOM e SAX parsing) sono inerenti a Java più che ad android, ma visto che molte persone si avvicinano a questo fantastico linguaggio grazie ad android, ritengo giusto condividere questo tipo di informazioni su questa board.
Vediamo il documento che vogliamo analizzare:
<?xml version="1.0" encoding="utf-8"?>
<messages>
<note id="p501">
<to>Carlo</to>
<from>Luca</from>
<heading>Promemoria</heading>
<body>Ricordati gli appunti!</body>
</note>
<note id="p502">
<to>Luca</to>
<from>Carlo</from>
<heading>Re: Promemoria</heading>
<body>Ok, mi ricorderò!</body>
</note>
</messages>
Creiamo una classe che rappresenta una nota:
public class MyNote {
private String body;
private String heading;
private String from;
private String to;
private String id;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getTo() {
return to;
}
public void setTo(String to) {
this.to = to;
}
public String getHeading() {
return heading;
}
public void setHeading(String heading) {
this.heading = heading;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
@Override
public String toString() {
return "MyNote [id=" + id + ", from=" + from + ", to=" + to +", heading="
+ heading + ",body=" + body+ "]";
}
}
Creiamo una classe che gestisce il parsing: (potremmo utilizzare un metodo, ma in questo modo rendiamo più pulito e riutilizzabile il tutto)
Se eliminate i metodi di debug e le chiamate a questi metodi, vi accorgerete della semplicità di questo tipo di parsing(nel caso vi sembrasse troppo lungo 
).
public class MyParser {
static void vDebug(String debugString){ //metodi di convenienza
Log.v("DomParsing", debugString+"\n");
}
static void eDebug(String debugString){
Log.e("DomParsing", debugString+"\n");
}
ArrayList<MyNote> parsedData=new ArrayList<MyNote>(); //struttura dati che immagazzinerà i dati letti
public ArrayList<MyNote> getParsedData() { //metodo di accesso alla struttura dati
return parsedData;
}
public void parseXml(String xmlUrl){
Document doc;
try {
doc=DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new URL(xmlUrl).openStream());
//Costruiamo il nostro documento a partire dallo stream dati fornito dall'URL
Element root=doc.getDocumentElement();
//Elemento(nodo) radice del documento
vDebug("Root element :" + root.getNodeName());
vDebug("");
//NodeList notes=root.getElementsByTagName("note"); //potremmo direttamente prendere gli elementi note
NodeList notes=root.getChildNodes();
//ma prediamo tutti i "figli" diretti di root. Utile se non avessimo solo "note" come figli di root
for(int i=0;i<notes.getLength();i++){//per ogni
Node c= notes.item(i);//nodo
if(c.getNodeType()==Node.ELEMENT_NODE){//controlliamo se questo è un nodo elemento (un tag)
//se avessimo usato root.getElementsByTagName("note") questo controllo
//non sarebbe stato necessario
MyNote newNote=new MyNote(); //costruiamo un oggetto MyNote dove andremo a salvare i dati
Element note=(Element)c; //cast da nodo a Elemento
//non controlliamo if(note.getNodeName().equals("note")) in quanto sappiamo di avere solo "note" come childs
String id=note.getAttribute("id"); // lettura attributo
vDebug("_Attributo note id:"+id);
vDebug("");
newNote.setId(id); // settiamo l'id del nostro oggetto MyNote
NodeList noteDetails=c.getChildNodes(); //per ogni nota abbiamo i vari dettagli
for(int j=0;j<noteDetails.getLength();j++){
Node c1=noteDetails.item(j);
if(c1.getNodeType()==Node.ELEMENT_NODE){ //anche in questo caso controlliamo se si tratta di tag
Element detail=(Element)c1; //cast
String nodeName=detail.getNodeName(); //leggo il nome del tag
String nodeValue=detail.getFirstChild().getNodeValue();//leggo il testo in esso contenuto
vDebug("______Dettaglio:"+nodeName);
vDebug("______Contenuto Dettaglio:"+nodeValue);
vDebug("");
//a dipendenza del nome del nodo (del dettaglio) settiamo il relativo valore nell'oggetto
if(nodeName.equals("from"))
newNote.setFrom(nodeValue);
if(nodeName.equals("to"))
newNote.setTo(nodeValue);
if(nodeName.equals("heading"))
newNote.setHeading(nodeValue);
if(nodeName.equals("body"))
newNote.setBody(nodeValue);
}
}
vDebug("");
parsedData.add(newNote); //aggiungiamo il nostro oggetto all'arraylist
}
}
//gestione eccezioni
} catch (SAXException e) {
eDebug(e.toString());
} catch (IOException e) {
eDebug(e.toString());
} catch (ParserConfigurationException e) {
eDebug(e.toString());
} catch (FactoryConfigurationError e) {
eDebug(e.toString());
}
}
}
Aggiungiamo questa permission al manifest:
<uses-permission android:name="android.permission.INTERNET"></uses-permission>
Usiamo ciò che abbiamo creato:
public class DomParsing extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
String xmlUrl="http://www.xxxx.xx/myfiles/messages.xml";
MyParser parser=new MyParser(); //otteniamo un istanza del nostro parser
parser.parseXml(xmlUrl);//usiamo il parser
((TextView)findViewById(R.id.result)).setText(parser.getParsedData().toString());
//per semplicità stampiamo il toString (che richiamerà i toString di MyNote) dell'arraylist risultato dal parsing
}
}
Il problema con gli aggiornamenti Android è che questi vengono scaglionati nel tempo in modo così lento che spesso gli utenti diventano estremamente impazienti e passano settimane prima di poter aggiornare il proprio telefono.
