Erreur pour lire fichier XML

Version imprimable

Bonjour à tous,
ça fait bientôt deux jours que je n'arrive pas à lire un fichier XML, le logcat m'indique toujours que je ne soulève pas une exception et donc qu'il ne peut pas continuer.
J'aimerais comprendre pourquoi...

Voilà ma première classe héritant de DefaultHandler:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package com.example.toolbook;
 
import java.util.ArrayList;
 
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
 
public class ParserXMLHandler extends DefaultHandler {
 
	private final String MOT_FRANCAIS = "motFrancais";
	private final String MOT_ANGLAIS = "motAnglais";
	private final String DEF_FRANCAIS = "definitionFrancais";
	private final String DEF_ANGLAIS = "definitionAnglais";
	private final String TEST1 = "test1";
	private final String TEST2 = "test2";
	private final String TEST3 = "test3";
	private final String TEST4 = "test4";
	private final String TEST5 = "test5";
 
	private ArrayList<String> entries;
 
	private Entry currentFeed;
 
	private StringBuffer buffer;
 
	public void processingInstruction(String target, String data)
	{
		try {
			super.processingInstruction(target, data);
		} catch (SAXException e) {
			e.printStackTrace();
		}
	}
 
	public ParserXMLHandler(){super();}
 
	public void startDocument() throws SAXException
	{
		super.startDocument();
		entries = new ArrayList<String>();
	}
 
	public void startElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(TEST1))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST2))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST3))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST4))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST5))
			this.currentFeed.setTest(buffer.toString());
	}
 
	public void endElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(MOT_FRANCAIS))
		{
				this.currentFeed.setMotFrancais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(MOT_ANGLAIS))
		{
				this.currentFeed.setMotAnglais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_FRANCAIS))
		{
				this.currentFeed.setDefFrancais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_ANGLAIS))
		{
				this.currentFeed.setDefAnglais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(TEST1))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST2))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST3))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST4))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST5))
			this.currentFeed.setTest(buffer.toString());
	}
 
	public void characters(char[] ch, int start, int length)
	{
		String lecture = new String(ch, start, length);
		if(buffer != null) buffer.append(lecture);
	}
 
	public ArrayList<String> getData()
	{
		return entries;
	}
}

Voilà maintenant ma classe qui me permet de récupérer les données :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package com.example.toolbook;
 
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
 
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
 
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
 
import android.content.Context;
import android.content.res.AssetManager;
 
public class ContainerData {
 
static public Context context;
 
	public ContainerData(){}
 
	public static ArrayList<String> getFeeds()
	{
		SAXParserFactory fabrique = SAXParserFactory.newInstance();
		SAXParser parseur = null;
		ArrayList<String> entries = null;
		try
		{
			parseur = fabrique.newSAXParser();
		}
		catch(ParserConfigurationException e){e.printStackTrace();}
		catch(SAXException e){e.printStackTrace();}
 
		AssetManager asset = context.getAssets();
 
		InputStream inputStream = null;
		try {
			inputStream = asset.open("dico.xml");
		} catch (IOException e2) {
			e2.printStackTrace();
		}
 
		InputSource input = null;
		input = new InputSource(inputStream);
 
		DefaultHandler handler = new ParserXMLHandler();
		try {
			parseur.parse(input, handler);
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		entries = ((ParserXMLHandler) handler).getData();
 
		return entries;
	}
}

et enfin le logcat :

http://www.casimages.com/img.php?i=1...0016290664.png

Si vous pouviez m'aider, ce serait vraiment très gentil ! :)

17/01/2013, 12h07
onda47

log

Le log cat ressemble à ça pardon

http://nsa30.casimages.com/img/2013/...0016290664.png

Bien,

NullpointerException ton erreur indiquée, probablement due à une de ces construction:
Code:

1 2 3 4 5 6 7 8 SAXParser parseur = null; ArrayList<String> entries = null; try { parseur = fabrique.newSAXParser(); } catch(ParserConfigurationException e){e.printStackTrace();} catch(SAXException e){e.printStackTrace();}
Tu tente d'initialiser un parser (et plus bas un inputstream), mais en cas d'exception.... tu continue quand même, alors que tu as un null maintenant dans parseur. Ce n'est pas possible de continuer. Il faut

1) récupérer le message de cette exception (envoie la dans le logcat plutot que de faire un e.printStackTrace())
2) arrêter immédiatement le travail ou alors avoir une solution de secours. Mais pas continuer comme si de rien n'était :)

corrigé

j'ai corrigé mon code en mettant un signe distinctif sur les erreurs pouvant être soulevé.
Il suffit bien de mettre un System.out.println pour afficher les soulèvement d'exception dans le LogCat ? Je ne vois pas l'erreur, peut-être faut-il implémenter le endDocument dans ma classe ParserXMLHandler ? Je ne comprends vraiment pas.
Voilà ma nouvelle classe ContainerData, suivit de ParserXMLHandler et enfin du LogCat.
ContainerData.java :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
public class ContainerData {
 
	public ContainerData(){}
 
