private void loadFromXml(XmlPullParser parser)
        throws IOException, XmlPullParserException {
    XmlUtils.beginDocument(parser, TAG_DISPLAY_MANAGER_STATE);
    final int outerDepth = parser.getDepth();
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        if (parser.getName().equals(TAG_REMEMBERED_WIFI_DISPLAYS)) {
            loadRememberedWifiDisplaysFromXml(parser);
        }
        if (parser.getName().equals(TAG_DISPLAY_STATES)) {
            loadDisplaysFromXml(parser);
        }
        if (parser.getName().equals(TAG_STABLE_DEVICE_VALUES)) {
            mStableDeviceValues.loadFromXml(parser);
        }
        if (parser.getName().equals(TAG_BRIGHTNESS_CONFIGURATIONS)) {
            mBrightnessConfigurations.loadFromXml(parser);
        }
    }
}
 

private void loadRememberedWifiDisplaysFromXml(XmlPullParser parser)
        throws IOException, XmlPullParserException {
    final int outerDepth = parser.getDepth();
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        if (parser.getName().equals(TAG_WIFI_DISPLAY)) {
            String deviceAddress = parser.getAttributeValue(null, ATTR_DEVICE_ADDRESS);
            String deviceName = parser.getAttributeValue(null, ATTR_DEVICE_NAME);
            String deviceAlias = parser.getAttributeValue(null, ATTR_DEVICE_ALIAS);
            if (deviceAddress == null || deviceName == null) {
                throw new XmlPullParserException(
                        "Missing deviceAddress or deviceName attribute on wifi-display.");
            }
            if (findRememberedWifiDisplay(deviceAddress) >= 0) {
                throw new XmlPullParserException(
                        "Found duplicate wifi display device address.");
            }

            mRememberedWifiDisplays.add(
                    new WifiDisplay(deviceAddress, deviceName, deviceAlias,
                            false, false, false));
        }
    }
}
 

private void loadDisplaysFromXml(XmlPullParser parser)
        throws IOException, XmlPullParserException {
    final int outerDepth = parser.getDepth();
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        if (parser.getName().equals(TAG_DISPLAY)) {
            String uniqueId = parser.getAttributeValue(null, ATTR_UNIQUE_ID);
            if (uniqueId == null) {
                throw new XmlPullParserException(
                        "Missing unique-id attribute on display.");
            }
            if (mDisplayStates.containsKey(uniqueId)) {
                throw new XmlPullParserException("Found duplicate display.");
            }

            DisplayState state = new DisplayState();
            state.loadFromXml(parser);
            mDisplayStates.put(uniqueId, state);
        }
    }
}
 

private static BrightnessConfiguration loadConfigurationFromXml(XmlPullParser parser)
        throws IOException, XmlPullParserException {
    final int outerDepth = parser.getDepth();
    String description = null;
    Pair<float[], float[]> curve = null;
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        if (TAG_BRIGHTNESS_CURVE.equals(parser.getName())) {
            description = parser.getAttributeValue(null, ATTR_DESCRIPTION);
            curve = loadCurveFromXml(parser);
        }
    }
    if (curve == null) {
        return null;
    }
    final BrightnessConfiguration.Builder builder = new BrightnessConfiguration.Builder(
            curve.first, curve.second);
    builder.setDescription(description);
    return builder.build();
}
 

private static Pair<float[], float[]> loadCurveFromXml(XmlPullParser parser)
        throws IOException, XmlPullParserException {
    final int outerDepth = parser.getDepth();
    List<Float> luxLevels = new ArrayList<>();
    List<Float> nitLevels = new ArrayList<>();
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        if (TAG_BRIGHTNESS_POINT.equals(parser.getName())) {
            luxLevels.add(loadFloat(parser.getAttributeValue(null, ATTR_LUX)));
            nitLevels.add(loadFloat(parser.getAttributeValue(null, ATTR_NITS)));
        }
    }
    final int N = luxLevels.size();
    float[] lux = new float[N];
    float[] nits = new float[N];
    for (int i = 0; i < N; i++) {
        lux[i] = luxLevels.get(i);
        nits[i] = nitLevels.get(i);
    }
    return Pair.create(lux, nits);
}
 

/**
 * Reads all signatures at the current depth (within the current provider) from the XML parser.
 */
