android-15.0.0_r3/s

/*
 * 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 android.content.res;

import static android.content.res.Resources.ID_NULL;
import static android.system.OsConstants.EINVAL;

import android.annotation.AnyRes;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.compat.annotation.UnsupportedAppUsage;
import android.os.Build;
import android.util.TypedValue;

import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.XmlUtils;

import dalvik.annotation.optimization.CriticalNative;
import dalvik.annotation.optimization.FastNative;

import org.xmlpull.v1.XmlPullParserException;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

/**
 * Wrapper around a compiled XML file.
 *
 * {@hide}
 */
@VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
public final class XmlBlock implements AutoCloseable {
    private static final boolean DEBUG=false;

    @UnsupportedAppUsage
    public XmlBlock(byte[] data) {
        mAssets = null;
        mNative = nativeCreate(data, 0, data.length);
        mStrings = new StringBlock(nativeGetStringBlock(mNative), false);
    }

    public XmlBlock(byte[] data, int offset, int size) {
        mAssets = null;
        mNative = nativeCreate(data, offset, size);
        mStrings = new StringBlock(nativeGetStringBlock(mNative), false);
    }

    @Override
    public void close() {
        synchronized (this) {
            if (mOpen) {
                mOpen = false;
                decOpenCountLocked();
            }
        }
    }

    private void decOpenCountLocked() {
        mOpenCount--;
        if (mOpenCount == 0) {
            mStrings.close();
            nativeDestroy(mNative);
            mNative = 0;
            if (mAssets != null) {
                mAssets.xmlBlockGone(hashCode());
            }
        }
    }

    @UnsupportedAppUsage
    public XmlResourceParser newParser() {
        return newParser(ID_NULL);
    }

    public XmlResourceParser newParser(@AnyRes int resId) {
        synchronized (this) {
            if (mNative != 0) {
                return new Parser(nativeCreateParseState(mNative, resId), this);
            }
            return null;
        }
    }

    /**
     * Returns a XmlResourceParser that validates the xml using the given validator.
     */
    public XmlResourceParser newParser(@AnyRes int resId, Validator validator) {
        synchronized (this) {
            if (mNative != 0) {
                return new Parser(nativeCreateParseState(mNative, resId), this, validator);
            }
            return null;
        }
    }

    /**
     * Reference Error.h UNEXPECTED_NULL
     */
    private static final int ERROR_NULL_DOCUMENT = Integer.MIN_VALUE + 8;
    /**
     * The reason not to ResXMLParser::BAD_DOCUMENT which is -1 is that other places use the same
     * value. Reference Error.h BAD_VALUE = -EINVAL
     */
    private static final int ERROR_BAD_DOCUMENT = -EINVAL;

    @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
    public final class Parser implements XmlResourceParser {
        Validator mValidator;

        Parser(long parseState, XmlBlock block) {
            mParseState = parseState;
            mBlock = block;
            block.mOpenCount++;
        }

        Parser(long parseState, XmlBlock block, Validator validator) {
            this(parseState, block);
            mValidator = validator;
        }

        @AnyRes
        public int getSourceResId() {
            return nativeGetSourceResId(mParseState);
        }