	public static ArrayList<Entry> getFeeds(Context context) throws SAXException
	{
		SAXParserFactory fabrique = SAXParserFactory.newInstance();
		SAXParser parseur;
		DefaultHandler handler = new ParserXMLHandler();
 
		InputStream inputStream;
		InputSource input = new InputSource();;
 
		AssetManager asset = context.getAssets();
		ArrayList<Entry> entries = new ArrayList<Entry>();
 
		try
		{
			parseur = fabrique.newSAXParser();
			inputStream = asset.open("dico.xml");
			input = new InputSource(inputStream);
			parseur.parse(input, handler);
			entries = ((ParserXMLHandler) handler).getData();
		}
		catch(ParserConfigurationException e){System.out.println("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + e);}
		catch(SAXException e){System.out.println("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" + e);}
		catch (IOException e) {System.out.println("CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" + e);}
 
		return entries;
	}
}

ParserXMLHandler :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
public class ParserXMLHandler extends DefaultHandler {
 
	private final String MOT_FRANCAIS = "motFrancais";
	private final String MOT_ANGLAIS = "motAnglais";
	private final String DEF_FRANCAIS = "definitionFrancais";
	private final String DEF_ANGLAIS = "definitionAnglais";
	private final String TEST1 = "test1";
	private final String TEST2 = "test2";
	private final String TEST3 = "test3";
	private final String TEST4 = "test4";
	private final String TEST5 = "test5";
 
	private ArrayList<Entry> entries;
 
	private Entry currentFeed;
 
	private StringBuffer buffer;
 
	public void processingInstruction(String target, String data)
	{
		try {
			super.processingInstruction(target, data);
		} catch (SAXException e) {
			e.printStackTrace();
		}
	}
 
	public ParserXMLHandler(){super();}
 
	public void startDocument() throws SAXException
	{
		super.startDocument();
		entries = new ArrayList<Entry>();
		currentFeed = new Entry();
	}
 
	public void startElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(TEST1))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST2))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST3))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST4))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST5))
			this.currentFeed.setTest(buffer.toString());
	}
 
	public void endElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(MOT_ANGLAIS))
		{
				this.currentFeed.setMotAnglais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(MOT_FRANCAIS))
		{
				this.currentFeed.setMotFrancais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_ANGLAIS))
		{
				this.currentFeed.setDefAnglais(buffer.toString());
				entries.add(currentFeed);
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_FRANCAIS))
		{
				this.currentFeed.setDefFrancais(buffer.toString());
				buffer = null;
		}
	}
 
	public void characters(char[] ch, int start, int length)
	{
		String lecture = new String(ch, start, length);
		if(buffer != null) buffer.append(lecture);
	}
 
	public ArrayList<Entry> getData()
	{
		return entries;
	}
}

LogCat :
http://nsa30.casimages.com/img/2013/...4635684618.png

17/01/2013, 21h05
tchize_

Citation:

Envoyé par onda47

j'ai corrigé mon code en mettant un signe distinctif sur les erreurs pouvant être soulevé.
Il suffit bien de mettre un System.out.println pour afficher les soulèvement d'exception dans le LogCat ?

Mmmm non, je ne pense pas

http://developer.android.com/tools/d...gging-log.html

remerciement

oh je te remercie beaucoup pour cette très précieuse information !
c'est vraiment génial (je suis débutant dans la programmation android)

j'ai trouvé ce qui ne va pas :
maintenant je comprends que c'est le fichier xml qui ne va pas ou bien le ma classe ParserXMLHandler.
Après avoir regardé et reregardé mon fichier xml je pense que c'est ma classe.
Je poste les deux à la suite. Peut-être pouvez-vous m'aider ? Je ne comprends pas.

Classe ParserXMLHandler :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
public class ParserXMLHandler extends DefaultHandler {
 
	private final String MOT_FRANCAIS = "motFrancais";
	private final String MOT_ANGLAIS = "motAnglais";
	private final String DEF_FRANCAIS = "definitionFrancais";
	private final String DEF_ANGLAIS = "definitionAnglais";
	private final String TEST1 = "test1";
	private final String TEST2 = "test2";
	private final String TEST3 = "test3";
	private final String TEST4 = "test4";
	private final String TEST5 = "test5";
 
	private static final String TAG = "ParserXMLHandler";
 
	private ArrayList<Entry> entries;
 
	private Entry currentFeed;
 
	private StringBuffer buffer;
 
	public void processingInstruction(String target, String data)
	{
		try 
		{
			super.processingInstruction(target, data);
		} 
		catch (SAXException e) {Log.e(TAG, "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" + e.getMessage());}
	}
 
	public ParserXMLHandler(){super();}
 
	public void startDocument()
	{
		try {
			super.startDocument();
		} catch (SAXException e) {
			Log.e(TAG, "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" + e.getMessage());
		}
		entries = new ArrayList<Entry>();
		currentFeed = new Entry();
	}
 
	public void startElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(TEST1))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST2))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST3))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST4))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST5))
			this.currentFeed.setTest(buffer.toString());
	}
 
	public void endElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(MOT_ANGLAIS))
		{
				this.currentFeed.setMotAnglais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(MOT_FRANCAIS))
		{
				this.currentFeed.setMotFrancais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_ANGLAIS))
		{
				this.currentFeed.setDefAnglais(buffer.toString());
				entries.add(currentFeed);
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_FRANCAIS))
		{
				this.currentFeed.setDefFrancais(buffer.toString());
				buffer = null;
		}
	}
 
	public void characters(char[] ch, int start, int length)
	{
		String lecture = new String(ch, start, length);
		if(buffer != null) buffer.append(lecture);
	}
 
	public ArrayList<Entry> getData()
	{
		return entries;
	}
}

Fichier Dico.xml :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
<?xml version='1.0' encoding="UTF-8" ?>
 
<test1>
	<motAnglais>Abort</motAnglais>
	<motFrancais>Interrompre</motFrancais>
	<definitionAnglais>To stop the running of a computer program, usually when things go wrong. The computer returns to the operating system after aborting the program, prints a message to warn the operator and waits for a new command.</definitionAnglais>
	<definitionFrancais>Arrêter l'exécution d'un programme informatique, le plus souvent lorsque surgit un problème. L'ordinateur renvoie au système d'exploitation, après avoir interrompu le programme, affiche un message pour alerter l'utilisateur et attend de sa part d'autres commandes.</definitionFrancais>
 
	<motAnglais>Access time</motAnglais>
	<motFrancais>Temps d'accès</motFrancais>
	<definitionAnglais>The time taken by the computer to fetch data from an address within the computer or other storage device. It is also the time between being told to fetch and having the data ready.</definitionAnglais>
	<definitionFrancais>Temps pris par l'ordinateur pour aller chercher des données à partir d'une adresse de l'ordinateur ou de tout autre dispositif de stockage. Il s'agit également du temps écoulé entre le moment où l'on a dit à l'ordinateur d'aller chercher les données et celui où les données sont prêtes.</definitionFrancais>
 
	<motAnglais>Accumulator</motAnglais>
	<motFrancais>Accumulateur</motFrancais>
	<definitionAnglais>A special location used to hold the result of calculations during processing.</definitionAnglais>
	<definitionFrancais>Emplacement particulier utilisé pour conserver le résultat de calculs pendant le traitement des données.</definitionFrancais>