private static String[] readSignatures(XmlResourceParser parser) throws IOException,
        XmlPullParserException {
    List<String> signatures = new ArrayList<String>();
    int outerDepth = parser.getDepth();
    while(XmlUtils.nextElementWithin(parser, outerDepth)) {
        if (parser.getName().equals(TAG_SIGNATURE)) {
            // Parse the value within the signature tag
            String signature = parser.nextText();
            signatures.add(signature);
        } else {
            Log.e(TAG, "Found an element in a webview provider that is not a signature");
        }
    }
    return signatures.toArray(new String[signatures.size()]);
}
 

private void loadFromXml(XmlPullParser parser)
        throws IOException, XmlPullParserException {
    XmlUtils.beginDocument(parser, TAG_TV_INPUT_MANAGER_STATE);
    final int outerDepth = parser.getDepth();
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        if (parser.getName().equals(TAG_BLOCKED_RATINGS)) {
            loadBlockedRatingsFromXml(parser);
        } else if (parser.getName().equals(TAG_PARENTAL_CONTROLS)) {
            String enabled = parser.getAttributeValue(null, ATTR_ENABLED);
            if (TextUtils.isEmpty(enabled)) {
                throw new XmlPullParserException(
                        "Missing " + ATTR_ENABLED + " attribute on " + TAG_PARENTAL_CONTROLS);
            }
            mParentalControlsEnabled = Boolean.parseBoolean(enabled);
        }
    }
}
 

public static void readPermissions(ArrayMap<String, BasePermission> out, XmlPullParser parser)
        throws IOException, XmlPullParserException {
    int outerDepth = parser.getDepth();
    int type;
    while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
            && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
        if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
            continue;
        }

        if (!BasePermission.readLPw(out, parser)) {
            PackageManagerService.reportSettingsProblem(Log.WARN,
                    "Unknown element reading permissions: " + parser.getName() + " at "
                            + parser.getPositionDescription());
        }
        XmlUtils.skipCurrentTag(parser);
    }
}
 

private static InstantAppInfo parsePackage(@NonNull XmlPullParser parser,
                                           @NonNull String packageName)
        throws IOException, XmlPullParserException {
    String label = parser.getAttributeValue(null, ATTR_LABEL);

    List<String> outRequestedPermissions = new ArrayList<>();
    List<String> outGrantedPermissions = new ArrayList<>();

    final int outerDepth = parser.getDepth();
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        if (TAG_PERMISSIONS.equals(parser.getName())) {
            parsePermissions(parser, outRequestedPermissions, outGrantedPermissions);
        }
    }

    String[] requestedPermissions = new String[outRequestedPermissions.size()];
    outRequestedPermissions.toArray(requestedPermissions);

    String[] grantedPermissions = new String[outGrantedPermissions.size()];
    outGrantedPermissions.toArray(grantedPermissions);

    return new InstantAppInfo(packageName, label,
            requestedPermissions, grantedPermissions);
}
 

public boolean onReadTag(String tagName, XmlPullParser parser) throws XmlPullParserException,
        IOException {
    if (tagName.equals("filter")) {
        if (DEBUG_FILTERS) {
            Log.i(TAG, "Starting to parse filter...");
        }
        readFromXml(parser);
        if (DEBUG_FILTERS) {
            Log.i(TAG, "Finished filter: depth=" + parser.getDepth() + " tag="
                    + parser.getName());
        }
    } else {
        PackageManagerService.reportSettingsProblem(Log.WARN,
                "Unknown element under <preferred-activities>: " + parser.getName());
        XmlUtils.skipCurrentTag(parser);
    }
    return true;
}
 

public static void restore(@NonNull final ArrayList<SettingsItem> table,
        @NonNull final InputStream is) throws IOException, XmlPullParserException {

    try (InputStreamReader reader = new InputStreamReader(is)) {
        table.clear();
        final XmlPullParser parser = Xml.newPullParser();
        parser.setInput(reader);
        XmlUtils.beginDocument(parser, TAG_OVERLAYS);
        int version = XmlUtils.readIntAttribute(parser, ATTR_VERSION);
        if (version != CURRENT_VERSION) {
            upgrade(version);
        }
        int depth = parser.getDepth();

        while (XmlUtils.nextElementWithin(parser, depth)) {
            switch (parser.getName()) {
                case TAG_ITEM:
                    final SettingsItem item = restoreRow(parser, depth + 1);
                    table.add(item);
                    break;
            }
        }
    }
}
 

