();
try {
parserClasses.add(Class.forName("org.kxml2.io.KXmlParser"));
serializerClasses.add(Class.forName("org.kxml2.io.KXmlSerializer"));
} catch (ClassNotFoundException e) {
throw new AssertionError();
}
}
/**
* Set the features to be set when XML Pull Parser is created by this factory.
* NOTE: factory features are not used for XML Serializer.
*
* @param name string with URI identifying feature
* @param state if true feature will be set; if false will be ignored
*/
public void setFeature(String name, boolean state) throws XmlPullParserException {
features.put(name, state);
}
/**
* Return the current value of the feature with given name.
*
NOTE: factory features are not used for XML Serializer.
*
* @param name The name of feature to be retrieved.
* @return The value of named feature.
* Unknown features are always returned as false
*/
public boolean getFeature(String name) {
Boolean value = features.get(name);
return value != null ? value.booleanValue() : false;
}
/**
* Specifies that the parser produced by this factory will provide
* support for XML namespaces.
* By default the value of this is set to false.
*
* @param awareness true if the parser produced by this code
* will provide support for XML namespaces; false otherwise.
*/
public void setNamespaceAware(boolean awareness) {
features.put (XmlPullParser.FEATURE_PROCESS_NAMESPACES, awareness);
}
/**
* Indicates whether or not the factory is configured to produce
* parsers which are namespace aware
* (it simply set feature XmlPullParser.FEATURE_PROCESS_NAMESPACES to true or false).
*
* @return true if the factory is configured to produce parsers
* which are namespace aware; false otherwise.
*/
public boolean isNamespaceAware() {
return getFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES);
}
/**
* Specifies that the parser produced by this factory will be validating
* (it simply set feature XmlPullParser.FEATURE_VALIDATION to true or false).
*
* By default the value of this is set to false.
*
* @param validating - if true the parsers created by this factory must be validating.
*/
public void setValidating(boolean validating) {
features.put(XmlPullParser.FEATURE_VALIDATION, validating);
}
/**
* Indicates whether or not the factory is configured to produce parsers
* which validate the XML content during parse.
*
* @return true if the factory is configured to produce parsers
* which validate the XML content during parse; false otherwise.
*/
public boolean isValidating() {
return getFeature(XmlPullParser.FEATURE_VALIDATION);
}
/**
* Creates a new instance of a XML Pull Parser
* using the currently configured factory features.
*
* @return A new instance of a XML Pull Parser.
*/
public XmlPullParser newPullParser() throws XmlPullParserException {
final XmlPullParser pp = getParserInstance();
for (Map.Entry entry : features.entrySet()) {
// NOTE: This test is needed for compatibility reasons. We guarantee
// that we only set a feature on a parser if its value is true.
if (entry.getValue()) {
pp.setFeature(entry.getKey(), entry.getValue());
}
}
return pp;
}
private XmlPullParser getParserInstance() throws XmlPullParserException {
ArrayList exceptions = null;
if (parserClasses != null && !parserClasses.isEmpty()) {
exceptions = new ArrayList();
for (Object o : parserClasses) {
try {
if (o != null) {
Class parserClass = (Class) o;
return (XmlPullParser) parserClass.newInstance();
}
} catch (InstantiationException e) {
exceptions.add(e);
} catch (IllegalAccessException e) {
exceptions.add(e);
} catch (ClassCastException e) {
exceptions.add(e);
}
}
}
throw newInstantiationException("Invalid parser class list", exceptions);
}
private XmlSerializer getSerializerInstance() throws XmlPullParserException {
ArrayList exceptions = null;
if (serializerClasses != null && !serializerClasses.isEmpty()) {
exceptions = new ArrayList();
for (Object o : serializerClasses) {
try {
if (o != null) {
Class serializerClass = (Class) o;
return (XmlSerializer) serializerClass.newInstance();
}
} catch (InstantiationException e) {
exceptions.add(e);
} catch (IllegalAccessException e) {
exceptions.add(e);
} catch (ClassCastException e) {
exceptions.add(e);
}
}
}
throw newInstantiationException("Invalid serializer class list", exceptions);
}
private static XmlPullParserException newInstantiationException(String message,
ArrayList exceptions) {
if (exceptions == null || exceptions.isEmpty()) {
return new XmlPullParserException(message);
} else {
XmlPullParserException exception = new XmlPullParserException(message);
for (Exception ex : exceptions) {
exception.addSuppressed(ex);
}
return exception;
}
}
/**
* Creates a new instance of a XML Serializer.
*
* NOTE: factory features are not used for XML Serializer.
*
* @return A new instance of a XML Serializer.
* @throws XmlPullParserException if a parser cannot be created which satisfies the
* requested configuration.
*/
public XmlSerializer newSerializer() throws XmlPullParserException {
return getSerializerInstance();
}
/**
* Creates a new instance of a PullParserFactory that can be used
* to create XML pull parsers. The factory will always return instances
* of Android's built-in {@link XmlPullParser} and {@link XmlSerializer}.
*/
public static XmlPullParserFactory newInstance () throws XmlPullParserException {
return new XmlPullParserFactory();
}
/**
* Creates a factory that always returns instances of Android's built-in
* {@link XmlPullParser} and {@link XmlSerializer} implementation. This
* does not support factories capable of creating arbitrary parser
* and serializer implementations. Both arguments to this method are unused.
*/
public static XmlPullParserFactory newInstance (String unused, Class unused2)
throws XmlPullParserException {
return newInstance();
}
}