</test1>
 
 
<test2>
	<motAnglais>Acronym</motAnglais>
	<motFrancais>Acronyme</motFrancais>
	<definitionAnglais>A word formed from the initial letters of a group of words or a phrase. The world of computing uses many acronyms, for example: ASCII. </definitionAnglais>
	<definitionFrancais>Un mot formé à partir des initiales d'un groupe de mots ou d'une expression. Le milieu de l'informatique utilise fréquemment des acronymes, par exemple ASCII.</definitionFrancais>
 
	<motAnglais>Adder</motAnglais>
	<motFrancais>Additionneur</motFrancais>
	<definitionAnglais>A device which performs addition on digital signals giving both the sum and the carry digit. A half-adder has two inputs whereas a full-adder has three inputs, each input being a 0 or 1.</definitionAnglais>
	<definitionFrancais>Dispositif qui fait des additions de signaux digitaux en donnant à la fois la somme et la retenue. Un demi-additionneur a deux entrées alors qu'un additionneur complet en a trois, chaque entrée correspondant à 0 ou à 1.</definitionFrancais>
 
	<motAnglais>Address</motAnglais>
	<motFrancais>Adresse</motFrancais>
	<definitionAnglais>The reference number given to each location in a computer's memory that stores data. Whenever a computer is asked to find a piece of data it has stored, it uses the address.</definitionAnglais>
	<definitionFrancais>Le numéro de référence donné à chaque emplacement dans la mémoire de l'ordinateur qui emmagasine les données. Chaque fois que l'ordinateur est appelé à trouver une donnée qui était emmagasinée, il utilise l'adresse.</definitionFrancais>
</test2>
 
 
<test3>
	<motAnglais>Address modification</motAnglais>
	<motFrancais>Modification d'adresse</motFrancais>
	<definitionAnglais>The process by which the address part of a program instruction is changed, say to one higher (i.e. the next address) each time the instruction is performed.</definitionAnglais>
	<definitionFrancais>Procédé par lequel la partie adresse d'une instruction de programme est modifiée, disons en une adresse supérieure (c'est-à-dire l'adresse suivante) chaque fois que l'instruction est exécutée.</definitionFrancais>
 
	<motAnglais>ADSL</motAnglais>
	<motFrancais>ADSL</motFrancais>
	<definitionAnglais>Provides a connection through telephone copper wires, which receives data between 2 and 8 Mbps, though is slower in the other direction.</definitionAnglais>
	<definitionFrancais>Fournit une connexion grâce aux fils de cuivre du téléphone et reçoit des données entre 2 et 8 Mbps bien que plus lent dans l'autre direction.</definitionFrancais>
</test3>
 
 
 
<test4>
	<motAnglais>ALGOL</motAnglais>
	<motFrancais>ALGOL</motFrancais>
	<definitionAnglais>ALGorithmic Oriented Language. A high-level programming language developed in Europe at the same time as FORTRAN was being developed in the United States.</definitionAnglais>
	<definitionFrancais>Langage orienté algorithmique. Langage de programmation de haut niveau développé en Europe en même temps que FORTRAN fut développé aux USA.</definitionFrancais>
</test4>
 
 
 
<test5>
	<motAnglais>Algorithm</motAnglais>
	<motFrancais>Algorithme</motFrancais>
	<definitionAnglais>A planned set of instructions or steps designed to solve a particular problem. There is only one starting point and all routes through the algorithm end at the same finishing point. Such steps can be carried out by a computer, or dry run on paper, using different inputs or values.</definitionAnglais>
	<definitionFrancais>Série d'instructions ou d'étapes organisées, conçues  pour résoudre un problème particulier. Il n'y a qu'un point de départ et tous les cheminements à travers l'algorithme aboutissent au même point d'arrivée. De telles étapes peuvent être exécutées par un ordinateur ou suivies sur papier, en utilisant différentes entrées ou valeurs.</definitionFrancais>
</test5>

17/01/2013, 22h54
onda47

fichier xml

Tiens, le code couleur semble buggé sur le forum... est-ce que c'est un problème de regex du forum ou mon fichier ? (sur eclipse il n'y a pas ce bug de couleur)

tout les fichiers

Voilà dans l'ordre, mon activité que j'ai appellé update, puis la classe ContainerData, la classe ParserXMLHandler, la classe Entry et le fichier xml et enfin le logcat.

Update :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Update extends Activity {
 
	private static final String TAG = "Update";
 
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
 
		Log.i(TAG, "TextView textView = new TextView(this);");
		TextView textView = new TextView(this);
 
		Log.i(TAG, "textView.setText(ContainerData.getFeeds(this).get(0).getDefFrancais());");
		textView.setText(ContainerData.getFeeds(this).get(0).getDefFrancais());
 
		Log.i(TAG, "setContentView(textView);");
		setContentView(textView);
	}
 
	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		// Inflate the menu; this adds items to the action bar if it is present.
		getMenuInflater().inflate(R.menu.activity_dico_francais_anglais, menu);
		return true;
	}
}