private static SettingsItem restoreRow(@NonNull final XmlPullParser parser, final int depth)
        throws IOException {
    final String packageName = XmlUtils.readStringAttribute(parser, ATTR_PACKAGE_NAME);
    final int userId = XmlUtils.readIntAttribute(parser, ATTR_USER_ID);
    final String targetPackageName = XmlUtils.readStringAttribute(parser,
            ATTR_TARGET_PACKAGE_NAME);
    final String baseCodePath = XmlUtils.readStringAttribute(parser, ATTR_BASE_CODE_PATH);
    final int state = XmlUtils.readIntAttribute(parser, ATTR_STATE);
    final boolean isEnabled = XmlUtils.readBooleanAttribute(parser, ATTR_IS_ENABLED);
    final boolean isStatic = XmlUtils.readBooleanAttribute(parser, ATTR_IS_STATIC);
    final int priority = XmlUtils.readIntAttribute(parser, ATTR_PRIORITY);
    final String category = XmlUtils.readStringAttribute(parser, ATTR_CATEGORY);

    return new SettingsItem(packageName, userId, targetPackageName, baseCodePath,
            state, isEnabled, isStatic, priority, category);
}
 

private void reloadSettings() {
    if (!mXmlFile.exists()) {
        // No settings config
        return;
    }
    try (FileInputStream stream = mXmlFile.openRead()){
        XmlPullParser parser = Xml.newPullParser();
        parser.setInput(stream, StandardCharsets.UTF_8.name());
        XmlUtils.beginDocument(parser, "network-watchlist-settings");
        final int outerDepth = parser.getDepth();
        while (XmlUtils.nextElementWithin(parser, outerDepth)) {
            if (parser.getName().equals("secret-key")) {
                mPrivacySecretKey = parseSecretKey(parser);
            }
        }
        Slog.i(TAG, "Reload watchlist settings done");
    } catch (IllegalStateException | NullPointerException | NumberFormatException |
            XmlPullParserException | IOException | IndexOutOfBoundsException e) {
        Slog.e(TAG, "Failed parsing xml", e);
    }
}
 

private void loadInputDevicesFromXml(XmlPullParser parser)
        throws IOException, XmlPullParserException {
    final int outerDepth = parser.getDepth();
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        if (parser.getName().equals("input-device")) {
            String descriptor = parser.getAttributeValue(null, "descriptor");
            if (descriptor == null) {
                throw new XmlPullParserException(
                        "Missing descriptor attribute on input-device.");
            }
            if (mInputDevices.containsKey(descriptor)) {
                throw new XmlPullParserException("Found duplicate input device.");
            }

            InputDeviceState state = new InputDeviceState();
            state.loadFromXml(parser);
            mInputDevices.put(descriptor, state);
        }
    }
}
 

@Override
public Filter newFilter(XmlPullParser parser)
        throws IOException, XmlPullParserException {
    Filter child = null;
    int outerDepth = parser.getDepth();
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        Filter filter = IntentFirewall.parseFilter(parser);
        if (child == null) {
            child = filter;
        } else {
            throw new XmlPullParserException(
                    "<not> tag can only contain a single child filter.", parser, null);
        }
    }
    return new NotFilter(child);
}
 

void readPackage(XmlPullParser parser) throws NumberFormatException,
        XmlPullParserException, IOException {
    String pkgName = parser.getAttributeValue(null, "n");
    int outerDepth = parser.getDepth();
    int type;
    while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
            && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
        if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
            continue;
        }

        String tagName = parser.getName();
        if (tagName.equals("uid")) {
            readUid(parser, pkgName);
        } else {
            Slog.w(TAG, "Unknown element under <pkg>: "
                    + parser.getName());
            XmlUtils.skipCurrentTag(parser);
        }
    }
}
 

