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
|
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.util;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlSerializer;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.UnsupportedEncodingException;
import org.apache.harmony.xml.ExpatPullParser;
import org.apache.harmony.xml.ExpatReader;
/**
* XML utility methods.
*/
public class Xml {
/**
* {@link org.xmlpull.v1.XmlPullParser} "relaxed" feature name.
*
* @see <a href="http://xmlpull.org/v1/doc/features.html#relaxed">
* specification</a>
*/
public static String FEATURE_RELAXED = ExpatPullParser.FEATURE_RELAXED;
/**
* Parses the given xml string and fires events on the given SAX handler.
*/
public static void parse(String xml, ContentHandler contentHandler)
throws SAXException {
try {
XMLReader reader = new ExpatReader();
reader.setContentHandler(contentHandler);
reader.parse(new InputSource(new StringReader(xml)));
}
catch (IOException e) {
throw new AssertionError(e);
}
}
/**
* Parses xml from the given reader and fires events on the given SAX
* handler.
*/
public static void parse(Reader in, ContentHandler contentHandler)
throws IOException, SAXException {
XMLReader reader = new ExpatReader();
reader.setContentHandler(contentHandler);
reader.parse(new InputSource(in));
}
/**
* Parses xml from the given input stream and fires events on the given SAX
* handler.
*/
public static void parse(InputStream in, Encoding encoding,
ContentHandler contentHandler) throws IOException, SAXException {
try {
XMLReader reader = new ExpatReader();
reader.setContentHandler(contentHandler);
InputSource source = new InputSource(in);
source.setEncoding(encoding.expatName);
reader.parse(source);
} catch (IOException e) {
throw new AssertionError(e);
}
}
/**
* Creates a new pull parser with namespace support.
*
* <p><b>Note:</b> This is actually slower than the SAX parser, and it's not
* fully implemented. If you need a fast, mostly implemented pull parser,
* use this. If you need a complete implementation, use KXML.
*/
public static XmlPullParser newPullParser() {
ExpatPullParser parser = new ExpatPullParser();
parser.setNamespaceProcessingEnabled(true);
return parser;
}
/**
* Creates a new xml serializer.
*/
public static XmlSerializer newSerializer() {
try {
return XmlSerializerFactory.instance.newSerializer();
} catch (XmlPullParserException e) {
throw new AssertionError(e);
}
}
/** Factory for xml serializers. Initialized on demand. */
static class XmlSerializerFactory {
static final String TYPE
= "org.kxml2.io.KXmlParser,org.kxml2.io.KXmlSerializer";
static final XmlPullParserFactory instance;
static {
try {
instance = XmlPullParserFactory.newInstance(TYPE, null);
} catch (XmlPullParserException e) {
throw new AssertionError(e);
}
}
}
/**
* Supported character encodings.
*/
public enum Encoding {
US_ASCII("US-ASCII"),
UTF_8("UTF-8"),
UTF_16("UTF-16"),
ISO_8859_1("ISO-8859-1");
final String expatName;
Encoding(String expatName) {
this.expatName = expatName;
}
}
/**
* Finds an encoding by name. Returns UTF-8 if you pass {@code null}.
*/
public static Encoding findEncodingByName(String encodingName)
throws UnsupportedEncodingException {
if (encodingName == null) {
return Encoding.UTF_8;
}
for (Encoding encoding : Encoding.values()) {
if (encoding.expatName.equalsIgnoreCase(encodingName))
return encoding;
}
throw new UnsupportedEncodingException(encodingName);
}
/**
* Return an AttributeSet interface for use with the given XmlPullParser.
* If the given parser itself implements AttributeSet, that implementation
* is simply returned. Otherwise a wrapper class is
* instantiated on top of the XmlPullParser, as a proxy for retrieving its
* attributes, and returned to you.
*
* @param parser The existing parser for which you would like an
* AttributeSet.
*
* @return An AttributeSet you can use to retrieve the
* attribute values at each of the tags as the parser moves
* through its XML document.
*
* @see AttributeSet
*/
public static AttributeSet asAttributeSet(XmlPullParser parser) {
return (parser instanceof AttributeSet)
? (AttributeSet) parser
: new XmlPullAttributes(parser);
}
}
|