ContainerData :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class ContainerData {
 
	public ContainerData(){}
 
	private static final String TAG = "ContainerData";
 
	public static ArrayList<Entry> getFeeds(Context context)
	{
		SAXParserFactory fabrique = SAXParserFactory.newInstance();
		SAXParser parseur = null;
		DefaultHandler handler = null;
 
		InputStream inputStream = null;
		InputSource input = null;
 
		AssetManager asset = context.getAssets();
		ArrayList<Entry> entries = new ArrayList<Entry>();
 
		handler = new ParserXMLHandler();
		try
		{
			Log.i(TAG, "PARSEUR = FABRIQUE.NEWSAXPARSER");
			parseur = fabrique.newSAXParser();
 
			Log.i(TAG, "INPUTSTREAM = ASSET.OPEN()");
			inputStream = asset.open("dico.xml");
			if(inputStream == null)
				Log.i(TAG, "INPUT STREAM CA BUG !!!!!!!!!!!");
			else
			{
				Log.i(TAG, "INPUT = NEW INPUTSOURCE(INPUTSTREAM)");
				input = new InputSource(inputStream);
				// Log.i(TAG, "PARSEUR.PARSE(INPUT, HANDLER");
				//parseur.parse(input,  handler);
				Log.i(TAG, "XMLReader xmlr = parseur.getXMLReader();");
				XMLReader xmlr = parseur.getXMLReader();
				Log.i(TAG, "xmlr.setContentHandler(handler);");
				xmlr.setContentHandler(handler);
				Log.i(TAG, "xmlr.parse(input);");
				xmlr.parse(input);
			}
			Log.i(TAG, "FIN DU TRY");
		}
		catch(ParserConfigurationException e){Log.e(TAG, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + e);}
		catch(SAXException e){Log.e(TAG, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" + e);}
		catch (IOException e) {Log.e(TAG, "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" + e);}
 
		Log.i(TAG, "AVANT LE GETDATA");
		entries = ((ParserXMLHandler) handler).getData();
		Log.i(TAG, "APRES LE GETDATA");
 
		return entries;
	}
}

ParserXMLHandler :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
public class ParserXMLHandler extends DefaultHandler {
 
	private final String MOT_FRANCAIS = "motFrancais";
	private final String MOT_ANGLAIS = "motAnglais";
	private final String DEF_FRANCAIS = "definitionFrancais";
	private final String DEF_ANGLAIS = "definitionAnglais";
	private final String TEST1 = "test1";
	private final String TEST2 = "test2";
	private final String TEST3 = "test3";
	private final String TEST4 = "test4";
	private final String TEST5 = "test5";
 
	private static final String TAG = "ParserXMLHandler";
 
	private ArrayList<Entry> entries;
 
	private Entry currentFeed;
 
	private StringBuffer buffer;
 
	public void processingInstruction(String target, String data)
	{
		try 
		{
			super.processingInstruction(target, data);
		} 
		catch (SAXException e) {Log.e(TAG, "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" + e.getMessage());}
	}
 
	public ParserXMLHandler(){super();}
 
	public void startDocument()
	{
		try {
			super.startDocument();
		} catch (SAXException e) {
			Log.e(TAG, "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" + e.getMessage());
		}
		entries = new ArrayList<Entry>();
		currentFeed = new Entry();
	}
 
	public void startElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(TEST1))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST2))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST3))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST4))
			this.currentFeed.setTest(buffer.toString());
 
		if(localName.equalsIgnoreCase(TEST5))
			this.currentFeed.setTest(buffer.toString());
	}
 
	public void endElement(String uri, String localName, String name)
	{
		if(localName.equalsIgnoreCase(MOT_ANGLAIS))
		{
				this.currentFeed.setMotAnglais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(MOT_FRANCAIS))
		{
				this.currentFeed.setMotFrancais(buffer.toString());
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_ANGLAIS))
		{
				this.currentFeed.setDefAnglais(buffer.toString());
				entries.add(currentFeed);
				buffer = null;
		}
 
		if(localName.equalsIgnoreCase(DEF_FRANCAIS))
		{
				this.currentFeed.setDefFrancais(buffer.toString());
				buffer = null;
		}
	}
 
	public void characters(char[] ch, int start, int length)
	{
		String lecture = new String(ch, start, length);
		if(buffer != null) buffer.append(lecture);
	}
 
	public ArrayList<Entry> getData()
	{
		return entries;
	}
}

Entry :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
public class Entry {
 
	private String motFrancais;
	private String motAnglais;
	private String defFrancais;
	private String defAnglais;
	private String test;
 
	public Entry(String motFrancais, String motAnglais, String defFrancais, String defAnglais, String test)
	{
		super();
		this.motAnglais = motAnglais;
		this.motFrancais = motFrancais;
		this.defFrancais = defFrancais;
		this.defAnglais = defAnglais;
		this.test = test;
	}
 
	public Entry(){}
 
	public String getMotFrancais()
	{
		return this.motFrancais;
	}
 
	public void setMotFrancais(String motFrancais)
	{
		this.motFrancais = motFrancais;
	}
 
	public String getMotAnglais()
	{
		return this.motAnglais;
	}
 
	public void setMotAnglais(String motAnglais)
	{
		this.motAnglais = motAnglais;
	}
 
	public String getDefFrancais()
	{
		return this.defFrancais;
	}
 
	public void setDefFrancais(String defFrancais)
	{
		this.defFrancais = defFrancais;
	}
 
	public String getDefAnglais()
	{
		return this.defAnglais;
	}
 
	public void setDefAnglais(String defAnglais)
	{
		this.defAnglais = defAnglais;
	}
 
	public String getTest()
	{
		return this.test;
	}
 
	public void setTest(String test)
	{
		this.test = test;
	}
 
	public String toString()
	{
		return (" motFrancais : " + this.motFrancais + 
				" motAnglais " + this.motAnglais + 
				" defFrancais " + this.defFrancais + 
				" defAnglais " + this.defAnglais + 
				" test : " + this.test);
	}
}

Dico.xml :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
<?xml version='1.0' encoding="UTF-8" ?>
 
<test1>
	<motAnglais>Abort</motAnglais>
	<motFrancais>Interrompre</motFrancais>
	<definitionAnglais>To stop the running of a computer program, usually when things go wrong. The computer returns to the operating system after aborting the program, prints a message to warn the operator and waits for a new command.</definitionAnglais>
	<definitionFrancais>Arrêter l'exécution d'un programme informatique, le plus souvent lorsque surgit un problème. L'ordinateur renvoie au système d'exploitation, après avoir interrompu le programme, affiche un message pour alerter l'utilisateur et attend de sa part d'autres commandes.</definitionFrancais>
 
	<motAnglais>Access time</motAnglais>
	<motFrancais>Temps d'accès</motFrancais>
	<definitionAnglais>The time taken by the computer to fetch data from an address within the computer or other storage device. It is also the time between being told to fetch and having the data ready.</definitionAnglais>
	<definitionFrancais>Temps pris par l'ordinateur pour aller chercher des données à partir d'une adresse de l'ordinateur ou de tout autre dispositif de stockage. Il s'agit également du temps écoulé entre le moment où l'on a dit à l'ordinateur d'aller chercher les données et celui où les données sont prêtes.</definitionFrancais>
 
	<motAnglais>Accumulator</motAnglais>
	<motFrancais>Accumulateur</motFrancais>
	<definitionAnglais>A special location used to hold the result of calculations during processing.</definitionAnglais>
	<definitionFrancais>Emplacement particulier utilisé pour conserver le résultat de calculs pendant le traitement des données.</definitionFrancais>
