Umlautdarstellung unterschied in Android 2.3.x vs 4.0.x

Tja, ich hätte da gern mal wieder ein Problem.

Grundlage der Datenhaltung sind XML Dokumente kodiert als UTF-8.
Diese lese ich ein, packe sie via greenDAO in eigene persistente Objekte und stelle sie dann dar.

Lustig:

Android 4.0.3 sagt:

Zitat

5 am Tag sorgt für gesunden Spaß
Öffentliche Pflanzaktion von Rosen
Gartenwelt und Rosenträume

Android 2.3.5 sagt:

Zitat

5 am Tag sorgt f
Ö
Gartenwelt und Rosentr

Gibt es irgendwelche Unterschiede im Handling von XML bei den unterschiedlichen Versionen, so dass ich unter 2.3 ein anderes Ergebnis bekomme als unter 4.0?

Der XML Parser basiert komplett auf java.io, java.xml, org.xml.sax und org.w3c.dom, es ist also nichts dabei, dass ich als unsupporteten Drittherstellerkrams ansehen würde...

Für sachdienliche Hinweise bin ich dankbar.

Moin,

ich muss das noch mal ansprechen.

Das Problem scheint in dem Zusammenspiel der XML und den XMLParser Bibliotheken zu liegen.

Die Umlaute im XML sind websafe als UTF-8 kodiert, also ü = ü und so weiter.

Dieselbe Klasse mit dem javax.xml.parsers.DocumentBuilder liefert unter 2.3 allerdings nicht die Umlaute, die es unter 4.0 liefert.
Stattdessen bricht es einfach ab.

Wenn ich mir die Werte ausgeben lasse, fehlen die Umlaute bereits beim Abholen aus dem XML.
Betreffende Zeilen Code:

public final String getElementValue( import org.w3c.dom.Node elem ) {
	    import org.w3c.dom.Node child;
	    if( elem != null){
	        if (elem.hasChildNodes()){
	            for( child = elem.getFirstChild(); child != null; child = child.getNextSibling() ){
	                if( child.getNodeType() == import org.w3c.dom.Node.TEXT_NODE  ){
                             return child.getNodeValue();
	                }
	            }
	        }
	    }
	    return "";
	}

Der XML String "Frühling" bringt mir dann bei 4.0 das Ergebnis 'Frühling' und bei 2.3 das Ergebnis 'Fr'.
Angeblich sei die Methode getNodeValue() bereits seit API 1 eingepflegt, so dass es natürlich schwer ist festzustellen, was sich da in deren Implementierung geändert hat.

Hat jemand einen Tipp für mich, wie ich dieses Problem behoben bekomme?
(Da Inhalte aus der XML aus einer Webquelle stammen und die Darstellung der Zeichen unter 4.0 ja keinerlei Probleme verursacht, würde ich ungern das XML auf 'irgend ein anderes Symbol als die UTF-8 Darstellung' umbauen müssen.)

Danke für den Tipp Kogoro.

Ich fürchte nur, dass das eben dieser Bug ist.

Tausche ich im XML das 'Fr&#xFChling' gegen ein 'Frühling', dann passt es wieder.
Auch werden mir nicht die Uppercase Umlaute abgeschnitten, sondern das Sonderzeichen mitsamt Rest gar nicht erst angezeigt.
Außer, das Sonderzeichen ist an erster Stelle, dann wird nur der Rest nicht angezeigt.

Anbei zwei Screenshots mit Testdaten.
Die XML dazu sieht simpel und wie folgt aus:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<news>
	<de>
		<item>
			<newsID>1</newsID>
			<title>Frühling</title>
			<bodytext>Frühling läßt sein blaues Band wieder flattern durch die Lüfte

</bodytext>
		</item>
		<item>
			<newsID>2</newsID>
			<title>„Der Sandmann“</title>
			<bodytext>Ein Bestseller von E.T.A Hoffmann</bodytext>
		</item>
	</de>
</news>

Die Umlaute als solche sind sichtbar, wenn ich sie im Klartext im XML eintipper.
Aus Kompatibilitätsgründen mit einigen WebViews sind sie Umlaute in der XML halt UTF-8 HTML Encoded.
Das beschriebene Encoding ist UTF-8, das Dateiencoding ist UTF-8 und Android 4.0 stellt die HTML-Encoded UTF-8 Chars vernünftig dar, nur Android 2.3 nicht.

Fun fact: drehe ich den Spieß um und nehme statt UTF-8 kodierter HTML-Werte das normale HTML-Encoding (in diesem Fall beispielsweise ü), dann werden die derart formatierten Zeichen unter 2.3 einfach nur ausgelassen:

Zitat

Frhling
Der Sandmann

Im Übrigen ist das auch gar nicht mein XML.
Mein XML hat immer entweder eine Inline-DTD oder eine importierte DTD, woher soll der Parser sonst wissen, was er damit alles tun kann?

Ich werde also bei Zeiten mal mit dem Ersteller der XML verhandeln, ob man die Zeichen nicht einfach in Klartext in das Dokument bekommt.

Nichts desto trotz wundert mich, dass dieselbe Implementierung bei derselben Datei auf unterschiedlichen OS-Versionen so eine unterschiedliche Darstellung zur Folge hat. Was wird mir noch alles begegnen?

