Discussion :

[jojo_ol76]

Bonjour,

Comment cela se fait -il qu'il n'arrive pas à parser ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
	byte[] bytes = EntityUtils.toByteArray(resEntity);
	InputStream input = new ByteArrayInputStream(bytes);
         SAXParser parseur=new SAXParser();
         parseur.parse(input, handler);

Aucun champs retournés

[MrDuChnok]

Vu l'erreur, je pense que ça vient de la ligne 12

Si tu veux vraiment qu'on te file un coup de main, il faut que tu nous donnes un peu plus de code :
- un extrait de ton fichier XML
- un peu plus de 4 ligne pour initialiser ton parser
- un bout de code de ton handler
- une erreur (logcat) si il y en a une.

Merci

[jojo_ol76]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
 
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
 
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.cookie.BasicClientCookie;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.apache.james.mime4j.util.CharsetUtil;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
import android.content.Context;
import android.os.Environment;
import android.provider.OpenableColumns;
import android.util.Log;
 
public class ContainerData {
	static public Context context;
 
	public ContainerData() {
	}
 
	public static ArrayList getFeeds(String link, String methode,String choice,
			NameValuePair... params) {
		// On passe par une classe factory pour obtenir une instance de sax
		SAXParserFactory fabrique = SAXParserFactory.newInstance();
		SAXParser parseur = null;
		ArrayList entries = null;
		try {
			// On "fabrique" une instance de SAXParser
			parseur = fabrique.newSAXParser();
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		}
		// On défini l'url du fichier XML
		URL url = null;
		try {
			url = new URL(link);
		} catch (MalformedURLException e1) {
			e1.printStackTrace();
		}
		/*
		 * Le handler sera gestionnaire du fichier XML c'est Ã* dire que c'est
		 * lui qui sera chargé des opérations de parsing. On vera cette classe
		 * en détails ci après.
		 */
		DefaultHandler handler = new ParserXMLHandler(choice);
		DefaultHttpClient client = new DefaultHttpClient();
		//HttpClient client=new DefaultHttpClient();
 
 
		try {
 
			HttpRequestBase req = null;
			List<NameValuePair> parameters = Arrays.asList(params);
			if (methode.equals("POST")) {
				HttpPost post = new HttpPost(link);
				Log.d("HttpRequest.doInBackground", "POST url " + link);
				/*
				 * UrlEncodedFormEntity ent = new
				 * UrlEncodedFormEntity(parameters, HTTP.UTF_8);
				 */
 
				MultipartEntity ent = new MultipartEntity();
				for (NameValuePair nameValuePair : params) {
 
					ent.addPart(nameValuePair.getName(), new StringBody(
							nameValuePair.getValue()));
 
				}
				post.setEntity(ent);
				req = post;
			}
			// On parse le fichier XML
 
			HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
			urlConnection.setDoOutput(true);
 
 
			HttpResponse httpResponse = client.execute(req);
			// InputStream input=httpResponse.getEntity().getContent();
			HttpEntity resEntity = httpResponse.getEntity();
			if (resEntity == null) {
				Log.v("COntainerData", "httpEntity is null");
			}
 
 
			//Log.d("ContainerData", EntityUtils.toString(resEntity));
//			URL urlAdParams=req.getURI().toURL();
//			InputStream io=url.openStream();
			// InputStream input=resEntity.getContent();
			//InputStream input=EntityUtils.toString(resEntity);
			//byte[] bytes = EntityUtils.toByteArray(resEntity);
			byte[] bytes = EntityUtils.toString(resEntity).getBytes();
			Log.d("ContainerData", "AAA");
			InputStream input = new ByteArrayInputStream(bytes);
			Reader reader = new InputStreamReader(input,"UTF-8");
			InputSource is = new InputSource(reader);
  	      	is.setEncoding("UTF-8");
 
			// /String response = EntityUtils.toString(resEntity);
 
			parseur.parse(is, handler);
			// On récupère directement la liste des feeds
			entries = ((ParserXMLHandler) handler).getData();
 
			input.close();
 
 
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (FactoryConfigurationError e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// On la retourne l'array list
		return entries;
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
 
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 {
	// nom des tags XML
	private final String ITEM = "rates";
	private final String DESTINATION = "destination";
	private final String ID = "id";
	private final String NAME = "name";
 
	// Array list de feeds
	private ArrayList entries;
	// Boolean permettant de savoir si nous sommes Ã* l'intérieur d'un item
	private boolean inItem;
	private String choice;
	private boolean inEnclosure;
	// Feed courant
	private ElementRss currentFeed;
 
	// Buffer permettant de contenir les données d'un tag XML
	private StringBuffer buffer;
 
	@Override
	public void processingInstruction(String target, String data)
			throws SAXException {
		super.processingInstruction(target, data);
	}
 
	public ParserXMLHandler(String choice) {
		super();
		this.choice = choice;
	}
 
	// * Cette méthode est appelée par le parser une et une seule
	// * fois au démarrage de l'analyse de votre flux xml.
	// * Elle est appelée avant toutes les autres méthodes de l'interface,
	// * Ã* l'exception unique, évidemment, de la méthode setDocumentLocator.
	// * Cet événement devrait vous permettre d'initialiser tout ce qui doit
	// * l'être avant ledébut du parcours du document.
	@Override
	public void startDocument() throws SAXException {
		super.startDocument();
		entries = new ArrayList();
	}
 
	/*
	 * Fonction étant déclenchée lorsque le parser trouve un tag XML C'est
	 * cette méthode que nous allons utiliser pour instancier un nouveau feed
	 */
	@Override
	public void startElement(String uri, String localName, String name,
			Attributes attributes) throws SAXException {
		// Nous réinitialisons le buffer a chaque fois qu'il rencontre un item
		buffer = new StringBuffer();
		// Ci dessous, localName contient le nom du tag rencontré
		// Nous avons rencontré un tag ITEM, il faut donc instancier un nouveau
		// feed
		if (choice.equals("Rate")) {
			if (localName.equalsIgnoreCase(ITEM)) {
				this.currentFeed = new ElementRss();
				inItem = true;
			}
 
		} else if (choice.equals("Destination")) {
			if (localName.equalsIgnoreCase(DESTINATION)) {
				this.currentFeed = new ElementRss();
				inItem = true;
			}
		}
		// Vous pouvez définir des actions Ã* effectuer pour chaque item
		// rencontré
		if (localName.equalsIgnoreCase(ID)) {
			// Nothing to do
		}
		if (localName.equalsIgnoreCase(NAME)) {
			// Nothing to do
		}
 
	}
 
	// * Fonction étant déclenchée lorsque le parser Ã* parsé
	// * l'intérieur de la balise XML La méthode characters
	// * a donc fait son ouvrage et tous les caractère inclus
	// * dans la balise en cours sont copiés dans le buffer
	// * On peut donc tranquillement les récupérer pour compléter
	// * notre objet currentFeed
	@Override
	public void endElement(String uri, String localName, String name)
			throws SAXException {
		if (localName.equalsIgnoreCase(ID)) {
			if (inItem) {
				// Les caractères sont dans l'objet buffer
				this.currentFeed.setId(buffer.toString());
				buffer = null;
			}
		}
		if (localName.equalsIgnoreCase(NAME)) {
			if (inItem) {
				this.currentFeed.setName(buffer.toString());
				buffer = null;
			}
		}
 
		if (choice.equals("Rate")) {
			if (localName.equalsIgnoreCase(ITEM)) {
				entries.add(currentFeed);
				inItem = false;
			}
		} else if (choice.equals("Destination")) {
			if (localName.equalsIgnoreCase(DESTINATION)) {
				entries.add(currentFeed);
				inItem = false;
			}
 
		}
 
	}
 
	// * Tout ce qui est dans l'arborescence mais n'est pas partie
	// * intégrante d'un tag, déclenche la levée de cet événement.
	// * En général, cet événement est donc levé tout simplement
	// * par la présence de texte entre la balise d'ouverture et
	// * la balise de fermeture
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		String lecture = new String(ch, start, length);
		if (buffer != null) {
			buffer.append(lecture);
			//Log.v("ParserXML", lecture);
		}
	}
 
	// cette méthode nous permettra de récupérer les données
	public ArrayList getData() {
		return entries;
	}
}

[MrDuChnok]

Et au débugage ça donne quoi ?
Ton parseur fonctionne bien ?
Ton fichier est bien récupéré ?
Tu as une exception ?

[jojo_ol76]

Le problème venait du fichier xml qui ne comportait pas une balise racine (root)