</test1>
 
 
<test2>
	<motAnglais>Acronym</motAnglais>
	<motFrancais>Acronyme</motFrancais>
	<definitionAnglais>A word formed from the initial letters of a group of words or a phrase. The world of computing uses many acronyms, for example: ASCII. </definitionAnglais>
	<definitionFrancais>Un mot formé à partir des initiales d'un groupe de mots ou d'une expression. Le milieu de l'informatique utilise fréquemment des acronymes, par exemple ASCII.</definitionFrancais>
 
	<motAnglais>Adder</motAnglais>
	<motFrancais>Additionneur</motFrancais>
	<definitionAnglais>A device which performs addition on digital signals giving both the sum and the carry digit. A half-adder has two inputs whereas a full-adder has three inputs, each input being a 0 or 1.</definitionAnglais>
	<definitionFrancais>Dispositif qui fait des additions de signaux digitaux en donnant à la fois la somme et la retenue. Un demi-additionneur a deux entrées alors qu'un additionneur complet en a trois, chaque entrée correspondant à 0 ou à 1.</definitionFrancais>
 
	<motAnglais>Address</motAnglais>
	<motFrancais>Adresse</motFrancais>
	<definitionAnglais>The reference number given to each location in a computer's memory that stores data. Whenever a computer is asked to find a piece of data it has stored, it uses the address.</definitionAnglais>
	<definitionFrancais>Le numéro de référence donné à chaque emplacement dans la mémoire de l'ordinateur qui emmagasine les données. Chaque fois que l'ordinateur est appelé à trouver une donnée qui était emmagasinée, il utilise l'adresse.</definitionFrancais>
</test2>
 
 
<test3>
	<motAnglais>Address modification</motAnglais>
	<motFrancais>Modification d'adresse</motFrancais>
	<definitionAnglais>The process by which the address part of a program instruction is changed, say to one higher (i.e. the next address) each time the instruction is performed.</definitionAnglais>
	<definitionFrancais>Procédé par lequel la partie adresse d'une instruction de programme est modifiée, disons en une adresse supérieure (c'est-à-dire l'adresse suivante) chaque fois que l'instruction est exécutée.</definitionFrancais>
 
	<motAnglais>ADSL</motAnglais>
	<motFrancais>ADSL</motFrancais>
	<definitionAnglais>Provides a connection through telephone copper wires, which receives data between 2 and 8 Mbps, though is slower in the other direction.</definitionAnglais>
	<definitionFrancais>Fournit une connexion grâce aux fils de cuivre du téléphone et reçoit des données entre 2 et 8 Mbps bien que plus lent dans l'autre direction.</definitionFrancais>
</test3>
 
 
 
<test4>
	<motAnglais>ALGOL</motAnglais>
	<motFrancais>ALGOL</motFrancais>
	<definitionAnglais>ALGorithmic Oriented Language. A high-level programming language developed in Europe at the same time as FORTRAN was being developed in the United States.</definitionAnglais>
	<definitionFrancais>Langage orienté algorithmique. Langage de programmation de haut niveau développé en Europe en même temps que FORTRAN fut développé aux USA.</definitionFrancais>
</test4>
 
 
 
<test5>
	<motAnglais>Algorithm</motAnglais>
	<motFrancais>Algorithme</motFrancais>
	<definitionAnglais>A planned set of instructions or steps designed to solve a particular problem. There is only one starting point and all routes through the algorithm end at the same finishing point. Such steps can be carried out by a computer, or dry run on paper, using different inputs or values.</definitionAnglais>
	<definitionFrancais>Série d'instructions ou d'étapes organisées, conçues  pour résoudre un problème particulier. Il n'y a qu'un point de départ et tous les cheminements à travers l'algorithme aboutissent au même point d'arrivée. De telles étapes peuvent être exécutées par un ordinateur ou suivies sur papier, en utilisant différentes entrées ou valeurs.</definitionFrancais>
</test5>

LogCat :

