Merge "Perf regression fix on low-level devices."

import org.xmlpull.v1.XmlPullParser;

import org.xmlpull.v1.XmlPullParserException;

import java.io.BufferedOutputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.nio.charset.StandardCharsets;

import java.io.OutputStream;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.Collections;

    public String computePackageStateHash(@UserIdInt int userId) {

        PackageManagerInternal packageManagerInternal = LocalServices.getService(

                PackageManagerInternal.class);

        final MessageDigestUtils md = new MessageDigestUtils();

        final MessageDigestOutputStream mdos = new MessageDigestOutputStream();

        DataOutputStream dataOutputStream = new DataOutputStream(new BufferedOutputStream(mdos));

        packageManagerInternal.forEachInstalledPackage(pkg -> {

            md.writeString(pkg.getPackageName());

            md.writeLong(pkg.getLongVersionCode());

            md.writeInt(packageManagerInternal.getApplicationEnabledState(pkg.getPackageName(),

                    userId));

            try {

                dataOutputStream.writeUTF(pkg.getPackageName());

                dataOutputStream.writeLong(pkg.getLongVersionCode());

                dataOutputStream.writeInt(packageManagerInternal.getApplicationEnabledState(

                        pkg.getPackageName(), userId));

                final List<String> requestedPermissions = pkg.getRequestedPermissions();

                final int requestedPermissionsSize = requestedPermissions.size();

            md.writeInt(requestedPermissionsSize);

                dataOutputStream.writeInt(requestedPermissionsSize);

                for (int i = 0; i < requestedPermissionsSize; i++) {

                md.writeString(requestedPermissions.get(i));

                    dataOutputStream.writeUTF(requestedPermissions.get(i));

                }

            final ArraySet<String> enabledComponents = packageManagerInternal.getEnabledComponents(

                    pkg.getPackageName(), userId);

                final ArraySet<String> enabledComponents =

                        packageManagerInternal.getEnabledComponents(pkg.getPackageName(), userId);

                final int enabledComponentsSize = CollectionUtils.size(enabledComponents);

            md.writeInt(enabledComponentsSize);

                dataOutputStream.writeInt(enabledComponentsSize);

                for (int i = 0; i < enabledComponentsSize; i++) {

                md.writeString(enabledComponents.valueAt(i));

                    dataOutputStream.writeUTF(enabledComponents.valueAt(i));

                }

                final ArraySet<String> disabledComponents =

                        packageManagerInternal.getDisabledComponents(pkg.getPackageName(), userId);

                final int disabledComponentsSize = CollectionUtils.size(disabledComponents);

                for (int i = 0; i < disabledComponentsSize; i++) {

                md.writeString(disabledComponents.valueAt(i));

                    dataOutputStream.writeUTF(disabledComponents.valueAt(i));

                }

                for (final Signature signature : pkg.getSigningDetails().getSignatures()) {

                md.writeBytes(signature.toByteArray());

                    dataOutputStream.write(signature.toByteArray());

                }

            } catch (IOException e) {

                // Never happens for MessageDigestOutputStream and DataOutputStream.

                throw new AssertionError(e);

            }

        }, userId);

        return md.getDigestAsString();

        return mdos.getDigestAsString();

    }

    private static class MessageDigestUtils {

        private final byte[] mBuffer = new byte[8];

    private static class MessageDigestOutputStream extends OutputStream {

        private final MessageDigest mMessageDigest;

        MessageDigestUtils() {

        MessageDigestOutputStream() {

            try {

                mMessageDigest = MessageDigest.getInstance("SHA256");

            } catch (NoSuchAlgorithmException e) {

            return HexEncoding.encodeToString(mMessageDigest.digest(), true /* uppercase */);

        }

        void writeBytes(@NonNull byte[] bytes) {

            mMessageDigest.update(bytes);

        }

        void writeString(@NonNull String s) {

            mMessageDigest.update(s.getBytes(StandardCharsets.UTF_8));

        @Override

        public void write(int b) throws IOException {

            mMessageDigest.update((byte) b);

        }

        void writeLong(long v) {

            mBuffer[0] = (byte) (v >>> 56);

            mBuffer[1] = (byte) (v >>> 48);

            mBuffer[2] = (byte) (v >>> 40);

            mBuffer[3] = (byte) (v >>> 32);

            mBuffer[4] = (byte) (v >>> 24);

            mBuffer[5] = (byte) (v >>> 16);

            mBuffer[6] = (byte) (v >>>  8);

            mBuffer[7] = (byte) (v >>>  0);

            mMessageDigest.update(mBuffer, 0, 8);

        @Override

        public void write(byte[] b) throws IOException {

            mMessageDigest.update(b);

        }

        void writeInt(int v) {

            mBuffer[0] = (byte) (v >>> 24);

            mBuffer[1] = (byte) (v >>> 16);

            mBuffer[2] = (byte) (v >>>  8);

            mBuffer[3] = (byte) (v >>>  0);

            mMessageDigest.update(mBuffer, 0, 4);

        @Override

        public void write(byte[] b, int off, int len) throws IOException {

            mMessageDigest.update(b, off, len);

        }

    }

}