private CertificatesEntryRef parseCertificatesEntry(XmlResourceParser parser,
        boolean defaultOverridePins)
        throws IOException, XmlPullParserException, ParserException {
    boolean overridePins =
            parser.getAttributeBooleanValue(null, "overridePins", defaultOverridePins);
    int sourceId = parser.getAttributeResourceValue(null, "src", -1);
    String sourceString = parser.getAttributeValue(null, "src");
    CertificateSource source = null;
    if (sourceString == null) {
        throw new ParserException(parser, "certificates element missing src attribute");
    }
    if (sourceId != -1) {
        // TODO: Cache ResourceCertificateSources by sourceId
        source = new ResourceCertificateSource(sourceId, mContext);
    } else if ("system".equals(sourceString)) {
        source = SystemCertificateSource.getInstance();
    } else if ("user".equals(sourceString)) {
        source = UserCertificateSource.getInstance();
    } else {
        throw new ParserException(parser, "Unknown certificates src. "
                + "Should be one of system|user|@resourceVal");
    }
    XmlUtils.skipCurrentTag(parser);
    return new CertificatesEntryRef(source, overridePins);
}
 

/** @hide */
public static PersistableBundle restoreFromXml(XmlPullParser in) throws IOException,
        XmlPullParserException {
    final int outerDepth = in.getDepth();
    final String startTag = in.getName();
    final String[] tagName = new String[1];
    int event;
    while (((event = in.next()) != XmlPullParser.END_DOCUMENT) &&
            (event != XmlPullParser.END_TAG || in.getDepth() < outerDepth)) {
        if (event == XmlPullParser.START_TAG) {
            return new PersistableBundle((ArrayMap<String, Object>)
                    XmlUtils.readThisArrayMapXml(in, startTag, tagName,
                    new MyReadMapCallback()));
        }
    }
    return EMPTY;
}
 

/**
 * Retrieve the boolean value for the attribute at <var>index</var>.
 * <p>
 * If the attribute is an integer value, this method will return whether
 * it is equal to zero. If the attribute is not a boolean or integer value,
 * this method will attempt to coerce it to an integer using
 * {@link Integer#decode(String)} and return whether it is equal to zero.
 *
 * @param index Index of attribute to retrieve.
 * @param defValue Value to return if the attribute is not defined or
 *                 cannot be coerced to an integer.
 *
 * @return Boolean value of the attribute, or defValue if the attribute was
 *         not defined or could not be coerced to an integer.
 * @throws RuntimeException if the TypedArray has already been recycled.
 */
public boolean getBoolean(@StyleableRes int index, boolean defValue) {
    if (mRecycled) {
        throw new RuntimeException("Cannot make calls to a recycled instance!");
    }

    index *= STYLE_NUM_ENTRIES;
    final int[] data = mData;
    final int type = data[index + STYLE_TYPE];
    if (type == TypedValue.TYPE_NULL) {
        return defValue;
    } else if (type >= TypedValue.TYPE_FIRST_INT
            && type <= TypedValue.TYPE_LAST_INT) {
        return data[index + STYLE_DATA] != 0;
    }

    final TypedValue v = mValue;
    if (getValueAt(index, v)) {
        StrictMode.noteResourceMismatch(v);
        return XmlUtils.convertValueToBoolean(v.coerceToString(), defValue);
    }

    // We already checked for TYPE_NULL. This should never happen.
    throw new RuntimeException("getBoolean of bad type: 0x" + Integer.toHexString(type));
}
 

/**
 * Retrieve the integer value for the attribute at <var>index</var>.
 * <p>
 * If the attribute is not an integer, this method will attempt to coerce
 * it to an integer using {@link Integer#decode(String)}.
 *
 * @param index Index of attribute to retrieve.
 * @param defValue Value to return if the attribute is not defined or
 *                 cannot be coerced to an integer.
 *
 * @return Integer value of the attribute, or defValue if the attribute was
 *         not defined or could not be coerced to an integer.
 * @throws RuntimeException if the TypedArray has already been recycled.
 */
public int getInt(@StyleableRes int index, int defValue) {
    if (mRecycled) {
        throw new RuntimeException("Cannot make calls to a recycled instance!");
    }

    index *= STYLE_NUM_ENTRIES;
    final int[] data = mData;
    final int type = data[index + STYLE_TYPE];
    if (type == TypedValue.TYPE_NULL) {
        return defValue;
    } else if (type >= TypedValue.TYPE_FIRST_INT
            && type <= TypedValue.TYPE_LAST_INT) {
        return data[index + STYLE_DATA];
    }

    final TypedValue v = mValue;
    if (getValueAt(index, v)) {
        StrictMode.noteResourceMismatch(v);
        return XmlUtils.convertValueToInt(v.coerceToString(), defValue);
    }

    // We already checked for TYPE_NULL. This should never happen.
    throw new RuntimeException("getInt of bad type: 0x" + Integer.toHexString(type));
}
 