01-17 23:23:50.088: I/ContainerData(30025): PARSEUR = FABRIQUE.NEWSAXPARSER
01-17 23:23:50.098: I/ContainerData(30025): INPUTSTREAM = ASSET.OPEN()
01-17 23:23:50.098: I/ContainerData(30025): INPUT = NEW INPUTSOURCE(INPUTSTREAM)
01-17 23:23:50.098: I/ContainerData(30025): XMLReader xmlr = parseur.getXMLReader();
01-17 23:23:50.098: I/ContainerData(30025): xmlr.setContentHandler(handler);
01-17 23:23:50.098: I/ContainerData(30025): xmlr.parse(input);
01-17 23:23:50.128: D/AndroidRuntime(30025): Shutting down VM
01-17 23:23:50.128: W/dalvikvm(30025): threadid=3: thread exiting with uncaught exception (group=0x40026160)
01-17 23:23:50.128: E/AndroidRuntime(30025): Uncaught handler: thread main exiting due to uncaught exception
01-17 23:23:50.358: E/AndroidRuntime(30025): java.lang.RuntimeException: Unable to start activity ComponentInfo{com.example.toolbook/com.example.toolbook.Update}: java.lang.NullPointerException
01-17 23:23:50.358: E/AndroidRuntime(30025): at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2503)
01-17 23:23:50.358: E/AndroidRuntime(30025): at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2519)
01-17 23:23:50.358: E/AndroidRuntime(30025): at android.app.ActivityThread.access$2200(ActivityThread.java:123)
01-17 23:23:50.358: E/AndroidRuntime(30025): at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1870)
01-17 23:23:50.358: E/AndroidRuntime(30025): at android.os.Handler.dispatchMessage(Handler.java:99)
01-17 23:23:50.358: E/AndroidRuntime(30025): at android.os.Looper.loop(Looper.java:123)
01-17 23:23:50.358: E/AndroidRuntime(30025): at android.app.ActivityThread.main(ActivityThread.java:4370)
01-17 23:23:50.358: E/AndroidRuntime(30025): at java.lang.reflect.Method.invokeNative(Native Method)
01-17 23:23:50.358: E/AndroidRuntime(30025): at java.lang.reflect.Method.invoke(Method.java:521)
01-17 23:23:50.358: E/AndroidRuntime(30025): at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:868)
01-17 23:23:50.358: E/AndroidRuntime(30025): at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:626)
01-17 23:23:50.358: E/AndroidRuntime(30025): at dalvik.system.NativeStart.main(Native Method)
01-17 23:23:50.358: E/AndroidRuntime(30025): Caused by: java.lang.NullPointerException
01-17 23:23:50.358: E/AndroidRuntime(30025): at readXML.ParserXMLHandler.endElement(ParserXMLHandler.java:75)
01-17 23:23:50.358: E/AndroidRuntime(30025): at org.apache.harmony.xml.ExpatParser.endElement(ExpatParser.java:159)
01-17 23:23:50.358: E/AndroidRuntime(30025): at org.apache.harmony.xml.ExpatParser.append(Native Method)
01-17 23:23:50.358: E/AndroidRuntime(30025): at org.apache.harmony.xml.ExpatParser.parseFragment(ExpatParser.java:506)
01-17 23:23:50.358: E/AndroidRuntime(30025): at org.apache.harmony.xml.ExpatParser.parseDocument(ExpatParser.java:467)
01-17 23:23:50.358: E/AndroidRuntime(30025): at org.apache.harmony.xml.ExpatReader.parse(ExpatReader.java:329)
01-17 23:23:50.358: E/AndroidRuntime(30025): at org.apache.harmony.xml.ExpatReader.parse(ExpatReader.java:286)
01-17 23:23:50.358: E/AndroidRuntime(30025): at readXML.ContainerData.getFeeds(ContainerData.java:59)
01-17 23:23:50.358: E/AndroidRuntime(30025): at com.example.toolbook.Update.onCreate(Update.java:22)
01-17 23:23:50.358: E/AndroidRuntime(30025): at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1047)
01-17 23:23:50.358: E/AndroidRuntime(30025): at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2466)
01-17 23:23:50.358: E/AndroidRuntime(30025): ... 11 more
01-17 23:23:50.398: E/SemcCheckin(30025): Get crash dump level : java.io.FileNotFoundException: /data/semc-checkin/crashdump
01-17 23:23:50.418: I/dalvikvm(30025): threadid=7: reacting to signal 3
01-17 23:23:50.428: I/dalvikvm(30025): Wrote stack trace to '/data/anr/traces.txt'

Bon... j'ai corrigé ton probleme de coloration syntaxique... la balise code fait de la coloration de code générique il faut rajouter =xml pour avoir une coloration "xml" (et donc ne plus prendre en compte les ' dans le texte).

Déjà, le XML n'est pas valide... Un fichier XML doit être un seul et unique élément (qui peut en contenir plusieurs), ici il y a test1, test2, ....

Ensuite dans le parsing... régulièrement tu met "buffer à null", sans tester par la suite si il est null ou pas... je pense que tu veux faire buffer.setLength(0); à la place (et du coup le test de nullité dans "characters" n'a plus lieu d'être).

Enfin, la syntaxe de Log n'est pas bonne pour une exception....
Log.e(TAG, texte + ex); va juste afficher le nom de l'exception... il faut la stack-trace pour être efficace:

Log.e(TAG,text,ex); marchera donc mieux...
D'ailleurs le but étant de récupérer toutes les exceptions (à priori) au lieu de faire:
Code:

1 2 3 4 5 } catch(ParserConfigurationException e){Log.e(TAG, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + e);} catch(SAXException e){Log.e(TAG, "BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB" + e);} catch (IOException e) {Log.e(TAG, "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC" + e);}
autant faire:
Code:

1 2 3 4 } catch(Exception e){ Log.e(TAG, "Failed to parse XML",e); }

GRAND MERCI

Je te remercie énormément.
Il a fallut que je change mon fichier xml comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
<?xml version='1.0' encoding="UTF-8" ?>
 
