android-10.0.0_r47/s

/*
 * Copyright (C) 2019 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.providers.media.util;

import static org.xmlpull.v1.XmlPullParser.END_DOCUMENT;
import static org.xmlpull.v1.XmlPullParser.END_TAG;
import static org.xmlpull.v1.XmlPullParser.START_TAG;
import static org.xmlpull.v1.XmlPullParser.TEXT;

import android.annotation.NonNull;
import android.annotation.Nullable;
import android.media.ExifInterface;
import android.text.TextUtils;
import android.util.IntArray;
import android.util.LongArray;
import android.util.Xml;

import com.android.internal.annotations.VisibleForTesting;

import libcore.util.EmptyArray;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.Set;
import java.util.UUID;

/**
 * Parser for Extensible Metadata Platform (XMP) metadata. Designed to mirror
 * ergonomics of {@link ExifInterface}.
 * <p>
 * Since values can be repeated multiple times within the same XMP data, this
 * parser prefers the first valid definition of a specific value, and it ignores
 * any subsequent attempts to redefine that value.
 */
public class XmpInterface {
    private static final String NS_RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
    private static final String NS_XMP = "http://ns.adobe.com/xap/1.0/";
    private static final String NS_XMPMM = "http://ns.adobe.com/xap/1.0/mm/";
    private static final String NS_DC = "http://purl.org/dc/elements/1.1/";
    private static final String NS_EXIF = "http://ns.adobe.com/exif/1.0/";

    private static final String NAME_DESCRIPTION = "Description";
    private static final String NAME_FORMAT = "format";
    private static final String NAME_DOCUMENT_ID = "DocumentID";
    private static final String NAME_ORIGINAL_DOCUMENT_ID = "OriginalDocumentID";
    private static final String NAME_INSTANCE_ID = "InstanceID";

    private final ByteCountingInputStream mIn;
    private final Set<String> mRedactedExifTags;
    private final long mXmpOffset;
    private final LongArray mRedactedRanges;
    private String mFormat;
    private String mDocumentId;
    private String mInstanceId;
    private String mOriginalDocumentId;

    private XmpInterface(@NonNull InputStream in) throws IOException {
        this(in, Collections.emptySet(), EmptyArray.LONG);
    }

    private XmpInterface(
            @NonNull InputStream in, @NonNull Set<String> redactedExifTags, long[] xmpOffsets)
            throws IOException {
        mIn = new ByteCountingInputStream(in);
        mRedactedExifTags = redactedExifTags;
        mXmpOffset = xmpOffsets.length == 0 ? 0 : xmpOffsets[0];
        mRedactedRanges = new LongArray();
        try {
            final XmlPullParser parser = Xml.newPullParser();
            parser.setInput(mIn, StandardCharsets.UTF_8.name());

            long offset = 0;
            int type;
            while ((type = parser.next()) != END_DOCUMENT) {
                if (type != START_TAG) {
                    offset = mIn.getOffset(parser);
                    continue;
                }

                // The values we're interested in could be stored in either
                // attributes or tags, so we're willing to look for both

                final String ns = parser.getNamespace();
                final String name = parser.getName();

                if (NS_RDF.equals(ns) && NAME_DESCRIPTION.equals(name)) {
                    mFormat = maybeOverride(mFormat,
                            parser.getAttributeValue(NS_DC, NAME_FORMAT));
                    mDocumentId = maybeOverride(mDocumentId,
                            parser.getAttributeValue(NS_XMPMM, NAME_DOCUMENT_ID));
                    mInstanceId = maybeOverride(mInstanceId,
                            parser.getAttributeValue(NS_XMPMM, NAME_INSTANCE_ID));
                    mOriginalDocumentId = maybeOverride(mOriginalDocumentId,
                            parser.getAttributeValue(NS_XMPMM, NAME_ORIGINAL_DOCUMENT_ID));
                } else if (NS_DC.equals(ns) && NAME_FORMAT.equals(name)) {
                    mFormat = maybeOverride(mFormat, parser.nextText());
                } else if (NS_XMPMM.equals(ns) && NAME_DOCUMENT_ID.equals(name)) {
                    mDocumentId = maybeOverride(mDocumentId, parser.nextText());
                } else if (NS_XMPMM.equals(ns) && NAME_INSTANCE_ID.equals(name)) {
                    mInstanceId = maybeOverride(mInstanceId, parser.nextText());
                } else if (NS_XMPMM.equals(ns) && NAME_ORIGINAL_DOCUMENT_ID.equals(name)) {
                    mOriginalDocumentId = maybeOverride(mOriginalDocumentId, parser.nextText());
                } else if (NS_EXIF.equals(ns) && mRedactedExifTags.contains(name)) {
                    long start = offset;
                    do {
                        type = parser.next();
                    } while (type != END_TAG || !parser.getName().equals(name));
                    offset = mIn.getOffset(parser);
                    mRedactedRanges.add(mXmpOffset + start);
                    mRedactedRanges.add(mXmpOffset + offset);
                }
            }
        } catch (XmlPullParserException e) {
            throw new IOException(e);
        }
    }

