| /* |
| * Copyright (C) 2006 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 com.android.internal.util; |
| |
| import android.annotation.NonNull; |
| import android.compat.annotation.UnsupportedAppUsage; |
| import android.graphics.Bitmap; |
| import android.graphics.Bitmap.CompressFormat; |
| import android.graphics.BitmapFactory; |
| import android.net.Uri; |
| import android.text.TextUtils; |
| import android.util.ArrayMap; |
| import android.util.Base64; |
| import android.util.Xml; |
| |
| import com.android.modules.utils.TypedXmlPullParser; |
| import com.android.modules.utils.TypedXmlSerializer; |
| |
| import libcore.util.HexEncoding; |
| |
| import org.xmlpull.v1.XmlPullParser; |
| import org.xmlpull.v1.XmlPullParserException; |
| import org.xmlpull.v1.XmlSerializer; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.net.ProtocolException; |
| import java.nio.charset.StandardCharsets; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** {@hide} */ |
| @android.ravenwood.annotation.RavenwoodKeepWholeClass |
| public class XmlUtils { |
| private static final String STRING_ARRAY_SEPARATOR = ":"; |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| private static class ForcedTypedXmlSerializer extends XmlSerializerWrapper |
| implements TypedXmlSerializer { |
| public ForcedTypedXmlSerializer(XmlSerializer wrapped) { |
| super(wrapped); |
| } |
| |
| @Override |
| public XmlSerializer attributeInterned(String namespace, String name, String value) |
| throws IOException { |
| return attribute(namespace, name, value); |
| } |
| |
| @Override |
| public XmlSerializer attributeBytesHex(String namespace, String name, byte[] value) |
| throws IOException { |
| return attribute(namespace, name, HexDump.toHexString(value)); |
| } |
| |
| @Override |
| public XmlSerializer attributeBytesBase64(String namespace, String name, byte[] value) |
| throws IOException { |
| return attribute(namespace, name, Base64.encodeToString(value, Base64.NO_WRAP)); |
| } |
| |
| @Override |
| public XmlSerializer attributeInt(String namespace, String name, int value) |
| throws IOException { |
| return attribute(namespace, name, Integer.toString(value)); |
| } |
| |
| @Override |
| public XmlSerializer attributeIntHex(String namespace, String name, int value) |
| throws IOException { |
| return attribute(namespace, name, Integer.toString(value, 16)); |
| } |
| |
| @Override |
| public XmlSerializer attributeLong(String namespace, String name, long value) |
| throws IOException { |
| return attribute(namespace, name, Long.toString(value)); |
| } |
| |
| @Override |
| public XmlSerializer attributeLongHex(String namespace, String name, long value) |
| throws IOException { |
| return attribute(namespace, name, Long.toString(value, 16)); |
| } |
| |
| @Override |
| public XmlSerializer attributeFloat(String namespace, String name, float value) |
| throws IOException { |
| return attribute(namespace, name, Float.toString(value)); |
| } |
| |
| @Override |
| public XmlSerializer attributeDouble(String namespace, String name, double value) |
| throws IOException { |
| return attribute(namespace, name, Double.toString(value)); |
| } |
| |
| @Override |
| public XmlSerializer attributeBoolean(String namespace, String name, boolean value) |
| throws IOException { |
| return attribute(namespace, name, Boolean.toString(value)); |
| } |
| } |
| |
| /** |
| * Return a specialization of the given {@link XmlSerializer} which has |
| * explicit methods to support consistent and efficient conversion of |
| * primitive data types. |
| */ |
| public static @NonNull TypedXmlSerializer makeTyped(@NonNull XmlSerializer xml) { |
| if (xml instanceof TypedXmlSerializer) { |
| return (TypedXmlSerializer) xml; |
| } else { |
| return new ForcedTypedXmlSerializer(xml); |
| } |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| private static class ForcedTypedXmlPullParser extends XmlPullParserWrapper |
| implements TypedXmlPullParser { |
| public ForcedTypedXmlPullParser(XmlPullParser wrapped) { |
| super(wrapped); |
| } |
| |
| @Override |
| public byte[] getAttributeBytesHex(int index) |
| throws XmlPullParserException { |
| try { |
| return HexDump.hexStringToByteArray(getAttributeValue(index)); |
| } catch (Exception e) { |
| throw new XmlPullParserException( |
| "Invalid attribute " + getAttributeName(index) + ": " + e); |
| } |
| } |
| |
| @Override |
| public byte[] getAttributeBytesBase64(int index) |
| throws XmlPullParserException { |
| try { |
| return Base64.decode(getAttributeValue(index), Base64.NO_WRAP); |
| } catch (Exception e) { |
| throw new XmlPullParserException( |
| "Invalid attribute " + getAttributeName(index) + ": " + e); |
| } |
| } |
| |
| @Override |
| public int getAttributeInt(int index) |
| throws XmlPullParserException { |
| try { |
| return Integer.parseInt(getAttributeValue(index)); |
| } catch (Exception e) { |
| throw new XmlPullParserException( |
| "Invalid attribute " + getAttributeName(index) + ": " + e); |
| } |
| } |
| |
| @Override |
| public int getAttributeIntHex(int index) |
| throws XmlPullParserException { |
| try { |
| return Integer.parseInt(getAttributeValue(index), 16); |
| } catch (Exception e) { |
| throw new XmlPullParserException( |
| "Invalid attribute " + getAttributeName(index) + ": " + e); |
| } |
| } |
| |
| @Override |
| public long getAttributeLong(int index) |
| throws XmlPullParserException { |
| try { |
| return Long.parseLong(getAttributeValue(index)); |
| } catch (Exception e) { |
| throw new XmlPullParserException( |
| "Invalid attribute " + getAttributeName(index) + ": " + e); |
| } |
| } |
| |
| @Override |
| public long getAttributeLongHex(int index) |
| throws XmlPullParserException { |
| try { |
| return Long.parseLong(getAttributeValue(index), 16); |
| } catch (Exception e) { |
| throw new XmlPullParserException( |
| "Invalid attribute " + getAttributeName(index) + ": " + e); |
| } |
| } |
| |
| @Override |
| public float getAttributeFloat(int index) |
| throws XmlPullParserException { |
| try { |
| return Float.parseFloat(getAttributeValue(index)); |
| } catch (Exception e) { |
| throw new XmlPullParserException( |
| "Invalid attribute " + getAttributeName(index) + ": " + e); |
| } |
| } |
| |
| @Override |
| public double getAttributeDouble(int index) |
| throws XmlPullParserException { |
| try { |
| return Double.parseDouble(getAttributeValue(index)); |
| } catch (Exception e) { |
| throw new XmlPullParserException( |
| "Invalid attribute " + getAttributeName(index) + ": " + e); |
| } |
| } |
| |
| @Override |
| public boolean getAttributeBoolean(int index) |
| throws XmlPullParserException { |
| final String value = getAttributeValue(index); |
| if ("true".equalsIgnoreCase(value)) { |
| return true; |
| } else if ("false".equalsIgnoreCase(value)) { |
| return false; |
| } else { |
| throw new XmlPullParserException( |
| "Invalid attribute " + getAttributeName(index) + ": " + value); |
| } |
| } |
| } |
| |
| /** |
| * Return a specialization of the given {@link XmlPullParser} which has |
| * explicit methods to support consistent and efficient conversion of |
| * primitive data types. |
| */ |
| public static @NonNull TypedXmlPullParser makeTyped(@NonNull XmlPullParser xml) { |
| if (xml instanceof TypedXmlPullParser) { |
| return (TypedXmlPullParser) xml; |
| } else { |
| return new ForcedTypedXmlPullParser(xml); |
| } |
| } |
| |
| @UnsupportedAppUsage |
| public static void skipCurrentTag(XmlPullParser parser) |
| throws XmlPullParserException, IOException { |
| int outerDepth = parser.getDepth(); |
| int type; |
| while ((type=parser.next()) != XmlPullParser.END_DOCUMENT |
| && (type != XmlPullParser.END_TAG |
| || parser.getDepth() > outerDepth)) { |
| } |
| } |
| |
| public static final int |
| convertValueToList(CharSequence value, String[] options, int defaultValue) |
| { |
| if (!TextUtils.isEmpty(value)) { |
| for (int i = 0; i < options.length; i++) { |
| if (value.equals(options[i])) |
| return i; |
| } |
| } |
| |
| return defaultValue; |
| } |
| |
| @UnsupportedAppUsage |
| public static final boolean |
| convertValueToBoolean(CharSequence value, boolean defaultValue) |
| { |
| boolean result = false; |
| |
| if (TextUtils.isEmpty(value)) { |
| return defaultValue; |
| } |
| |
| if (value.equals("1") |
| || value.equals("true") |
| || value.equals("TRUE")) |
| result = true; |
| |
| return result; |
| } |
| |
| @UnsupportedAppUsage |
| public static final int |
| convertValueToInt(CharSequence charSeq, int defaultValue) |
| { |
| if (TextUtils.isEmpty(charSeq)) { |
| return defaultValue; |
| } |
| |
| String nm = charSeq.toString(); |
| |
| // XXX This code is copied from Integer.decode() so we don't |
| // have to instantiate an Integer! |
| |
| int value; |
| int sign = 1; |
| int index = 0; |
| int len = nm.length(); |
| int base = 10; |
| |
| if ('-' == nm.charAt(0)) { |
| sign = -1; |
| index++; |
| } |
| |
| if ('0' == nm.charAt(index)) { |
| // Quick check for a zero by itself |
| if (index == (len - 1)) |
| return 0; |
| |
| char c = nm.charAt(index + 1); |
| |
| if ('x' == c || 'X' == c) { |
| index += 2; |
| base = 16; |
| } else { |
| index++; |
| base = 8; |
| } |
| } |
| else if ('#' == nm.charAt(index)) |
| { |
| index++; |
| base = 16; |
| } |
| |
| return Integer.parseInt(nm.substring(index), base) * sign; |
| } |
| |
| public static int convertValueToUnsignedInt(String value, int defaultValue) { |
| if (TextUtils.isEmpty(value)) { |
| return defaultValue; |
| } |
| |
| return parseUnsignedIntAttribute(value); |
| } |
| |
| public static int parseUnsignedIntAttribute(CharSequence charSeq) { |
| String value = charSeq.toString(); |
| |
| long bits; |
| int index = 0; |
| int len = value.length(); |
| int base = 10; |
| |
| if ('0' == value.charAt(index)) { |
| // Quick check for zero by itself |
| if (index == (len - 1)) |
| return 0; |
| |
| char c = value.charAt(index + 1); |
| |
| if ('x' == c || 'X' == c) { // check for hex |
| index += 2; |
| base = 16; |
| } else { // check for octal |
| index++; |
| base = 8; |
| } |
| } else if ('#' == value.charAt(index)) { |
| index++; |
| base = 16; |
| } |
| |
| return (int) Long.parseLong(value.substring(index), base); |
| } |
| |
| /** |
| * Flatten a Map into an output stream as XML. The map can later be |
| * read back with readMapXml(). |
| * |
| * @param val The map to be flattened. |
| * @param out Where to write the XML data. |
| * |
| * @see #writeMapXml(Map, String, XmlSerializer) |
| * @see #writeListXml |
| * @see #writeValueXml |
| * @see #readMapXml |
| */ |
| @UnsupportedAppUsage |
| public static final void writeMapXml(Map val, OutputStream out) |
| throws XmlPullParserException, java.io.IOException { |
| TypedXmlSerializer serializer = Xml.newFastSerializer(); |
| serializer.setOutput(out, StandardCharsets.UTF_8.name()); |
| serializer.startDocument(null, true); |
| serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); |
| writeMapXml(val, null, serializer); |
| serializer.endDocument(); |
| } |
| |
| /** |
| * Flatten a List into an output stream as XML. The list can later be |
| * read back with readListXml(). |
| * |
| * @param val The list to be flattened. |
| * @param out Where to write the XML data. |
| * |
| * @see #writeListXml(List, String, XmlSerializer) |
| * @see #writeMapXml |
| * @see #writeValueXml |
| * @see #readListXml |
| */ |
| public static final void writeListXml(List val, OutputStream out) |
| throws XmlPullParserException, java.io.IOException |
| { |
| TypedXmlSerializer serializer = Xml.newFastSerializer(); |
| serializer.setOutput(out, StandardCharsets.UTF_8.name()); |
| serializer.startDocument(null, true); |
| serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); |
| writeListXml(val, null, serializer); |
| serializer.endDocument(); |
| } |
| |
| /** |
| * Flatten a Map into an XmlSerializer. The map can later be read back |
| * with readThisMapXml(). |
| * |
| * @param val The map to be flattened. |
| * @param name Name attribute to include with this list's tag, or null for |
| * none. |
| * @param out XmlSerializer to write the map into. |
| * |
| * @see #writeMapXml(Map, OutputStream) |
| * @see #writeListXml |
| * @see #writeValueXml |
| * @see #readMapXml |
| */ |
| public static final void writeMapXml(Map val, String name, TypedXmlSerializer out) |
| throws XmlPullParserException, java.io.IOException { |
| writeMapXml(val, name, out, null); |
| } |
| |
| /** |
| * Flatten a Map into an XmlSerializer. The map can later be read back |
| * with readThisMapXml(). |
| * |
| * @param val The map to be flattened. |
| * @param name Name attribute to include with this list's tag, or null for |
| * none. |
| * @param out XmlSerializer to write the map into. |
| * @param callback Method to call when an Object type is not recognized. |
| * |
| * @see #writeMapXml(Map, OutputStream) |
| * @see #writeListXml |
| * @see #writeValueXml |
| * @see #readMapXml |
| * |
| * @hide |
| */ |
| public static final void writeMapXml(Map val, String name, TypedXmlSerializer out, |
| WriteMapCallback callback) throws XmlPullParserException, java.io.IOException { |
| |
| if (val == null) { |
| out.startTag(null, "null"); |
| out.endTag(null, "null"); |
| return; |
| } |
| |
| out.startTag(null, "map"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| |
| writeMapXml(val, out, callback); |
| |
| out.endTag(null, "map"); |
| } |
| |
| /** |
| * Flatten a Map into an XmlSerializer. The map can later be read back |
| * with readThisMapXml(). This method presumes that the start tag and |
| * name attribute have already been written and does not write an end tag. |
| * |
| * @param val The map to be flattened. |
| * @param out XmlSerializer to write the map into. |
| * |
| * @see #writeMapXml(Map, OutputStream) |
| * @see #writeListXml |
| * @see #writeValueXml |
| * @see #readMapXml |
| * |
| * @hide |
| */ |
| public static final void writeMapXml(Map val, TypedXmlSerializer out, |
| WriteMapCallback callback) throws XmlPullParserException, java.io.IOException { |
| if (val == null) { |
| return; |
| } |
| |
| Set s = val.entrySet(); |
| Iterator i = s.iterator(); |
| |
| while (i.hasNext()) { |
| Map.Entry e = (Map.Entry)i.next(); |
| writeValueXml(e.getValue(), (String)e.getKey(), out, callback); |
| } |
| } |
| |
| /** |
| * Flatten a List into an XmlSerializer. The list can later be read back |
| * with readThisListXml(). |
| * |
| * @param val The list to be flattened. |
| * @param name Name attribute to include with this list's tag, or null for |
| * none. |
| * @param out XmlSerializer to write the list into. |
| * |
| * @see #writeListXml(List, OutputStream) |
| * @see #writeMapXml |
| * @see #writeValueXml |
| * @see #readListXml |
| */ |
| public static final void writeListXml(List val, String name, TypedXmlSerializer out) |
| throws XmlPullParserException, java.io.IOException |
| { |
| if (val == null) { |
| out.startTag(null, "null"); |
| out.endTag(null, "null"); |
| return; |
| } |
| |
| out.startTag(null, "list"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| |
| int N = val.size(); |
| int i=0; |
| while (i < N) { |
| writeValueXml(val.get(i), null, out); |
| i++; |
| } |
| |
| out.endTag(null, "list"); |
| } |
| |
| public static final void writeSetXml(Set val, String name, TypedXmlSerializer out) |
| throws XmlPullParserException, java.io.IOException { |
| if (val == null) { |
| out.startTag(null, "null"); |
| out.endTag(null, "null"); |
| return; |
| } |
| |
| out.startTag(null, "set"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| |
| for (Object v : val) { |
| writeValueXml(v, null, out); |
| } |
| |
| out.endTag(null, "set"); |
| } |
| |
| /** |
| * Flatten a byte[] into an XmlSerializer. The list can later be read back |
| * with readThisByteArrayXml(). |
| * |
| * @param val The byte array to be flattened. |
| * @param name Name attribute to include with this array's tag, or null for |
| * none. |
| * @param out XmlSerializer to write the array into. |
| * |
| * @see #writeMapXml |
| * @see #writeValueXml |
| */ |
| public static final void writeByteArrayXml(byte[] val, String name, |
| TypedXmlSerializer out) |
| throws XmlPullParserException, java.io.IOException { |
| |
| if (val == null) { |
| out.startTag(null, "null"); |
| out.endTag(null, "null"); |
| return; |
| } |
| |
| out.startTag(null, "byte-array"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| |
| final int N = val.length; |
| out.attributeInt(null, "num", N); |
| |
| out.text(HexEncoding.encodeToString(val).toLowerCase()); |
| |
| out.endTag(null, "byte-array"); |
| } |
| |
| /** |
| * Flatten an int[] into an XmlSerializer. The list can later be read back |
| * with readThisIntArrayXml(). |
| * |
| * @param val The int array to be flattened. |
| * @param name Name attribute to include with this array's tag, or null for |
| * none. |
| * @param out XmlSerializer to write the array into. |
| * |
| * @see #writeMapXml |
| * @see #writeValueXml |
| * @see #readThisIntArrayXml |
| */ |
| public static final void writeIntArrayXml(int[] val, String name, |
| TypedXmlSerializer out) |
| throws XmlPullParserException, java.io.IOException { |
| |
| if (val == null) { |
| out.startTag(null, "null"); |
| out.endTag(null, "null"); |
| return; |
| } |
| |
| out.startTag(null, "int-array"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| |
| final int N = val.length; |
| out.attributeInt(null, "num", N); |
| |
| for (int i=0; i<N; i++) { |
| out.startTag(null, "item"); |
| out.attributeInt(null, "value", val[i]); |
| out.endTag(null, "item"); |
| } |
| |
| out.endTag(null, "int-array"); |
| } |
| |
| /** |
| * Flatten a long[] into an XmlSerializer. The list can later be read back |
| * with readThisLongArrayXml(). |
| * |
| * @param val The long array to be flattened. |
| * @param name Name attribute to include with this array's tag, or null for |
| * none. |
| * @param out XmlSerializer to write the array into. |
| * |
| * @see #writeMapXml |
| * @see #writeValueXml |
| * @see #readThisIntArrayXml |
| */ |
| public static final void writeLongArrayXml(long[] val, String name, TypedXmlSerializer out) |
| throws XmlPullParserException, java.io.IOException { |
| |
| if (val == null) { |
| out.startTag(null, "null"); |
| out.endTag(null, "null"); |
| return; |
| } |
| |
| out.startTag(null, "long-array"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| |
| final int N = val.length; |
| out.attributeInt(null, "num", N); |
| |
| for (int i=0; i<N; i++) { |
| out.startTag(null, "item"); |
| out.attributeLong(null, "value", val[i]); |
| out.endTag(null, "item"); |
| } |
| |
| out.endTag(null, "long-array"); |
| } |
| |
| /** |
| * Flatten a double[] into an XmlSerializer. The list can later be read back |
| * with readThisDoubleArrayXml(). |
| * |
| * @param val The double array to be flattened. |
| * @param name Name attribute to include with this array's tag, or null for |
| * none. |
| * @param out XmlSerializer to write the array into. |
| * |
| * @see #writeMapXml |
| * @see #writeValueXml |
| * @see #readThisIntArrayXml |
| */ |
| public static final void writeDoubleArrayXml(double[] val, String name, TypedXmlSerializer out) |
| throws XmlPullParserException, java.io.IOException { |
| |
| if (val == null) { |
| out.startTag(null, "null"); |
| out.endTag(null, "null"); |
| return; |
| } |
| |
| out.startTag(null, "double-array"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| |
| final int N = val.length; |
| out.attributeInt(null, "num", N); |
| |
| for (int i=0; i<N; i++) { |
| out.startTag(null, "item"); |
| out.attributeDouble(null, "value", val[i]); |
| out.endTag(null, "item"); |
| } |
| |
| out.endTag(null, "double-array"); |
| } |
| |
| /** |
| * Flatten a String[] into an XmlSerializer. The list can later be read back |
| * with readThisStringArrayXml(). |
| * |
| * @param val The String array to be flattened. |
| * @param name Name attribute to include with this array's tag, or null for |
| * none. |
| * @param out XmlSerializer to write the array into. |
| * |
| * @see #writeMapXml |
| * @see #writeValueXml |
| * @see #readThisIntArrayXml |
| */ |
| public static final void writeStringArrayXml(String[] val, String name, TypedXmlSerializer out) |
| throws XmlPullParserException, java.io.IOException { |
| |
| if (val == null) { |
| out.startTag(null, "null"); |
| out.endTag(null, "null"); |
| return; |
| } |
| |
| out.startTag(null, "string-array"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| |
| final int N = val.length; |
| out.attributeInt(null, "num", N); |
| |
| for (int i=0; i<N; i++) { |
| out.startTag(null, "item"); |
| out.attribute(null, "value", val[i]); |
| out.endTag(null, "item"); |
| } |
| |
| out.endTag(null, "string-array"); |
| } |
| |
| /** |
| * Flatten a boolean[] into an XmlSerializer. The list can later be read back |
| * with readThisBooleanArrayXml(). |
| * |
| * @param val The boolean array to be flattened. |
| * @param name Name attribute to include with this array's tag, or null for |
| * none. |
| * @param out XmlSerializer to write the array into. |
| * |
| * @see #writeMapXml |
| * @see #writeValueXml |
| * @see #readThisIntArrayXml |
| */ |
| public static final void writeBooleanArrayXml(boolean[] val, String name, |
| TypedXmlSerializer out) throws XmlPullParserException, java.io.IOException { |
| |
| if (val == null) { |
| out.startTag(null, "null"); |
| out.endTag(null, "null"); |
| return; |
| } |
| |
| out.startTag(null, "boolean-array"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| |
| final int N = val.length; |
| out.attributeInt(null, "num", N); |
| |
| for (int i=0; i<N; i++) { |
| out.startTag(null, "item"); |
| out.attributeBoolean(null, "value", val[i]); |
| out.endTag(null, "item"); |
| } |
| |
| out.endTag(null, "boolean-array"); |
| } |
| |
| @Deprecated |
| public static final void writeValueXml(Object v, String name, XmlSerializer out) |
| throws XmlPullParserException, java.io.IOException { |
| writeValueXml(v, name, XmlUtils.makeTyped(out)); |
| } |
| |
| /** |
| * Flatten an object's value into an XmlSerializer. The value can later |
| * be read back with readThisValueXml(). |
| * |
| * Currently supported value types are: null, String, Integer, Long, |
| * Float, Double Boolean, Map, List. |
| * |
| * @param v The object to be flattened. |
| * @param name Name attribute to include with this value's tag, or null |
| * for none. |
| * @param out XmlSerializer to write the object into. |
| * |
| * @see #writeMapXml |
| * @see #writeListXml |
| * @see #readValueXml |
| */ |
| public static final void writeValueXml(Object v, String name, TypedXmlSerializer out) |
| throws XmlPullParserException, java.io.IOException { |
| writeValueXml(v, name, out, null); |
| } |
| |
| /** |
| * Flatten an object's value into an XmlSerializer. The value can later |
| * be read back with readThisValueXml(). |
| * |
| * Currently supported value types are: null, String, Integer, Long, |
| * Float, Double Boolean, Map, List. |
| * |
| * @param v The object to be flattened. |
| * @param name Name attribute to include with this value's tag, or null |
| * for none. |
| * @param out XmlSerializer to write the object into. |
| * @param callback Handler for Object types not recognized. |
| * |
| * @see #writeMapXml |
| * @see #writeListXml |
| * @see #readValueXml |
| */ |
| private static final void writeValueXml(Object v, String name, TypedXmlSerializer out, |
| WriteMapCallback callback) throws XmlPullParserException, java.io.IOException { |
| if (v == null) { |
| out.startTag(null, "null"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| out.endTag(null, "null"); |
| return; |
| } else if (v instanceof String) { |
| out.startTag(null, "string"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| out.text(v.toString()); |
| out.endTag(null, "string"); |
| return; |
| } else if (v instanceof Integer) { |
| out.startTag(null, "int"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| out.attributeInt(null, "value", (int) v); |
| out.endTag(null, "int"); |
| } else if (v instanceof Long) { |
| out.startTag(null, "long"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| out.attributeLong(null, "value", (long) v); |
| out.endTag(null, "long"); |
| } else if (v instanceof Float) { |
| out.startTag(null, "float"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| out.attributeFloat(null, "value", (float) v); |
| out.endTag(null, "float"); |
| } else if (v instanceof Double) { |
| out.startTag(null, "double"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| out.attributeDouble(null, "value", (double) v); |
| out.endTag(null, "double"); |
| } else if (v instanceof Boolean) { |
| out.startTag(null, "boolean"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| out.attributeBoolean(null, "value", (boolean) v); |
| out.endTag(null, "boolean"); |
| } else if (v instanceof byte[]) { |
| writeByteArrayXml((byte[])v, name, out); |
| return; |
| } else if (v instanceof int[]) { |
| writeIntArrayXml((int[])v, name, out); |
| return; |
| } else if (v instanceof long[]) { |
| writeLongArrayXml((long[])v, name, out); |
| return; |
| } else if (v instanceof double[]) { |
| writeDoubleArrayXml((double[])v, name, out); |
| return; |
| } else if (v instanceof String[]) { |
| writeStringArrayXml((String[])v, name, out); |
| return; |
| } else if (v instanceof boolean[]) { |
| writeBooleanArrayXml((boolean[])v, name, out); |
| return; |
| } else if (v instanceof Map) { |
| writeMapXml((Map)v, name, out); |
| return; |
| } else if (v instanceof List) { |
| writeListXml((List) v, name, out); |
| return; |
| } else if (v instanceof Set) { |
| writeSetXml((Set) v, name, out); |
| return; |
| } else if (v instanceof CharSequence) { |
| // XXX This is to allow us to at least write something if |
| // we encounter styled text... but it means we will drop all |
| // of the styling information. :( |
| out.startTag(null, "string"); |
| if (name != null) { |
| out.attribute(null, "name", name); |
| } |
| out.text(v.toString()); |
| out.endTag(null, "string"); |
| return; |
| } else if (callback != null) { |
| callback.writeUnknownObject(v, name, out); |
| return; |
| } else { |
| throw new RuntimeException("writeValueXml: unable to write value " + v); |
| } |
| } |
| |
| /** |
| * Read a HashMap from an InputStream containing XML. The stream can |
| * previously have been written by writeMapXml(). |
| * |
| * @param in The InputStream from which to read. |
| * |
| * @return HashMap The resulting map. |
| * |
| * @see #readListXml |
| * @see #readValueXml |
| * @see #readThisMapXml |
| * #see #writeMapXml |
| */ |
| @SuppressWarnings("unchecked") |
| @UnsupportedAppUsage |
| public static final HashMap<String, ?> readMapXml(InputStream in) |
| throws XmlPullParserException, java.io.IOException { |
| TypedXmlPullParser parser = Xml.newFastPullParser(); |
| parser.setInput(in, StandardCharsets.UTF_8.name()); |
| return (HashMap<String, ?>) readValueXml(parser, new String[1]); |
| } |
| |
| /** |
| * Read an ArrayList from an InputStream containing XML. The stream can |
| * previously have been written by writeListXml(). |
| * |
| * @param in The InputStream from which to read. |
| * |
| * @return ArrayList The resulting list. |
| * |
| * @see #readMapXml |
| * @see #readValueXml |
| * @see #readThisListXml |
| * @see #writeListXml |
| */ |
| public static final ArrayList readListXml(InputStream in) |
| throws XmlPullParserException, java.io.IOException { |
| TypedXmlPullParser parser = Xml.newFastPullParser(); |
| parser.setInput(in, StandardCharsets.UTF_8.name()); |
| return (ArrayList)readValueXml(parser, new String[1]); |
| } |
| |
| |
| /** |
| * Read a HashSet from an InputStream containing XML. The stream can |
| * previously have been written by writeSetXml(). |
| * |
| * @param in The InputStream from which to read. |
| * |
| * @return HashSet The resulting set. |
| * |
| * @throws XmlPullParserException |
| * @throws java.io.IOException |
| * |
| * @see #readValueXml |
| * @see #readThisSetXml |
| * @see #writeSetXml |
| */ |
| public static final HashSet readSetXml(InputStream in) |
| throws XmlPullParserException, java.io.IOException { |
| TypedXmlPullParser parser = Xml.newFastPullParser(); |
| parser.setInput(in, StandardCharsets.UTF_8.name()); |
| return (HashSet) readValueXml(parser, new String[1]); |
| } |
| |
| /** |
| * Read a HashMap object from an XmlPullParser. The XML data could |
| * previously have been generated by writeMapXml(). The XmlPullParser |
| * must be positioned <em>after</em> the tag that begins the map. |
| * |
| * @param parser The XmlPullParser from which to read the map data. |
| * @param endTag Name of the tag that will end the map, usually "map". |
| * @param name An array of one string, used to return the name attribute |
| * of the map's tag. |
| * |
| * @return HashMap The newly generated map. |
| * |
| * @see #readMapXml |
| */ |
| public static final HashMap<String, ?> readThisMapXml(TypedXmlPullParser parser, String endTag, |
| String[] name) throws XmlPullParserException, java.io.IOException { |
| return readThisMapXml(parser, endTag, name, null); |
| } |
| |
| /** |
| * Read a HashMap object from an XmlPullParser. The XML data could |
| * previously have been generated by writeMapXml(). The XmlPullParser |
| * must be positioned <em>after</em> the tag that begins the map. |
| * |
| * @param parser The XmlPullParser from which to read the map data. |
| * @param endTag Name of the tag that will end the map, usually "map". |
| * @param name An array of one string, used to return the name attribute |
| * of the map's tag. |
| * |
| * @return HashMap The newly generated map. |
| * |
| * @see #readMapXml |
| * @hide |
| */ |
| public static final HashMap<String, ?> readThisMapXml(TypedXmlPullParser parser, String endTag, |
| String[] name, ReadMapCallback callback) |
| throws XmlPullParserException, java.io.IOException { |
| HashMap<String, Object> map = new HashMap<String, Object>(); |
| |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.START_TAG) { |
| Object val = readThisValueXml(parser, name, callback, false); |
| map.put(name[0], val); |
| } else if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(endTag)) { |
| return map; |
| } |
| throw new XmlPullParserException( |
| "Expected " + endTag + " end tag at: " + parser.getName()); |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException( |
| "Document ended before " + endTag + " end tag"); |
| } |
| |
| /** |
| * Like {@link #readThisMapXml}, but returns an ArrayMap instead of HashMap. |
| * @hide |
| */ |
| public static final ArrayMap<String, ?> readThisArrayMapXml(TypedXmlPullParser parser, |
| String endTag, String[] name, ReadMapCallback callback) |
| throws XmlPullParserException, java.io.IOException { |
| ArrayMap<String, Object> map = new ArrayMap<>(); |
| |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.START_TAG) { |
| Object val = readThisValueXml(parser, name, callback, true); |
| map.put(name[0], val); |
| } else if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(endTag)) { |
| return map; |
| } |
| throw new XmlPullParserException( |
| "Expected " + endTag + " end tag at: " + parser.getName()); |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException( |
| "Document ended before " + endTag + " end tag"); |
| } |
| |
| /** |
| * Read an ArrayList object from an XmlPullParser. The XML data could |
| * previously have been generated by writeListXml(). The XmlPullParser |
| * must be positioned <em>after</em> the tag that begins the list. |
| * |
| * @param parser The XmlPullParser from which to read the list data. |
| * @param endTag Name of the tag that will end the list, usually "list". |
| * @param name An array of one string, used to return the name attribute |
| * of the list's tag. |
| * |
| * @return HashMap The newly generated list. |
| * |
| * @see #readListXml |
| */ |
| public static final ArrayList readThisListXml(TypedXmlPullParser parser, String endTag, |
| String[] name) throws XmlPullParserException, java.io.IOException { |
| return readThisListXml(parser, endTag, name, null, false); |
| } |
| |
| /** |
| * Read an ArrayList object from an XmlPullParser. The XML data could |
| * previously have been generated by writeListXml(). The XmlPullParser |
| * must be positioned <em>after</em> the tag that begins the list. |
| * |
| * @param parser The XmlPullParser from which to read the list data. |
| * @param endTag Name of the tag that will end the list, usually "list". |
| * @param name An array of one string, used to return the name attribute |
| * of the list's tag. |
| * |
| * @return HashMap The newly generated list. |
| * |
| * @see #readListXml |
| */ |
| private static final ArrayList readThisListXml(TypedXmlPullParser parser, String endTag, |
| String[] name, ReadMapCallback callback, boolean arrayMap) |
| throws XmlPullParserException, java.io.IOException { |
| ArrayList list = new ArrayList(); |
| |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.START_TAG) { |
| Object val = readThisValueXml(parser, name, callback, arrayMap); |
| list.add(val); |
| //System.out.println("Adding to list: " + val); |
| } else if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(endTag)) { |
| return list; |
| } |
| throw new XmlPullParserException( |
| "Expected " + endTag + " end tag at: " + parser.getName()); |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException( |
| "Document ended before " + endTag + " end tag"); |
| } |
| |
| /** |
| * Read a HashSet object from an XmlPullParser. The XML data could previously |
| * have been generated by writeSetXml(). The XmlPullParser must be positioned |
| * <em>after</em> the tag that begins the set. |
| * |
| * @param parser The XmlPullParser from which to read the set data. |
| * @param endTag Name of the tag that will end the set, usually "set". |
| * @param name An array of one string, used to return the name attribute |
| * of the set's tag. |
| * |
| * @return HashSet The newly generated set. |
| * |
| * @throws XmlPullParserException |
| * @throws java.io.IOException |
| * |
| * @see #readSetXml |
| */ |
| public static final HashSet readThisSetXml(TypedXmlPullParser parser, String endTag, |
| String[] name) throws XmlPullParserException, java.io.IOException { |
| return readThisSetXml(parser, endTag, name, null, false); |
| } |
| |
| /** |
| * Read a HashSet object from an XmlPullParser. The XML data could previously |
| * have been generated by writeSetXml(). The XmlPullParser must be positioned |
| * <em>after</em> the tag that begins the set. |
| * |
| * @param parser The XmlPullParser from which to read the set data. |
| * @param endTag Name of the tag that will end the set, usually "set". |
| * @param name An array of one string, used to return the name attribute |
| * of the set's tag. |
| * |
| * @return HashSet The newly generated set. |
| * |
| * @throws XmlPullParserException |
| * @throws java.io.IOException |
| * |
| * @see #readSetXml |
| * @hide |
| */ |
| private static final HashSet readThisSetXml(TypedXmlPullParser parser, String endTag, |
| String[] name, ReadMapCallback callback, boolean arrayMap) |
| throws XmlPullParserException, java.io.IOException { |
| HashSet set = new HashSet(); |
| |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.START_TAG) { |
| Object val = readThisValueXml(parser, name, callback, arrayMap); |
| set.add(val); |
| //System.out.println("Adding to set: " + val); |
| } else if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(endTag)) { |
| return set; |
| } |
| throw new XmlPullParserException( |
| "Expected " + endTag + " end tag at: " + parser.getName()); |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException( |
| "Document ended before " + endTag + " end tag"); |
| } |
| |
| /** |
| * Read a byte[] object from an XmlPullParser. The XML data could |
| * previously have been generated by writeByteArrayXml(). The XmlPullParser |
| * must be positioned <em>after</em> the tag that begins the list. |
| * |
| * @param parser The XmlPullParser from which to read the list data. |
| * @param endTag Name of the tag that will end the list, usually "list". |
| * @param name An array of one string, used to return the name attribute |
| * of the list's tag. |
| * |
| * @return Returns a newly generated byte[]. |
| * |
| * @see #writeByteArrayXml |
| */ |
| public static final byte[] readThisByteArrayXml(TypedXmlPullParser parser, |
| String endTag, String[] name) |
| throws XmlPullParserException, java.io.IOException { |
| |
| int num = parser.getAttributeInt(null, "num"); |
| |
| // 0 len byte array does not have a text in the XML tag. So, initialize to 0 len array. |
| // For all other array lens, HexEncoding.decode() below overrides the array. |
| byte[] array = new byte[0]; |
| |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.TEXT) { |
| if (num > 0) { |
| String values = parser.getText(); |
| if (values == null || values.length() != num * 2) { |
| throw new XmlPullParserException( |
| "Invalid value found in byte-array: " + values); |
| } |
| array = HexEncoding.decode(values); |
| } |
| } else if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(endTag)) { |
| return array; |
| } else { |
| throw new XmlPullParserException( |
| "Expected " + endTag + " end tag at: " |
| + parser.getName()); |
| } |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException( |
| "Document ended before " + endTag + " end tag"); |
| } |
| |
| /** |
| * Read an int[] object from an XmlPullParser. The XML data could |
| * previously have been generated by writeIntArrayXml(). The XmlPullParser |
| * must be positioned <em>after</em> the tag that begins the list. |
| * |
| * @param parser The XmlPullParser from which to read the list data. |
| * @param endTag Name of the tag that will end the list, usually "list". |
| * @param name An array of one string, used to return the name attribute |
| * of the list's tag. |
| * |
| * @return Returns a newly generated int[]. |
| * |
| * @see #readListXml |
| */ |
| public static final int[] readThisIntArrayXml(TypedXmlPullParser parser, |
| String endTag, String[] name) |
| throws XmlPullParserException, java.io.IOException { |
| |
| int num = parser.getAttributeInt(null, "num"); |
| parser.next(); |
| |
| int[] array = new int[num]; |
| int i = 0; |
| |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.START_TAG) { |
| if (parser.getName().equals("item")) { |
| array[i] = parser.getAttributeInt(null, "value"); |
| } else { |
| throw new XmlPullParserException( |
| "Expected item tag at: " + parser.getName()); |
| } |
| } else if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(endTag)) { |
| return array; |
| } else if (parser.getName().equals("item")) { |
| i++; |
| } else { |
| throw new XmlPullParserException( |
| "Expected " + endTag + " end tag at: " |
| + parser.getName()); |
| } |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException( |
| "Document ended before " + endTag + " end tag"); |
| } |
| |
| /** |
| * Read a long[] object from an XmlPullParser. The XML data could |
| * previously have been generated by writeLongArrayXml(). The XmlPullParser |
| * must be positioned <em>after</em> the tag that begins the list. |
| * |
| * @param parser The XmlPullParser from which to read the list data. |
| * @param endTag Name of the tag that will end the list, usually "list". |
| * @param name An array of one string, used to return the name attribute |
| * of the list's tag. |
| * |
| * @return Returns a newly generated long[]. |
| * |
| * @see #readListXml |
| */ |
| public static final long[] readThisLongArrayXml(TypedXmlPullParser parser, |
| String endTag, String[] name) |
| throws XmlPullParserException, java.io.IOException { |
| |
| int num = parser.getAttributeInt(null, "num"); |
| parser.next(); |
| |
| long[] array = new long[num]; |
| int i = 0; |
| |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.START_TAG) { |
| if (parser.getName().equals("item")) { |
| array[i] = parser.getAttributeLong(null, "value"); |
| } else { |
| throw new XmlPullParserException("Expected item tag at: " + parser.getName()); |
| } |
| } else if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(endTag)) { |
| return array; |
| } else if (parser.getName().equals("item")) { |
| i++; |
| } else { |
| throw new XmlPullParserException("Expected " + endTag + " end tag at: " + |
| parser.getName()); |
| } |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException("Document ended before " + endTag + " end tag"); |
| } |
| |
| /** |
| * Read a double[] object from an XmlPullParser. The XML data could |
| * previously have been generated by writeDoubleArrayXml(). The XmlPullParser |
| * must be positioned <em>after</em> the tag that begins the list. |
| * |
| * @param parser The XmlPullParser from which to read the list data. |
| * @param endTag Name of the tag that will end the list, usually "double-array". |
| * @param name An array of one string, used to return the name attribute |
| * of the list's tag. |
| * |
| * @return Returns a newly generated double[]. |
| * |
| * @see #readListXml |
| */ |
| public static final double[] readThisDoubleArrayXml(TypedXmlPullParser parser, String endTag, |
| String[] name) throws XmlPullParserException, java.io.IOException { |
| |
| int num = parser.getAttributeInt(null, "num"); |
| parser.next(); |
| |
| double[] array = new double[num]; |
| int i = 0; |
| |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.START_TAG) { |
| if (parser.getName().equals("item")) { |
| array[i] = parser.getAttributeDouble(null, "value"); |
| } else { |
| throw new XmlPullParserException("Expected item tag at: " + parser.getName()); |
| } |
| } else if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(endTag)) { |
| return array; |
| } else if (parser.getName().equals("item")) { |
| i++; |
| } else { |
| throw new XmlPullParserException("Expected " + endTag + " end tag at: " + |
| parser.getName()); |
| } |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException("Document ended before " + endTag + " end tag"); |
| } |
| |
| /** |
| * Read a String[] object from an XmlPullParser. The XML data could |
| * previously have been generated by writeStringArrayXml(). The XmlPullParser |
| * must be positioned <em>after</em> the tag that begins the list. |
| * |
| * @param parser The XmlPullParser from which to read the list data. |
| * @param endTag Name of the tag that will end the list, usually "string-array". |
| * @param name An array of one string, used to return the name attribute |
| * of the list's tag. |
| * |
| * @return Returns a newly generated String[]. |
| * |
| * @see #readListXml |
| */ |
| public static final String[] readThisStringArrayXml(TypedXmlPullParser parser, String endTag, |
| String[] name) throws XmlPullParserException, java.io.IOException { |
| |
| int num = parser.getAttributeInt(null, "num"); |
| parser.next(); |
| |
| String[] array = new String[num]; |
| int i = 0; |
| |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.START_TAG) { |
| if (parser.getName().equals("item")) { |
| array[i] = parser.getAttributeValue(null, "value"); |
| } else { |
| throw new XmlPullParserException("Expected item tag at: " + parser.getName()); |
| } |
| } else if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(endTag)) { |
| return array; |
| } else if (parser.getName().equals("item")) { |
| i++; |
| } else { |
| throw new XmlPullParserException("Expected " + endTag + " end tag at: " + |
| parser.getName()); |
| } |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException("Document ended before " + endTag + " end tag"); |
| } |
| |
| /** |
| * Read a boolean[] object from an XmlPullParser. The XML data could |
| * previously have been generated by writeBooleanArrayXml(). The XmlPullParser |
| * must be positioned <em>after</em> the tag that begins the list. |
| * |
| * @param parser The XmlPullParser from which to read the list data. |
| * @param endTag Name of the tag that will end the list, usually "string-array". |
| * @param name An array of one string, used to return the name attribute |
| * of the list's tag. |
| * |
| * @return Returns a newly generated boolean[]. |
| * |
| * @see #readListXml |
| */ |
| public static final boolean[] readThisBooleanArrayXml(TypedXmlPullParser parser, String endTag, |
| String[] name) throws XmlPullParserException, java.io.IOException { |
| |
| int num = parser.getAttributeInt(null, "num"); |
| parser.next(); |
| |
| boolean[] array = new boolean[num]; |
| int i = 0; |
| |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.START_TAG) { |
| if (parser.getName().equals("item")) { |
| array[i] = parser.getAttributeBoolean(null, "value"); |
| } else { |
| throw new XmlPullParserException("Expected item tag at: " + parser.getName()); |
| } |
| } else if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(endTag)) { |
| return array; |
| } else if (parser.getName().equals("item")) { |
| i++; |
| } else { |
| throw new XmlPullParserException("Expected " + endTag + " end tag at: " + |
| parser.getName()); |
| } |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException("Document ended before " + endTag + " end tag"); |
| } |
| |
| /** |
| * Read a flattened object from an XmlPullParser. The XML data could |
| * previously have been written with writeMapXml(), writeListXml(), or |
| * writeValueXml(). The XmlPullParser must be positioned <em>at</em> the |
| * tag that defines the value. |
| * |
| * @param parser The XmlPullParser from which to read the object. |
| * @param name An array of one string, used to return the name attribute |
| * of the value's tag. |
| * |
| * @return Object The newly generated value object. |
| * |
| * @see #readMapXml |
| * @see #readListXml |
| * @see #writeValueXml |
| */ |
| public static final Object readValueXml(TypedXmlPullParser parser, String[] name) |
| throws XmlPullParserException, java.io.IOException |
| { |
| int eventType = parser.getEventType(); |
| do { |
| if (eventType == parser.START_TAG) { |
| return readThisValueXml(parser, name, null, false); |
| } else if (eventType == parser.END_TAG) { |
| throw new XmlPullParserException( |
| "Unexpected end tag at: " + parser.getName()); |
| } else if (eventType == parser.TEXT) { |
| throw new XmlPullParserException( |
| "Unexpected text: " + parser.getText()); |
| } |
| eventType = parser.next(); |
| } while (eventType != parser.END_DOCUMENT); |
| |
| throw new XmlPullParserException( |
| "Unexpected end of document"); |
| } |
| |
| private static final Object readThisValueXml(TypedXmlPullParser parser, String[] name, |
| ReadMapCallback callback, boolean arrayMap) |
| throws XmlPullParserException, java.io.IOException { |
| final String valueName = parser.getAttributeValue(null, "name"); |
| final String tagName = parser.getName(); |
| |
| //System.out.println("Reading this value tag: " + tagName + ", name=" + valueName); |
| |
| Object res; |
| |
| if (tagName.equals("null")) { |
| res = null; |
| } else if (tagName.equals("string")) { |
| final StringBuilder value = new StringBuilder(); |
| int eventType; |
| while ((eventType = parser.next()) != parser.END_DOCUMENT) { |
| if (eventType == parser.END_TAG) { |
| if (parser.getName().equals("string")) { |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + value); |
| return value.toString(); |
| } |
| throw new XmlPullParserException( |
| "Unexpected end tag in <string>: " + parser.getName()); |
| } else if (eventType == parser.TEXT) { |
| value.append(parser.getText()); |
| } else if (eventType == parser.START_TAG) { |
| throw new XmlPullParserException( |
| "Unexpected start tag in <string>: " + parser.getName()); |
| } |
| } |
| throw new XmlPullParserException( |
| "Unexpected end of document in <string>"); |
| } else if ((res = readThisPrimitiveValueXml(parser, tagName)) != null) { |
| // all work already done by readThisPrimitiveValueXml |
| } else if (tagName.equals("byte-array")) { |
| res = readThisByteArrayXml(parser, "byte-array", name); |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + res); |
| return res; |
| } else if (tagName.equals("int-array")) { |
| res = readThisIntArrayXml(parser, "int-array", name); |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + res); |
| return res; |
| } else if (tagName.equals("long-array")) { |
| res = readThisLongArrayXml(parser, "long-array", name); |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + res); |
| return res; |
| } else if (tagName.equals("double-array")) { |
| res = readThisDoubleArrayXml(parser, "double-array", name); |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + res); |
| return res; |
| } else if (tagName.equals("string-array")) { |
| res = readThisStringArrayXml(parser, "string-array", name); |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + res); |
| return res; |
| } else if (tagName.equals("boolean-array")) { |
| res = readThisBooleanArrayXml(parser, "boolean-array", name); |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + res); |
| return res; |
| } else if (tagName.equals("map")) { |
| parser.next(); |
| res = arrayMap |
| ? readThisArrayMapXml(parser, "map", name, callback) |
| : readThisMapXml(parser, "map", name, callback); |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + res); |
| return res; |
| } else if (tagName.equals("list")) { |
| parser.next(); |
| res = readThisListXml(parser, "list", name, callback, arrayMap); |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + res); |
| return res; |
| } else if (tagName.equals("set")) { |
| parser.next(); |
| res = readThisSetXml(parser, "set", name, callback, arrayMap); |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + res); |
| return res; |
| } else if (callback != null) { |
| res = callback.readThisUnknownObjectXml(parser, tagName); |
| name[0] = valueName; |
| return res; |
| } else { |
| throw new XmlPullParserException("Unknown tag: " + tagName); |
| } |
| |
| // Skip through to end tag. |
| int eventType; |
| while ((eventType = parser.next()) != parser.END_DOCUMENT) { |
| if (eventType == parser.END_TAG) { |
| if (parser.getName().equals(tagName)) { |
| name[0] = valueName; |
| //System.out.println("Returning value for " + valueName + ": " + res); |
| return res; |
| } |
| throw new XmlPullParserException( |
| "Unexpected end tag in <" + tagName + ">: " + parser.getName()); |
| } else if (eventType == parser.TEXT) { |
| throw new XmlPullParserException( |
| "Unexpected text in <" + tagName + ">: " + parser.getName()); |
| } else if (eventType == parser.START_TAG) { |
| throw new XmlPullParserException( |
| "Unexpected start tag in <" + tagName + ">: " + parser.getName()); |
| } |
| } |
| throw new XmlPullParserException( |
| "Unexpected end of document in <" + tagName + ">"); |
| } |
| |
| private static final Object readThisPrimitiveValueXml(TypedXmlPullParser parser, String tagName) |
| throws XmlPullParserException, java.io.IOException { |
| if (tagName.equals("int")) { |
| return parser.getAttributeInt(null, "value"); |
| } else if (tagName.equals("long")) { |
| return parser.getAttributeLong(null, "value"); |
| } else if (tagName.equals("float")) { |
| return parser.getAttributeFloat(null, "value"); |
| } else if (tagName.equals("double")) { |
| return parser.getAttributeDouble(null, "value"); |
| } else if (tagName.equals("boolean")) { |
| return parser.getAttributeBoolean(null, "value"); |
| } else { |
| return null; |
| } |
| } |
| |
| @UnsupportedAppUsage |
| public static final void beginDocument(XmlPullParser parser, String firstElementName) throws XmlPullParserException, IOException |
| { |
| int type; |
| while ((type=parser.next()) != parser.START_TAG |
| && type != parser.END_DOCUMENT) { |
| ; |
| } |
| |
| if (type != parser.START_TAG) { |
| throw new XmlPullParserException("No start tag found"); |
| } |
| |
| if (!parser.getName().equals(firstElementName)) { |
| throw new XmlPullParserException("Unexpected start tag: found " + parser.getName() + |
| ", expected " + firstElementName); |
| } |
| } |
| |
| @UnsupportedAppUsage |
| public static final void nextElement(XmlPullParser parser) throws XmlPullParserException, IOException |
| { |
| int type; |
| while ((type=parser.next()) != parser.START_TAG |
| && type != parser.END_DOCUMENT) { |
| ; |
| } |
| } |
| |
| public static boolean nextElementWithin(XmlPullParser parser, int outerDepth) |
| throws IOException, XmlPullParserException { |
| for (;;) { |
| int type = parser.next(); |
| if (type == XmlPullParser.END_DOCUMENT |
| || (type == XmlPullParser.END_TAG && parser.getDepth() == outerDepth)) { |
| return false; |
| } |
| if (type == XmlPullParser.START_TAG |
| && parser.getDepth() == outerDepth + 1) { |
| return true; |
| } |
| } |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static int readIntAttribute(XmlPullParser in, String name, int defaultValue) { |
| if (in instanceof TypedXmlPullParser) { |
| return ((TypedXmlPullParser) in).getAttributeInt(null, name, defaultValue); |
| } |
| final String value = in.getAttributeValue(null, name); |
| if (TextUtils.isEmpty(value)) { |
| return defaultValue; |
| } |
| try { |
| return Integer.parseInt(value); |
| } catch (NumberFormatException e) { |
| return defaultValue; |
| } |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static int readIntAttribute(XmlPullParser in, String name) throws IOException { |
| if (in instanceof TypedXmlPullParser) { |
| try { |
| return ((TypedXmlPullParser) in).getAttributeInt(null, name); |
| } catch (XmlPullParserException e) { |
| throw new ProtocolException(e.getMessage()); |
| } |
| } |
| final String value = in.getAttributeValue(null, name); |
| try { |
| return Integer.parseInt(value); |
| } catch (NumberFormatException e) { |
| throw new ProtocolException("problem parsing " + name + "=" + value + " as int"); |
| } |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static void writeIntAttribute(XmlSerializer out, String name, int value) |
| throws IOException { |
| if (out instanceof TypedXmlSerializer) { |
| ((TypedXmlSerializer) out).attributeInt(null, name, value); |
| return; |
| } |
| out.attribute(null, name, Integer.toString(value)); |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static long readLongAttribute(XmlPullParser in, String name, long defaultValue) { |
| if (in instanceof TypedXmlPullParser) { |
| return ((TypedXmlPullParser) in).getAttributeLong(null, name, defaultValue); |
| } |
| final String value = in.getAttributeValue(null, name); |
| if (TextUtils.isEmpty(value)) { |
| return defaultValue; |
| } |
| try { |
| return Long.parseLong(value); |
| } catch (NumberFormatException e) { |
| return defaultValue; |
| } |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static long readLongAttribute(XmlPullParser in, String name) throws IOException { |
| if (in instanceof TypedXmlPullParser) { |
| try { |
| return ((TypedXmlPullParser) in).getAttributeLong(null, name); |
| } catch (XmlPullParserException e) { |
| throw new ProtocolException(e.getMessage()); |
| } |
| } |
| final String value = in.getAttributeValue(null, name); |
| try { |
| return Long.parseLong(value); |
| } catch (NumberFormatException e) { |
| throw new ProtocolException("problem parsing " + name + "=" + value + " as long"); |
| } |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static void writeLongAttribute(XmlSerializer out, String name, long value) |
| throws IOException { |
| if (out instanceof TypedXmlSerializer) { |
| ((TypedXmlSerializer) out).attributeLong(null, name, value); |
| return; |
| } |
| out.attribute(null, name, Long.toString(value)); |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static float readFloatAttribute(XmlPullParser in, String name) throws IOException { |
| if (in instanceof TypedXmlPullParser) { |
| try { |
| return ((TypedXmlPullParser) in).getAttributeFloat(null, name); |
| } catch (XmlPullParserException e) { |
| throw new ProtocolException(e.getMessage()); |
| } |
| } |
| final String value = in.getAttributeValue(null, name); |
| try { |
| return Float.parseFloat(value); |
| } catch (NumberFormatException e) { |
| throw new ProtocolException("problem parsing " + name + "=" + value + " as long"); |
| } |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static void writeFloatAttribute(XmlSerializer out, String name, float value) |
| throws IOException { |
| if (out instanceof TypedXmlSerializer) { |
| ((TypedXmlSerializer) out).attributeFloat(null, name, value); |
| return; |
| } |
| out.attribute(null, name, Float.toString(value)); |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static boolean readBooleanAttribute(XmlPullParser in, String name) { |
| return readBooleanAttribute(in, name, false); |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static boolean readBooleanAttribute(XmlPullParser in, String name, |
| boolean defaultValue) { |
| if (in instanceof TypedXmlPullParser) { |
| return ((TypedXmlPullParser) in).getAttributeBoolean(null, name, defaultValue); |
| } |
| final String value = in.getAttributeValue(null, name); |
| if (TextUtils.isEmpty(value)) { |
| return defaultValue; |
| } else { |
| return Boolean.parseBoolean(value); |
| } |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static void writeBooleanAttribute(XmlSerializer out, String name, boolean value) |
| throws IOException { |
| if (out instanceof TypedXmlSerializer) { |
| ((TypedXmlSerializer) out).attributeBoolean(null, name, value); |
| return; |
| } |
| out.attribute(null, name, Boolean.toString(value)); |
| } |
| |
| public static Uri readUriAttribute(XmlPullParser in, String name) { |
| final String value = in.getAttributeValue(null, name); |
| return (value != null) ? Uri.parse(value) : null; |
| } |
| |
| public static void writeUriAttribute(XmlSerializer out, String name, Uri value) |
| throws IOException { |
| if (value != null) { |
| out.attribute(null, name, value.toString()); |
| } |
| } |
| |
| public static String readStringAttribute(XmlPullParser in, String name) { |
| return in.getAttributeValue(null, name); |
| } |
| |
| public static void writeStringAttribute(XmlSerializer out, String name, CharSequence value) |
| throws IOException { |
| if (value != null) { |
| out.attribute(null, name, value.toString()); |
| } |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static byte[] readByteArrayAttribute(XmlPullParser in, String name) { |
| if (in instanceof TypedXmlPullParser) { |
| try { |
| return ((TypedXmlPullParser) in).getAttributeBytesBase64(null, name); |
| } catch (XmlPullParserException e) { |
| return null; |
| } |
| } |
| final String value = in.getAttributeValue(null, name); |
| if (!TextUtils.isEmpty(value)) { |
| return Base64.decode(value, Base64.DEFAULT); |
| } else { |
| return null; |
| } |
| } |
| |
| @SuppressWarnings("AndroidFrameworkEfficientXml") |
| public static void writeByteArrayAttribute(XmlSerializer out, String name, byte[] value) |
| throws IOException { |
| if (value != null) { |
| if (out instanceof TypedXmlSerializer) { |
| ((TypedXmlSerializer) out).attributeBytesBase64(null, name, value); |
| return; |
| } |
| out.attribute(null, name, Base64.encodeToString(value, Base64.DEFAULT)); |
| } |
| } |
| |
| public static Bitmap readBitmapAttribute(XmlPullParser in, String name) { |
| final byte[] value = readByteArrayAttribute(in, name); |
| if (value != null) { |
| return BitmapFactory.decodeByteArray(value, 0, value.length); |
| } else { |
| return null; |
| } |
| } |
| |
| @Deprecated |
| public static void writeBitmapAttribute(XmlSerializer out, String name, Bitmap value) |
| throws IOException { |
| if (value != null) { |
| final ByteArrayOutputStream os = new ByteArrayOutputStream(); |
| value.compress(CompressFormat.PNG, 90, os); |
| writeByteArrayAttribute(out, name, os.toByteArray()); |
| } |
| } |
| |
| /** @hide */ |
| public interface WriteMapCallback { |
| /** |
| * Called from writeMapXml when an Object type is not recognized. The implementer |
| * must write out the entire element including start and end tags. |
| * |
| * @param v The object to be written out |
| * @param name The mapping key for v. Must be written into the "name" attribute of the |
| * start tag. |
| * @param out The XML output stream. |
| * @throws XmlPullParserException on unrecognized Object type. |
| * @throws IOException on XmlSerializer serialization errors. |
| * @hide |
| */ |
| public void writeUnknownObject(Object v, String name, TypedXmlSerializer out) |
| throws XmlPullParserException, IOException; |
| } |
| |
| /** @hide */ |
| public interface ReadMapCallback { |
| /** |
| * Called from readThisMapXml when a START_TAG is not recognized. The input stream |
| * is positioned within the start tag so that attributes can be read using in.getAttribute. |
| * |
| * @param in the XML input stream |
| * @param tag the START_TAG that was not recognized. |
| * @return the Object parsed from the stream which will be put into the map. |
| * @throws XmlPullParserException if the START_TAG is not recognized. |
| * @throws IOException on XmlPullParser serialization errors. |
| * @hide |
| */ |
| public Object readThisUnknownObjectXml(TypedXmlPullParser in, String tag) |
| throws XmlPullParserException, IOException; |
| } |
| } |