<dictionnaire>
    <test1>
        <entry>
            <motAnglais>Abort</motAnglais>
			<motFrancais>Interrompre</motFrancais>
			<definitionAnglais>To stop the running of a computer program, usually when things go wrong. The computer returns to the operating system after aborting the program, prints a message to warn the operator and waits for a new command.</definitionAnglais>
			<definitionFrancais>Arrêter l'exécution d'un programme informatique, le plus souvent lorsque surgit un problème. L'ordinateur renvoie au système d'exploitation, après avoir interrompu le programme, affiche un message pour alerter l'utilisateur et attend de sa part d'autres commandes.</definitionFrancais>
        </entry>
		<entry>
			<motAnglais>Access time</motAnglais>
			<motFrancais>Temps d'accès</motFrancais>
			<definitionAnglais>The time taken by the computer to fetch data from an address within the computer or other storage device. It is also the time between being told to fetch and having the data ready.</definitionAnglais>
			<definitionFrancais>Temps pris par l'ordinateur pour aller chercher des données à partir d'une adresse de l'ordinateur ou de tout autre dispositif de stockage. Il s'agit également du temps écoulé entre le moment où l'on a dit à l'ordinateur d'aller chercher les données et celui où les données sont prêtes.</definitionFrancais>
		</entry>
		<entry>
			<motAnglais>Accumulator</motAnglais>
			<motFrancais>Accumulateur</motFrancais>
			<definitionAnglais>A special location used to hold the result of calculations during processing.</definitionAnglais>
			<definitionFrancais>Emplacement particulier utilisé pour conserver le résultat de calculs pendant le traitement des données.</definitionFrancais>
		</entry>
	</test1>
 
 
	<test2>
	    <entry>
			<motAnglais>Acronym</motAnglais>
			<motFrancais>Acronyme</motFrancais>
			<definitionAnglais>A word formed from the initial letters of a group of words or a phrase. The world of computing uses many acronyms, for example: ASCII. </definitionAnglais>
			<definitionFrancais>Un mot formé à partir des initiales d'un groupe de mots ou d'une expression. Le milieu de l'informatique utilise fréquemment des acronymes, par exemple ASCII.</definitionFrancais>
		</entry>
		<entry>
			<motAnglais>Adder</motAnglais>
			<motFrancais>Additionneur</motFrancais>
			<definitionAnglais>A device which performs addition on digital signals giving both the sum and the carry digit. A half-adder has two inputs whereas a full-adder has three inputs, each input being a 0 or 1.</definitionAnglais>
			<definitionFrancais>Dispositif qui fait des additions de signaux digitaux en donnant à la fois la somme et la retenue. Un demi-additionneur a deux entrées alors qu'un additionneur complet en a trois, chaque entrée correspondant à 0 ou à 1.</definitionFrancais>
		</entry>
		<entry>
			<motAnglais>Address</motAnglais>
			<motFrancais>Adresse</motFrancais>
			<definitionAnglais>The reference number given to each location in a computer's memory that stores data. Whenever a computer is asked to find a piece of data it has stored, it uses the address.</definitionAnglais>
			<definitionFrancais>Le numéro de référence donné à chaque emplacement dans la mémoire de l'ordinateur qui emmagasine les données. Chaque fois que l'ordinateur est appelé à trouver une donnée qui était emmagasinée, il utilise l'adresse.</definitionFrancais>
		</entry>
	</test2>
 
 
	<test3>
	    <entry>
			<motAnglais>Address modification</motAnglais>
			<motFrancais>Modification d'adresse</motFrancais>
			<definitionAnglais>The process by which the address part of a program instruction is changed, say to one higher (i.e. the next address) each time the instruction is performed.</definitionAnglais>
			<definitionFrancais>Procédé par lequel la partie adresse d'une instruction de programme est modifiée, disons en une adresse supérieure (c'est-à-dire l'adresse suivante) chaque fois que l'instruction est exécutée.</definitionFrancais>
		</entry>
		<entry>
			<motAnglais>ADSL</motAnglais>
			<motFrancais>ADSL</motFrancais>
			<definitionAnglais>Provides a connection through telephone copper wires, which receives data between 2 and 8 Mbps, though is slower in the other direction.</definitionAnglais>
			<definitionFrancais>Fournit une connexion grâce aux fils de cuivre du téléphone et reçoit des données entre 2 et 8 Mbps bien que plus lent dans l'autre direction.</definitionFrancais>
		</entry>
	</test3>
 
	<test4>
	    <entry>
			<motAnglais>ALGOL</motAnglais>
			<motFrancais>ALGOL</motFrancais>
			<definitionAnglais>ALGorithmic Oriented Language. A high-level programming language developed in Europe at the same time as FORTRAN was being developed in the United States.</definitionAnglais>
			<definitionFrancais>Langage orienté algorithmique. Langage de programmation de haut niveau développé en Europe en même temps que FORTRAN fut développé aux USA.</definitionFrancais>
		</entry>
	</test4>
 
 
 
	<test5>
	    <entry>
			<motAnglais>Algorithm</motAnglais>
			<motFrancais>Algorithme</motFrancais>
			<definitionAnglais>A planned set of instructions or steps designed to solve a particular problem. There is only one starting point and all routes through the algorithm end at the same finishing point. Such steps can be carried out by a computer, or dry run on paper, using different inputs or values.</definitionAnglais>
			<definitionFrancais>Série d'instructions ou d'étapes organisées, conçues  pour résoudre un problème particulier. Il n'y a qu'un point de départ et tous les cheminements à travers l'algorithme aboutissent au même point d'arrivée. De telles étapes peuvent être exécutées par un ordinateur ou suivies sur papier, en utilisant différentes entrées ou valeurs.</definitionFrancais>
		</entry>
	</test5>
</dictionnaire>

Ensuite que je change beaucoup ma classe parserXMLHandler comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
package readXML;
 
import java.util.ArrayList;
 
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
 
import android.util.Log;
 
 
public class ParserXMLHandler extends DefaultHandler {
 
	private final String MOT_FRANCAIS = "motFrancais";
	private final String MOT_ANGLAIS = "motAnglais";
	private final String DEF_FRANCAIS = "definitionFrancais";
	private final String DEF_ANGLAIS = "definitionAnglais";
	private final String TEST1 = "test1";
	private final String TEST2 = "test2";
	private final String TEST3 = "test3";
	private final String TEST4 = "test4";
	private final String TEST5 = "test5";
	private final String ENTRY = "entry";
 
	private boolean inEntry;
	private boolean inTest1;
	private boolean inTest2;
	private boolean inTest3;
	private boolean inTest4;
	private boolean inTest5;
 
	private static final String TAG = "ParserXMLHandler";
 
	private ArrayList<Entry> entries;
	private Entry currentFeed;
	private StringBuffer buffer;
 
	public ParserXMLHandler(){
		super();
		Log.i(TAG, "super();");
		this.inTest1 = false;
		this.inTest2 = false;
		this.inTest3 = false;
		this.inTest4 = false;
		this.inTest5 = false;
		this.inEntry = false;
	}
 
	@Override
	public void processingInstruction(String target, String data) throws SAXException
	{
		try 
		{
			Log.i(TAG, "super.processingInstruction(target, data);");
			super.processingInstruction(target, data);
		} 
		catch (SAXException e) {Log.e(TAG, "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE" + e.getMessage());}
	}
 
	@Override
	public void startDocument() throws SAXException
	{
		try 
		{
			Log.i(TAG, "super.startDocument();");
			super.startDocument();
		} catch (SAXException e) {Log.e(TAG, "DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD" + e.getMessage());}
 
		Log.i(TAG, "this.entries = new ArrayList<Entry>();");
		this.entries = new ArrayList<Entry>();
	}
	@Override
	public void startElement(String uri, String localName, String name, Attributes atts) throws SAXException
	{
		Log.i(TAG, "STARTELEMENT");
 
		buffer = new StringBuffer();
 
		if(localName.equalsIgnoreCase(TEST1))
		{
			Log.i(TAG, "TEST1");
			this.inTest1 = true;
		}
 
		if(localName.equalsIgnoreCase(TEST2))
		{
			Log.i(TAG, "TEST2");
			this.inTest1 = false;
			this.inTest2 = true;
		}
 
		if(localName.equalsIgnoreCase(TEST3))
		{
			Log.i(TAG, "TEST3");
			this.inTest2 = false;
			this.inTest3 = true;
		}
 
		if(localName.equalsIgnoreCase(TEST4))
		{
			Log.i(TAG, "TEST4");
			this.inTest3 = false;
			this.inTest4 = true;
		}
 
		if(localName.equalsIgnoreCase(TEST5))
		{
			Log.i(TAG, "TEST5");
			this.inTest4 = false;
			this.inTest5 = true;
		}
 
		if(localName.equalsIgnoreCase(ENTRY))
		{
			Log.i(TAG, "ENTRYYYYYYYYY");
			this.inEntry = true;
			this.currentFeed = new Entry();
			if(this.inTest1)
				this.currentFeed.setTest("test1");
			if(this.inTest2)
				this.currentFeed.setTest("test2");
			if(this.inTest3)
				this.currentFeed.setTest("test3");
			if(this.inTest4)
				this.currentFeed.setTest("test4");
			if(this.inTest5)
				this.currentFeed.setTest("test5");
		}
	}
 