    public static @NonNull XmpInterface fromContainer(@NonNull InputStream is)
            throws IOException {
        return fromContainer(new ExifInterface(is));
    }

    public static @NonNull XmpInterface fromContainer(@NonNull InputStream is,
            @NonNull Set<String> redactedExifTags) throws IOException {
        return fromContainer(new ExifInterface(is), redactedExifTags);
    }

    public static @NonNull XmpInterface fromContainer(@NonNull ExifInterface exif)
            throws IOException {
        return fromContainer(exif, Collections.emptySet());
    }

    public static @NonNull XmpInterface fromContainer(@NonNull ExifInterface exif,
            @NonNull Set<String> redactedExifTags) throws IOException {
        final byte[] buf;
        long[] xmpOffsets;
        if (exif.hasAttribute(ExifInterface.TAG_XMP)) {
            buf = exif.getAttributeBytes(ExifInterface.TAG_XMP);
            xmpOffsets = exif.getAttributeRange(ExifInterface.TAG_XMP);
        } else {
            buf = EmptyArray.BYTE;
            xmpOffsets = EmptyArray.LONG;
        }
        return new XmpInterface(new ByteArrayInputStream(buf), redactedExifTags, xmpOffsets);
    }

    public static @NonNull XmpInterface fromContainer(@NonNull IsoInterface iso)
            throws IOException {
        return fromContainer(iso, Collections.emptySet());
    }

    public static @NonNull XmpInterface fromContainer(@NonNull IsoInterface iso,
            @NonNull Set<String> redactedExifTags) throws IOException {
        byte[] buf = null;
        long[] xmpOffsets = EmptyArray.LONG;
        if (buf == null) {
            UUID uuid = UUID.fromString("be7acfcb-97a9-42e8-9c71-999491e3afac");
            buf = iso.getBoxBytes(uuid);
            xmpOffsets = iso.getBoxRanges(uuid);
        }
        if (buf == null) {
            buf = iso.getBoxBytes(IsoInterface.BOX_XMP);
            xmpOffsets = iso.getBoxRanges(IsoInterface.BOX_XMP);
        }
        if (buf == null) {
            buf = EmptyArray.BYTE;
            xmpOffsets = EmptyArray.LONG;
        }
        return new XmpInterface(new ByteArrayInputStream(buf), redactedExifTags, xmpOffsets);
    }

    public static @NonNull XmpInterface fromSidecar(@NonNull File file)
            throws IOException {
        return new XmpInterface(new FileInputStream(file));
    }

    private static @Nullable String maybeOverride(@Nullable String existing,
            @Nullable String current) {
        if (!TextUtils.isEmpty(existing)) {
            // If already defined, first definition always wins
            return existing;
        } else if (!TextUtils.isEmpty(current)) {
            // If current defined, it wins
            return current;
        } else {
            // Otherwise, null wins to prevent weird empty strings
            return null;
        }
    }

    public @Nullable String getFormat() {
        return mFormat;
    }

    public @Nullable String getDocumentId() {
        return mDocumentId;
    }

    public @Nullable String getInstanceId() {
        return mInstanceId;
    }

    public @Nullable String getOriginalDocumentId() {
        return mOriginalDocumentId;
    }

    /** The [start, end] offsets in the original file where to-be redacted info is stored */
    public LongArray getRedactionRanges() {
        return mRedactedRanges;
    }

    @VisibleForTesting
    public static class ByteCountingInputStream extends InputStream {
        private final InputStream mWrapped;
        private final LongArray mOffsets;
        private int mLine;
        private int mOffset;

        public ByteCountingInputStream(InputStream wrapped) {
            mWrapped = wrapped;
            mOffsets = new LongArray();
            mLine = 1;
            mOffset = 0;
        }

        public long getOffset(XmlPullParser parser) {
            int line = parser.getLineNumber() - 1; // getLineNumber is 1-based
            long lineOffset = line == 0 ? 0 : mOffsets.get(line - 1);
            int columnOffset = parser.getColumnNumber() - 1; // meant to be 0-based, but is 1-based?
            return lineOffset + columnOffset;
        }

        @Override
        public int read(byte[] b) throws IOException {
            return read(b, 0, b.length);
        }

        @Override
        public int read(byte[] b, int off, int len) throws IOException {
            final int read = mWrapped.read(b, off, len);
            if (read == -1) return -1;

            for (int i = 0; i < read; i++) {
                if (b[off + i] == '\n') {
                    mOffsets.add(mLine - 1, mOffset + i + 1);
                    mLine++;
                }
            }
            mOffset += read;
            return read;
        }

        @Override
        public int read() throws IOException {
            int r = mWrapped.read();
            if (r == -1) return -1;

            mOffset++;
            if (r == '\n') {
                mOffsets.add(mLine - 1, mOffset);
                mLine++;
            }
            return r;
        }

        @Override
        public long skip(long n) throws IOException {
            return super.skip(n);
        }

        @Override
        public int available() throws IOException {
            return mWrapped.available();
        }

        @Override
        public void close() throws IOException {
            mWrapped.close();
        }

        @Override
        public String toString() {
            return java.util.Arrays.toString(mOffsets.toArray());
        }
    }
}