        public void setFeature(String name, boolean state) throws XmlPullParserException {
            if (FEATURE_PROCESS_NAMESPACES.equals(name) && state) {
                return;
            }
            if (FEATURE_REPORT_NAMESPACE_ATTRIBUTES.equals(name) && state) {
                return;
            }
            throw new XmlPullParserException("Unsupported feature: " + name);
        }
        public boolean getFeature(String name) {
            if (FEATURE_PROCESS_NAMESPACES.equals(name)) {
                return true;
            }
            if (FEATURE_REPORT_NAMESPACE_ATTRIBUTES.equals(name)) {
                return true;
            }
            return false;
        }
        public void setProperty(String name, Object value) throws XmlPullParserException {
            throw new XmlPullParserException("setProperty() not supported");
        }
        public Object getProperty(String name) {
            return null;
        }
        public void setInput(Reader in) throws XmlPullParserException {
            throw new XmlPullParserException("setInput() not supported");
        }
        public void setInput(InputStream inputStream, String inputEncoding) throws XmlPullParserException {
            throw new XmlPullParserException("setInput() not supported");
        }
        public void defineEntityReplacementText(String entityName, String replacementText) throws XmlPullParserException {
            throw new XmlPullParserException("defineEntityReplacementText() not supported");
        }
        public String getNamespacePrefix(int pos) throws XmlPullParserException {
            throw new XmlPullParserException("getNamespacePrefix() not supported");
        }
        public String getInputEncoding() {
            return null;
        }
        public String getNamespace(String prefix) {
            throw new RuntimeException("getNamespace() not supported");
        }
        public int getNamespaceCount(int depth) throws XmlPullParserException {
            throw new XmlPullParserException("getNamespaceCount() not supported");
        }
        public String getPositionDescription() {
            return "Binary XML file line #" + getLineNumber();
        }
        public String getNamespaceUri(int pos) throws XmlPullParserException {
            throw new XmlPullParserException("getNamespaceUri() not supported");
        }
        public int getColumnNumber() {
            return -1;
        }
        public int getDepth() {
            return mDepth;
        }
        @Nullable
        public String getText() {
            int id = nativeGetText(mParseState);
            return id >= 0 ? getSequenceString(mStrings.getSequence(id)) : null;
        }
        public int getLineNumber() {
            final int lineNumber = nativeGetLineNumber(mParseState);
            if (lineNumber == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            return lineNumber;
        }
        public int getEventType() throws XmlPullParserException {
            return mEventType;
        }
        public boolean isWhitespace() throws XmlPullParserException {
            // whitespace was stripped by aapt.
            return false;
        }
        public String getPrefix() {
            throw new RuntimeException("getPrefix not supported");
        }
        public char[] getTextCharacters(int[] holderForStartAndLength) {
            String txt = getText();
            char[] chars = null;
            if (txt != null) {
                holderForStartAndLength[0] = 0;
                holderForStartAndLength[1] = txt.length();
                chars = new char[txt.length()];
                txt.getChars(0, txt.length(), chars, 0);
            }
            return chars;
        }
        @Nullable
        public String getNamespace() {
            int id = nativeGetNamespace(mParseState);
            return id >= 0 ? getSequenceString(mStrings.getSequence(id)) : "";
        }
        @Nullable
        public String getName() {
            int id = nativeGetName(mParseState);
            return id >= 0 ? getSequenceString(mStrings.getSequence(id)) : null;
        }
        @NonNull
        public String getAttributeNamespace(int index) {
            final int id = nativeGetAttributeNamespace(mParseState, index);
            if (id == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            if (DEBUG) System.out.println("getAttributeNamespace of " + index + " = " + id);
            if (id >= 0) return getSequenceString(mStrings.getSequence(id));
            else if (id == -1) return "";
            throw new IndexOutOfBoundsException(String.valueOf(index));
        }
        @NonNull
        public String getAttributeName(int index) {
            final int id = nativeGetAttributeName(mParseState, index);
            if (DEBUG) System.out.println("getAttributeName of " + index + " = " + id);
            if (id == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            if (id >= 0) return getSequenceString(mStrings.getSequence(id));
            throw new IndexOutOfBoundsException(String.valueOf(index));
        }
        public String getAttributePrefix(int index) {
            throw new RuntimeException("getAttributePrefix not supported");
        }
        public boolean isEmptyElementTag() throws XmlPullParserException {
            // XXX Need to detect this.
            return false;
        }
        public int getAttributeCount() {
            if (mEventType == START_TAG) {
                final int count = nativeGetAttributeCount(mParseState);
                if (count == ERROR_NULL_DOCUMENT) {
                    throw new NullPointerException("Null document");
                }
                return count;
            } else {
                return -1;
            }
        }
        @NonNull
        public String getAttributeValue(int index) {
            final int id = nativeGetAttributeStringValue(mParseState, index);
            if (id == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            if (DEBUG) System.out.println("getAttributeValue of " + index + " = " + id);
            if (id >= 0) return getSequenceString(mStrings.getSequence(id));

            // May be some other type...  check and try to convert if so.
            final int t = nativeGetAttributeDataType(mParseState, index);
            if (t == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            if (t == TypedValue.TYPE_NULL) {
                throw new IndexOutOfBoundsException(String.valueOf(index));
            }

            final int v = nativeGetAttributeData(mParseState, index);
            if (v == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            return TypedValue.coerceToString(t, v);
        }
        public String getAttributeType(int index) {
            return "CDATA";
        }
        public boolean isAttributeDefault(int index) {
            return false;
        }
        public int nextToken() throws XmlPullParserException,IOException {
            return next();
        }
        public String getAttributeValue(String namespace, String name) {
            int idx = nativeGetAttributeIndex(mParseState, namespace, name);
            if (idx >= 0) {
                if (DEBUG) System.out.println("getAttributeName of "
                        + namespace + ":" + name + " index = " + idx);
                if (DEBUG) System.out.println(
                        "Namespace=" + getAttributeNamespace(idx)
                        + "Name=" + getAttributeName(idx)
                        + ", Value=" + getAttributeValue(idx));
                String value = getAttributeValue(idx);
                if (mValidator != null) {
                    mValidator.validateStrAttr(this, name, value);
                }
                return value;
            }
            return null;
        }
        public int next() throws XmlPullParserException,IOException {
            if (!mStarted) {
                mStarted = true;
                return START_DOCUMENT;
            }
            if (mParseState == 0) {
                return END_DOCUMENT;
            }
            int ev = nativeNext(mParseState);
            if (ev == ERROR_BAD_DOCUMENT) {
                throw new XmlPullParserException("Corrupt XML binary file");
            }
            if (mDecNextDepth) {
                mDepth--;
                mDecNextDepth = false;
            }
            switch (ev) {
            case START_TAG:
                mDepth++;
                break;
            case END_TAG:
                mDecNextDepth = true;
                break;
            }
            mEventType = ev;
            if (mValidator != null) {
                mValidator.validate(this);
            }
            if (ev == END_DOCUMENT) {
                // Automatically close the parse when we reach the end of
                // a document, since the standard XmlPullParser interface
                // doesn't have such an API so most clients will leave us
                // dangling.
                close();
            }
            return ev;
        }
        public void require(int type, String namespace, String name) throws XmlPullParserException,IOException {
            if (type != getEventType()
                || (namespace != null && !namespace.equals( getNamespace () ) )
                || (name != null && !name.equals( getName() ) ) )
                throw new XmlPullParserException( "expected "+ TYPES[ type ]+getPositionDescription());
        }
        public String nextText() throws XmlPullParserException,IOException {
            if(getEventType() != START_TAG) {
               throw new XmlPullParserException(
                 getPositionDescription()
                 + ": parser must be on START_TAG to read next text", this, null);
            }
            int eventType = next();
            if(eventType == TEXT) {
               String result = getText();
               eventType = next();
               if(eventType != END_TAG) {
                 throw new XmlPullParserException(
                    getPositionDescription()
                    + ": event TEXT it must be immediately followed by END_TAG", this, null);
                }
                return result;
            } else if(eventType == END_TAG) {
               return "";
            } else {
               throw new XmlPullParserException(
                 getPositionDescription()
                 + ": parser must be on START_TAG or TEXT to read text", this, null);
            }
        }
        public int nextTag() throws XmlPullParserException,IOException {
            int eventType = next();
            if(eventType == TEXT && isWhitespace()) {   // skip whitespace
               eventType = next();
            }
            if (eventType != START_TAG && eventType != END_TAG) {
               throw new XmlPullParserException(
                   getPositionDescription()
                   + ": expected start or end tag", this, null);
            }
            return eventType;
        }

        public int getAttributeNameResource(int index) {
            final int resourceNameId = nativeGetAttributeResource(mParseState, index);
            if (resourceNameId == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            return resourceNameId;
        }

        public int getAttributeListValue(String namespace, String attribute,
                String[] options, int defaultValue) {
            int idx = nativeGetAttributeIndex(mParseState, namespace, attribute);
            if (idx >= 0) {
                return getAttributeListValue(idx, options, defaultValue);
            }
            return defaultValue;
        }
        public boolean getAttributeBooleanValue(String namespace, String attribute,
                boolean defaultValue) {
            int idx = nativeGetAttributeIndex(mParseState, namespace, attribute);
            if (idx >= 0) {
                return getAttributeBooleanValue(idx, defaultValue);
            }
            return defaultValue;
        }
        public int getAttributeResourceValue(String namespace, String attribute,
                int defaultValue) {
            int idx = nativeGetAttributeIndex(mParseState, namespace, attribute);
            if (idx >= 0) {
                return getAttributeResourceValue(idx, defaultValue);
            }
            return defaultValue;
        }
        public int getAttributeIntValue(String namespace, String attribute,
                int defaultValue) {
            int idx = nativeGetAttributeIndex(mParseState, namespace, attribute);
            if (idx >= 0) {
                return getAttributeIntValue(idx, defaultValue);
            }
            return defaultValue;
        }
        public int getAttributeUnsignedIntValue(String namespace, String attribute,
                                                int defaultValue)
        {
            int idx = nativeGetAttributeIndex(mParseState, namespace, attribute);
            if (idx >= 0) {
                return getAttributeUnsignedIntValue(idx, defaultValue);
            }
            return defaultValue;
        }
        public float getAttributeFloatValue(String namespace, String attribute,
                float defaultValue) {
            int idx = nativeGetAttributeIndex(mParseState, namespace, attribute);
            if (idx >= 0) {
                return getAttributeFloatValue(idx, defaultValue);
            }
            return defaultValue;
        }

        public int getAttributeListValue(int idx,
                String[] options, int defaultValue) {
            final int t = nativeGetAttributeDataType(mParseState, idx);
            if (t == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            final int v = nativeGetAttributeData(mParseState, idx);
            if (v == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            if (t == TypedValue.TYPE_STRING) {
                return XmlUtils.convertValueToList(
                    mStrings.getSequence(v), options, defaultValue);
            }
            return v;
        }
        public boolean getAttributeBooleanValue(int idx,
                boolean defaultValue) {
            final int t = nativeGetAttributeDataType(mParseState, idx);
            if (t == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            // Note: don't attempt to convert any other types, because
            // we want to count on aapt doing the conversion for us.
            if (t >= TypedValue.TYPE_FIRST_INT && t <= TypedValue.TYPE_LAST_INT) {
                final int v = nativeGetAttributeData(mParseState, idx);
                if (v == ERROR_NULL_DOCUMENT) {
                    throw new NullPointerException("Null document");
                }
                return v != 0;
            }
            return defaultValue;
        }
        public int getAttributeResourceValue(int idx, int defaultValue) {
            final int t = nativeGetAttributeDataType(mParseState, idx);
            if (t == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            // Note: don't attempt to convert any other types, because
            // we want to count on aapt doing the conversion for us.
            if (t == TypedValue.TYPE_REFERENCE) {
                final int v = nativeGetAttributeData(mParseState, idx);
                if (v == ERROR_NULL_DOCUMENT) {
                    throw new NullPointerException("Null document");
                }
                return v;
            }
            return defaultValue;
        }
        public int getAttributeIntValue(int idx, int defaultValue) {
            final int t = nativeGetAttributeDataType(mParseState, idx);
            if (t == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            // Note: don't attempt to convert any other types, because
            // we want to count on aapt doing the conversion for us.
            if (t >= TypedValue.TYPE_FIRST_INT && t <= TypedValue.TYPE_LAST_INT) {
                final int v = nativeGetAttributeData(mParseState, idx);
                if (v == ERROR_NULL_DOCUMENT) {
                    throw new NullPointerException("Null document");
                }
                return v;
            }
            return defaultValue;
        }
        public int getAttributeUnsignedIntValue(int idx, int defaultValue) {
            int t = nativeGetAttributeDataType(mParseState, idx);
            if (t == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            // Note: don't attempt to convert any other types, because
            // we want to count on aapt doing the conversion for us.
            if (t >= TypedValue.TYPE_FIRST_INT && t <= TypedValue.TYPE_LAST_INT) {
                final int v = nativeGetAttributeData(mParseState, idx);
                if (v == ERROR_NULL_DOCUMENT) {
                    throw new NullPointerException("Null document");
                }
                return v;
            }
            return defaultValue;
        }
        public float getAttributeFloatValue(int idx, float defaultValue) {
            final int t = nativeGetAttributeDataType(mParseState, idx);
            if (t == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            // Note: don't attempt to convert any other types, because
            // we want to count on aapt doing the conversion for us.
            if (t == TypedValue.TYPE_FLOAT) {
                final int v = nativeGetAttributeData(mParseState, idx);
                if (v == ERROR_NULL_DOCUMENT) {
                    throw new NullPointerException("Null document");
                }
                return Float.intBitsToFloat(v);
            }
            throw new RuntimeException("not a float!");
        }
        @Nullable
        public String getIdAttribute() {
            final int id = nativeGetIdAttribute(mParseState);
            if (id == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            return id >= 0 ? getSequenceString(mStrings.getSequence(id)) : null;
        }
        @Nullable
        public String getClassAttribute() {
            final int id = nativeGetClassAttribute(mParseState);
            if (id == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            return id >= 0 ? getSequenceString(mStrings.getSequence(id)) : null;
        }

        public int getIdAttributeResourceValue(int defaultValue) {
            //todo: create and use native method
            return getAttributeResourceValue(null, "id", defaultValue);
        }

        public int getStyleAttribute() {
            final int styleAttributeId = nativeGetStyleAttribute(mParseState);
            if (styleAttributeId == ERROR_NULL_DOCUMENT) {
                throw new NullPointerException("Null document");
            }
            return styleAttributeId;
        }

        private String getSequenceString(@Nullable CharSequence str) {
            if (str == null) {
                // A value of null retrieved from a StringPool indicates that retrieval of the
                // string failed due to incremental installation. The presence of all the XmlBlock
                // data is verified when it is created, so this exception must not be possible.
                throw new IllegalStateException("Retrieving a string from the StringPool of an"
                        + " XmlBlock should never fail");
            }
            return str.toString();
        }

        public void close() {
            synchronized (mBlock) {
                if (mParseState != 0) {
                    nativeDestroyParseState(mParseState);
                    mParseState = 0;
                    mBlock.decOpenCountLocked();
                }
            }
        }

        protected void finalize() throws Throwable {
            close();
        }

        @Nullable
        /*package*/ final CharSequence getPooledString(int id) {
            return mStrings.getSequence(id);
        }

        @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
        /*package*/ long mParseState;
        @UnsupportedAppUsage
        private final XmlBlock mBlock;
        private boolean mStarted = false;
        private boolean mDecNextDepth = false;
        private int mDepth = 0;
        private int mEventType = START_DOCUMENT;
    }

    protected void finalize() throws Throwable {
        close();
    }

    /**
     * Create from an existing xml block native object.  This is
     * -extremely- dangerous -- only use it if you absolutely know what you
     *  are doing!  The given native object must exist for the entire lifetime
     *  of this newly creating XmlBlock.
     */
    XmlBlock(@Nullable AssetManager assets, long xmlBlock) {
        mAssets = assets;
        mNative = xmlBlock;
        mStrings = new StringBlock(nativeGetStringBlock(xmlBlock), false);
    }

    private @Nullable final AssetManager mAssets;
    private long mNative;   // final, but gets reset on close
    /*package*/ final StringBlock mStrings;
    private boolean mOpen = true;
    private int mOpenCount = 1;

    private static final native long nativeCreate(byte[] data,
                                                 int offset,
                                                 int size);
    private static final native long nativeGetStringBlock(long obj);
    private static final native long nativeCreateParseState(long obj, int resId);
    private static final native void nativeDestroyParseState(long state);
    private static final native void nativeDestroy(long obj);

    // ----------- @FastNative ------------------

    @FastNative
    private static native int nativeGetAttributeIndex(
            long state, String namespace, String name);

    // ----------- @CriticalNative ------------------
    @CriticalNative
    /*package*/ static final native int nativeNext(long state);

    @CriticalNative
    private static final native int nativeGetNamespace(long state);

    @CriticalNative
    /*package*/ static final native int nativeGetName(long state);

    @CriticalNative
    private static final native int nativeGetText(long state);

    @CriticalNative
    private static final native int nativeGetLineNumber(long state);

    @CriticalNative
    private static final native int nativeGetAttributeCount(long state);

    @CriticalNative
    private static final native int nativeGetAttributeNamespace(long state, int idx);

    @CriticalNative
    private static final native int nativeGetAttributeName(long state, int idx);

    @CriticalNative
    private static final native int nativeGetAttributeResource(long state, int idx);

    @CriticalNative
    private static final native int nativeGetAttributeDataType(long state, int idx);

    @CriticalNative
    private static final native int nativeGetAttributeData(long state, int idx);

    @CriticalNative
    private static final native int nativeGetAttributeStringValue(long state, int idx);

    @CriticalNative
    private static final native int nativeGetIdAttribute(long state);

    @CriticalNative
    private static final native int nativeGetClassAttribute(long state);

    @CriticalNative
    private static final native int nativeGetStyleAttribute(long state);

    @CriticalNative
    private static final native int nativeGetSourceResId(long state);
}