	@Override
	public void endElement(String uri, String localName, String name) throws SAXException
	{
		Log.i(TAG, "ENDELEMENT");
 
		if(localName.equalsIgnoreCase(MOT_ANGLAIS))
		{
			if(this.inEntry)
			{
				Log.i(TAG, "SET MOT ANGLAIS  : " + buffer.toString());
				this.currentFeed.setMotAnglais(buffer.toString());
				this.buffer = null;
			}
		}
 
		if(localName.equalsIgnoreCase(MOT_FRANCAIS))
		{
			if(this.inEntry)
			{
				Log.i(TAG, "SET MOT FRANCAIS : " + buffer.toString());
				this.currentFeed.setMotFrancais(buffer.toString());
				this.buffer = null;
			}
		}
 
		if(localName.equalsIgnoreCase(DEF_ANGLAIS))
		{
			if(this.inEntry)
			{
				Log.i(TAG,  "SET DEF ANGLAIS  : " + buffer.toString());
				this.currentFeed.setDefAnglais(buffer.toString());
				this.buffer = null;
			}
		}
 
		if(localName.equalsIgnoreCase(DEF_FRANCAIS))
		{
			if(this.inEntry)
			{
				Log.i(TAG,  "SET DEF FRANCAIS  : " + buffer.toString());
				this.currentFeed.setDefFrancais(buffer.toString());
				this.buffer = null;
			}
 
		}
 
		if(localName.equalsIgnoreCase(ENTRY))
		{
			this.entries.add(currentFeed);
			this.inEntry = false;
		}
	}
 
	@Override
	public void characters(char[] ch, int start, int length) throws SAXException
	{
		String lecture = new String(ch, start, length);
		if(buffer != null)
		{	
			Log.i(TAG, "buffer PAAAS null !!!!!!" + lecture);
			this.buffer.append(lecture);
		}
		else
		{
			Log.i(TAG, "buffer null !!!!!!");
		}
	}
 
	public ArrayList<Entry> getData()
	{
		Log.i(TAG, "getData()");
		return this.entries;
	}
}

Ma classe ContainerData et Entry n'a pas changé.
Pour ceux que ça intéresse je m'étais inspiré à la base de ce tutoriel :
http://thibault-koprowski.fr/2010/10...-sous-android/

Je te remercie à encore pour ces précieuses informations... :ccool:

(par contre je n'ai pas réussi à insérer le =xml dans la balise code... il me faudrait un exemple)

18/01/2013, 16h49
tchize_

Citation:

Envoyé par onda47

(par contre je n'ai pas réussi à insérer le =xml dans la balise code... il me faudrait un exemple)

http://club.developpez.com/aidenouve...es/Balises.gif

Je voudrai juste rajouter un commentaire pour le XML...

Je te conseille, pour le XML, de toujours écrire un DTD en parallèle qui va valider le bon format du XML.

Ainsi, on aurait ici:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 <!DOCTYPE dictionnaire [ <!ELEMENT dictionnaire (test1, test2, test3, test4, test5) > <!ELEMENT test1 (entry+) > <!ELEMENT test2 (entry+) > <!ELEMENT test3 (entry+) > <!ELEMENT test4 (entry+) > <!ELEMENT test5 (entry+) > <!ELEMENT entry (motAnglais, motFrancais, definitionAnglais, definitionFrancais) > <!ELEMENT motAnglais (#PCDATA)> <!ELEMENT motFrancais (#PCDATA)> <!ELEMENT definitionAnglais (#PCDATA)> <!ELEMENT definitionFrancais(#PCDATA)> ]>
Hors, il est notoire que plus un DTD est complexe, plus il est difficile à parser le XML...

Donc je pense que partir sur un DTD "plus" simple serait plus approprié genre:
Code:

1 2 3 4 5 6 7 8 9 10 <!DOCTYPE dictionnaire [ <!ELEMENT dictionnaire (test+) > <!ELEMENT test (entry+) > <!ELEMENT entry (motAnglais, motFrancais, definitionAnglais, definitionFrancais) > <!ELEMENT motAnglais (#PCDATA)> <!ELEMENT motFrancais (#PCDATA)> <!ELEMENT definitionAnglais (#PCDATA)> <!ELEMENT definitionFrancais(#PCDATA)> ]>
Disparition donc de test1/test2/test3 etc...

Du coup le decoding est plus simple....

18/01/2013, 17h22
onda47

XML

Merci pour ces informations mais je suis étudiant en informatique et je n'ai pas encore vu le XML en cours alors... je comprends pas trop. Mes classes marchent et je récupère bien ma liste d'Entry. Donc pour l'instant ça ira ^^
Mais merci quand même
18/01/2013, 18h04
tchize_

Citation:

Envoyé par nicroman

Je voudrai juste rajouter un commentaire pour le XML...

Je te conseille, pour le XML, de toujours écrire un DTD en parallèle qui va valider le bon format du XML.

un XSD étant encore mieux :)
18/01/2013, 18h44
nicroman

D'accord pour le XSD... mais je suis de la vieille école et autant je maîtrise l'un autant l'autre me fout les chocottes :aie:
Et puis de toute manière depuis que j'ai découvert AJAX et JSON, j'aime plus XML :mrgreen:
18/01/2013, 18h46
tchize_

le jour ou on aura des shémas de validation pour le json, j'aimerais peut être :D