/**
 * Parse a series of {@link android.R.styleable#Extra <extra>} tags from
 * an XML file.  You call this when you are at the parent tag of the
 * extra tags, and it will return once all of the child tags have been parsed.
 * This will call {@link #parseBundleExtra} for each extra tag encountered.
 * 
 * @param parser The parser from which to retrieve the extras.
 * @param outBundle A Bundle in which to place all parsed extras.
 * @throws XmlPullParserException
 * @throws IOException
 */
public void parseBundleExtras(XmlResourceParser parser, Bundle outBundle)
        throws XmlPullParserException, IOException {
    int outerDepth = parser.getDepth();
    int type;
    while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
           && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
        if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
            continue;
        }
        
        String nodeName = parser.getName();
        if (nodeName.equals("extra")) {
            parseBundleExtra("extra", parser, outBundle);
            XmlUtils.skipCurrentTag(parser);

        } else {
            XmlUtils.skipCurrentTag(parser);
        }
    }        
}
 

private boolean parseAllMetaData(Resources res,
        XmlPullParser parser, AttributeSet attrs, String tag,
        Component outInfo, String[] outError)
        throws XmlPullParserException, IOException {
    int outerDepth = parser.getDepth();
    int type;
    while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
           && (type != XmlPullParser.END_TAG
                   || parser.getDepth() > outerDepth)) {
        if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
            continue;
        }

        if (parser.getName().equals("meta-data")) {
            if ((outInfo.metaData=parseMetaData(res, parser, attrs,
                    outInfo.metaData, outError)) == null) {
                return false;
            }
        } else {
            if (!RIGID_PARSER) {
                Slog.w(TAG, "Unknown element under " + tag + ": "
                        + parser.getName() + " at " + mArchiveSourcePath + " "
                        + parser.getPositionDescription());
                XmlUtils.skipCurrentTag(parser);
                continue;
            } else {
                outError[0] = "Bad element under " + tag + ": " + parser.getName();
                return false;
            }
        }
    }
    return true;
}
 

private Collection<CertificatesEntryRef> parseTrustAnchors(XmlResourceParser parser,
        boolean defaultOverridePins)
        throws IOException, XmlPullParserException, ParserException {
    int outerDepth = parser.getDepth();
    List<CertificatesEntryRef> anchors = new ArrayList<>();
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        String tagName = parser.getName();
        if (tagName.equals("certificates")) {
            anchors.add(parseCertificatesEntry(parser, defaultOverridePins));
        } else {
            XmlUtils.skipCurrentTag(parser);
        }
    }
    return anchors;
}
 

private boolean parseAllMetaData(Resources res,
        XmlPullParser parser, AttributeSet attrs, String tag,
        Component outInfo, String[] outError)
        throws XmlPullParserException, IOException {
    int outerDepth = parser.getDepth();
    int type;
    while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
           && (type != XmlPullParser.END_TAG
                   || parser.getDepth() > outerDepth)) {
        if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
            continue;
        }

        if (parser.getName().equals("meta-data")) {
            if ((outInfo.metaData=parseMetaData(res, parser, attrs,
                    outInfo.metaData, outError)) == null) {
                return false;
            }
        } else {
            if (!RIGID_PARSER) {
                Slog.w(TAG, "Unknown element under " + tag + ": "
                        + parser.getName() + " at " + mArchiveSourcePath + " "
                        + parser.getPositionDescription());
                XmlUtils.skipCurrentTag(parser);
                continue;
            } else {
                outError[0] = "Bad element under " + tag + ": " + parser.getName();
                return false;
            }
        }
    }
    return true;
}
 