Hab noch ein bisschen weiter am XML gespielt und eine vernünftige DTD eingetragen sowie die UTF-8 als auch die HTML Entities verwendet.
Die spannenden Ergebnisse hängen an.

Das XML dazu sieht aus wie folgt:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<!DOCTYPE tt_news [
	<!ELEMENT tt_news(de?,en?)>
	<!ELEMENT de(newsID,title,bodytext)>
	<!ELEMENT en(newsID,title,bodytext)>
	<!ELEMENT newsID(#CDATA)>
	<!ELEMENT title(#PCDATA)>
	<!ELEMENT short(#PCDATA)>
]>
<tt_news>
	<de>
		<item>
			<newsID>1</newsID>
			<title>Frühling</title>
			<short>Frühling läßt sein blaues Band wieder flattern durch die Lüfte

</short>
		</item>
		<item>
			<newsID>2</newsID>
			<title>"Der Sandmann"</title>
			<short>Ein Bestseller von E.T.A Hoffmann</short>
		</item>
	</de>
</tt_news>

Also nicht großartig anders, nur dass ich den ursprünglichen Bodytext in eine Kurzbeschreibung umgebaut habe. Die Titel haben HTML-Entities, die Kurzbeschreibungen haben (wenn überhaupt) die UTF-8 codierten Entities.

Man beachte beim ersten Bild (2.3) dass da kaum was stimmt und beim zweiten Bild (4.0), dass zwar die Umlaute in den UTF-8 Encodings sowie die XML-eigenen Entities dargestellt werden, die Umlaute in HTML-Entities hingegen nicht.

An meiner Ursprungsfrage ändert das jedoch nichts:
warum kann 4.0 die UTF-8 kodierten Zeichen als String ausgeben, während 2.3 an der Stelle abbricht?

Da mir das Ganze nach einem gewaltigen Systembug in 2.3 und kleiner riecht, es aber noch immer zu weit verbreitet ist als dass man es wegfallen lassen könnte (was ich echt liebend gern täte... +seufz+): welche Stelle ist die Richtige, um ein erstelltes Testprojekt zur Darstellung dieses Bugs abzuliefern?

[killphil75]
Nein, den WebChromeClient habe ich nicht ausprobiert.
Ja, das Encoding steht explizit auf UTF-8.
Ja, ich nutze loadDataWithBaseURL(), weil ich mit loadData() nur Probleme hatte.

Danke für den Tipp mit dem WebChromeClient.

Nun, der Code bezüglich des Auslesens steht ja im zweiten Beitrag.
Dort habe ich mir einfach im Log child.getNodeValue() ausgeben lassen und festgestellt, dass dort die ü schon fehlten.

Dass die ü ein genereller Fehler sind, habe ich bereits festgestellt. Es ist ja quasi als Test drin, ob die Parser mit Fehlern gleich umgehen.

Ich bekomme keinerlei Log-Ausgaben bezüglich des XML-Parsens, die ich nicht selbst abgegeben habe, außer:

Zitat

11-30 15:06:50.693: VERBOSE/BaseXMLParser#parse(787): done parsing xml

Hast du den SAX oder den DOM Parser genutzt?
Bei mir wird wie gesagt einfach alles inklusive des ersten Umlauts abgeschnitten...

Der gesamte Parser sieht so aus:

package com.example.xml;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringReader;


import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;


import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;


import android.util.Log;


public class XMLParser {
	
	// Loading from Stream
	public String xmlFromStream(InputStream stream)
	{
		BufferedReader r = new BufferedReader(new InputStreamReader(stream));
		StringBuilder total = new StringBuilder();
		String line;
		try {
			while ((line = r.readLine()) != null) {
			    total.append(line);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return total.toString();
	}
	


	
	// Getting DOM
	public Document getDomElement(String xml){
        Document doc;
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        try {
 
            DocumentBuilder db = dbf.newDocumentBuilder();
 
            InputSource is = new InputSource();
                is.setCharacterStream(new StringReader(xml));
                doc = db.parse(is); 
 
            } catch (ParserConfigurationException e) {
                Log.e("ParserConfigurationException: ", e.getMessage());
                return null;
            } catch (SAXException e) {
                Log.e("SAXException: ", e.getMessage());
                return null;
            } catch (IOException e) {
                Log.e("IOException: ", e.getMessage());
                return null;
            }
                // return DOM
            return doc;
        }
	
	// Getting values
	public String getValue(Element item, String str) {
	    NodeList n = item.getElementsByTagName(str);
	    return this.getElementValue(n.item(0));
	}
	 
	public final String getElementValue( Node elem ) {
	    Node child;
	    if( elem != null){
	        if (elem.hasChildNodes()){
	            for( child = elem.getFirstChild(); child != null; child = child.getNextSibling() ){
	                if( child.getNodeType() == Node.TEXT_NODE  ){
                             // Gebe ich hier child.getNodeValue() zurück, habe ich bereits die abgeschnittenen Strings.
                             return child.getNodeValue();
	                }
	            }
	        }
	    }
	    return "";
	}
}

XmlPullParser? Feini, da schau ich mal drüber. Danke. =)

Wuuhuu, das funktioniert!

Danke für die Hilfe und die investierte Zeit.