private boolean parseUsesPermission(Package pkg, Resources res, XmlResourceParser parser,
                                        AttributeSet attrs, String[] outError)
            throws XmlPullParserException, IOException {
        TypedArray sa = res.obtainAttributes(attrs,
                com.android.internal.R.styleable.AndroidManifestUsesPermission);

        // Note: don't allow this value to be a reference to a resource
        // that may change.
        String name = sa.getNonResourceString(
                com.android.internal.R.styleable.AndroidManifestUsesPermission_name);
/*
        boolean required = sa.getBoolean(
                com.android.internal.R.styleable.AndroidManifestUsesPermission_required, true);
*/
        boolean required = true; // Optional <uses-permission> not supported

        sa.recycle();

        if (name != null) {
            int index = pkg.requestedPermissions.indexOf(name);
            if (index == -1) {
                pkg.requestedPermissions.add(name.intern());
                pkg.requestedPermissionsRequired.add(required ? Boolean.TRUE : Boolean.FALSE);
            } else {
                if (pkg.requestedPermissionsRequired.get(index) != required) {
                    outError[0] = "conflicting <uses-permission> entries";
                    mParseError = PackageManager.INSTALL_PARSE_FAILED_MANIFEST_MALFORMED;
                    return false;
                }
            }
        }

        XmlUtils.skipCurrentTag(parser);
        return true;
    }
 

private boolean parseAllMetaData(Resources res,
        XmlPullParser parser, AttributeSet attrs, String tag,
        Component outInfo, String[] outError)
        throws XmlPullParserException, IOException {
    int outerDepth = parser.getDepth();
    int type;
    while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
           && (type != XmlPullParser.END_TAG
                   || parser.getDepth() > outerDepth)) {
        if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
            continue;
        }

        if (parser.getName().equals("meta-data")) {
            if ((outInfo.metaData=parseMetaData(res, parser, attrs,
                    outInfo.metaData, outError)) == null) {
                return false;
            }
        } else {
            if (!RIGID_PARSER) {
                Slog.w(TAG, "Unknown element under " + tag + ": "
                        + parser.getName() + " at " + mArchiveSourcePath + " "
                        + parser.getPositionDescription());
                XmlUtils.skipCurrentTag(parser);
                continue;
            } else {
                outError[0] = "Bad element under " + tag + ": " + parser.getName();
                return false;
            }
        }
    }
    return true;
}
 

private boolean parseAllMetaData(Resources res,
        XmlPullParser parser, AttributeSet attrs, String tag,
        Component outInfo, String[] outError)
        throws XmlPullParserException, IOException {
    int outerDepth = parser.getDepth();
    int type;
    while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
           && (type != XmlPullParser.END_TAG
                   || parser.getDepth() > outerDepth)) {
        if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
            continue;
        }

        if (parser.getName().equals("meta-data")) {
            if ((outInfo.metaData=parseMetaData(res, parser, attrs,
                    outInfo.metaData, outError)) == null) {
                return false;
            }
        } else {
            if (!RIGID_PARSER) {
                Slog.w(TAG, "Unknown element under " + tag + ": "
                        + parser.getName() + " at " + mArchiveSourcePath + " "
                        + parser.getPositionDescription());
                XmlUtils.skipCurrentTag(parser);
                continue;
            } else {
                outError[0] = "Bad element under " + tag + ": " + parser.getName();
                return false;
            }
        }
    }
    return true;
}
 

public void loadFromXml(XmlPullParser parser)
        throws IOException, XmlPullParserException {
    final int outerDepth = parser.getDepth();

    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        if (parser.getName().equals(TAG_COLOR_MODE)) {
            String value = parser.nextText();
            mColorMode = Integer.parseInt(value);
        }
    }
}
 

public void loadFromXml(XmlPullParser parser) throws IOException, XmlPullParserException {
    final int outerDepth = parser.getDepth();
    while (XmlUtils.nextElementWithin(parser, outerDepth)) {
        switch (parser.getName()) {
            case TAG_STABLE_DISPLAY_WIDTH:
                mWidth = loadIntValue(parser);
                break;
            case TAG_STABLE_DISPLAY_HEIGHT:
                mHeight = loadIntValue(parser);
                break;
        }
    }
}
 

private void readDisplay(XmlPullParser parser) throws NumberFormatException,
        XmlPullParserException, IOException {
    String name = parser.getAttributeValue(null, "name");
    if (name != null) {
        Entry entry = new Entry(name);
        entry.overscanLeft = getIntAttribute(parser, "overscanLeft");
        entry.overscanTop = getIntAttribute(parser, "overscanTop");
        entry.overscanRight = getIntAttribute(parser, "overscanRight");
        entry.overscanBottom = getIntAttribute(parser, "overscanBottom");
        mEntries.put(name, entry);
    }
    XmlUtils.skipCurrentTag(parser);
}