Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1259c1fe authored by Jeff Sharkey's avatar Jeff Sharkey
Browse files

Mechanically apply TypedXml refaster template. 

This is a purely mechanical CL that applies the output of the
recently added refaster templates to help guide towards more
efficient TypedXml methods.  There is no behavior change.

Bug: 171832118
Test: manual
Change-Id: I5df6df67a9d53675c23a7ba1c0d5126f5fe72c25
parent f14ed648

services/core/java/com/android/server/pm/CrossProfileIntentFilter.java

+2 −2
Original line number Diff line number Diff line
@@ -124,8 +124,8 @@ class CrossProfileIntentFilter extends IntentFilter { 
    }



    public void writeToXml(TypedXmlSerializer serializer) throws IOException {

        serializer.attribute(null, ATTR_TARGET_USER_ID, Integer.toString(mTargetUserId));

        serializer.attribute(null, ATTR_FLAGS, Integer.toString(mFlags));

        serializer.attributeInt(null, ATTR_TARGET_USER_ID, mTargetUserId);

        serializer.attributeInt(null, ATTR_FLAGS, mFlags);

        serializer.attribute(null, ATTR_OWNER_PACKAGE, mOwnerPackage);

        serializer.startTag(null, ATTR_FILTER);

            super.writeToXml(serializer);

services/core/java/com/android/server/pm/InstantAppRegistry.java

+2 −2
Original line number Diff line number Diff line
@@ -1108,7 +1108,7 @@ class InstantAppRegistry { 
            if (TAG_PERMISSION.equals(parser.getName())) {

                String permission = XmlUtils.readStringAttribute(parser, ATTR_NAME);

                outRequestedPermissions.add(permission);

                if (XmlUtils.readBooleanAttribute(parser, ATTR_GRANTED)) {

                if (parser.getAttributeBoolean(null, ATTR_GRANTED, false)) {

                    outGrantedPermissions.add(permission);

                }

            }
@@ -1143,7 +1143,7 @@ class InstantAppRegistry { 
                serializer.startTag(null, TAG_PERMISSION);

                serializer.attribute(null, ATTR_NAME, permission);

                if (ArrayUtils.contains(instantApp.getGrantedPermissions(), permission)) {

                    serializer.attribute(null, ATTR_GRANTED, String.valueOf(true));

                    serializer.attributeBoolean(null, ATTR_GRANTED, true);

                }

                serializer.endTag(null, TAG_PERMISSION);

            }

services/core/java/com/android/server/pm/KeySetManagerService.java

+8 −8
Original line number Diff line number Diff line
@@ -674,14 +674,14 @@ public class KeySetManagerService { 


    void writeKeySetManagerServiceLPr(TypedXmlSerializer serializer) throws IOException {

        serializer.startTag(null, "keyset-settings");

        serializer.attribute(null, "version", Integer.toString(CURRENT_VERSION));

        serializer.attributeInt(null, "version", CURRENT_VERSION);

        writePublicKeysLPr(serializer);

        writeKeySetsLPr(serializer);

        serializer.startTag(null, "lastIssuedKeyId");

        serializer.attribute(null, "value", Long.toString(lastIssuedKeyId));

        serializer.attributeLong(null, "value", lastIssuedKeyId);

        serializer.endTag(null, "lastIssuedKeyId");

        serializer.startTag(null, "lastIssuedKeySetId");

        serializer.attribute(null, "value", Long.toString(lastIssuedKeySetId));

        serializer.attributeLong(null, "value", lastIssuedKeySetId);

        serializer.endTag(null, "lastIssuedKeySetId");

        serializer.endTag(null, "keyset-settings");

    }
@@ -693,7 +693,7 @@ public class KeySetManagerService { 
            PublicKeyHandle pkh = mPublicKeys.valueAt(pKeyIndex);

            String encodedKey = encodePublicKey(pkh.getKey());

            serializer.startTag(null, "public-key");

            serializer.attribute(null, "identifier", Long.toString(id));

            serializer.attributeLong(null, "identifier", id);

            serializer.attribute(null, "value", encodedKey);

            serializer.endTag(null, "public-key");

        }
@@ -706,10 +706,10 @@ public class KeySetManagerService { 
            long id = mKeySetMapping.keyAt(keySetIndex);

            ArraySet<Long> keys = mKeySetMapping.valueAt(keySetIndex);

            serializer.startTag(null, "keyset");

            serializer.attribute(null, "identifier", Long.toString(id));

            serializer.attributeLong(null, "identifier", id);

            for (long keyId : keys) {

                serializer.startTag(null, "key-id");

                serializer.attribute(null, "identifier", Long.toString(keyId));

                serializer.attributeLong(null, "identifier", keyId);

                serializer.endTag(null, "key-id");

            }

            serializer.endTag(null, "keyset");
@@ -749,9 +749,9 @@ public class KeySetManagerService { 
            } else if (tagName.equals("keysets")) {

                readKeySetListLPw(parser);

            } else if (tagName.equals("lastIssuedKeyId")) {

                lastIssuedKeyId = Long.parseLong(parser.getAttributeValue(null, "value"));

                lastIssuedKeyId = parser.getAttributeLong(null, "value");

            } else if (tagName.equals("lastIssuedKeySetId")) {

                lastIssuedKeySetId = Long.parseLong(parser.getAttributeValue(null, "value"));

                lastIssuedKeySetId = parser.getAttributeLong(null, "value");

            }

        }

services/core/java/com/android/server/pm/PackageInstallerSession.java

+49 −48
Original line number Diff line number Diff line
@@ -3971,7 +3971,7 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub { 
    private static void writeAutoRevokePermissionsMode(@NonNull TypedXmlSerializer out, int mode)

            throws IOException {

        out.startTag(null, TAG_AUTO_REVOKE_PERMISSIONS_MODE);

        writeIntAttribute(out, ATTR_MODE, mode);

        out.attributeInt(null, ATTR_MODE, mode);

        out.endTag(null, TAG_AUTO_REVOKE_PERMISSIONS_MODE);

    }
@@ -3994,19 +3994,19 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub { 


            out.startTag(null, TAG_SESSION);



            writeIntAttribute(out, ATTR_SESSION_ID, sessionId);

            writeIntAttribute(out, ATTR_USER_ID, userId);

            out.attributeInt(null, ATTR_SESSION_ID, sessionId);

            out.attributeInt(null, ATTR_USER_ID, userId);

            writeStringAttribute(out, ATTR_INSTALLER_PACKAGE_NAME,

                    mInstallSource.installerPackageName);

            writeStringAttribute(out, ATTR_INSTALLER_ATTRIBUTION_TAG,

                    mInstallSource.installerAttributionTag);

            writeIntAttribute(out, ATTR_INSTALLER_UID, mInstallerUid);

            out.attributeInt(null, ATTR_INSTALLER_UID, mInstallerUid);

            writeStringAttribute(out, ATTR_INITIATING_PACKAGE_NAME,

                    mInstallSource.initiatingPackageName);

            writeStringAttribute(out, ATTR_ORIGINATING_PACKAGE_NAME,

                    mInstallSource.originatingPackageName);

            writeLongAttribute(out, ATTR_CREATED_MILLIS, createdMillis);

            writeLongAttribute(out, ATTR_UPDATED_MILLIS, updatedMillis);

            out.attributeLong(null, ATTR_CREATED_MILLIS, createdMillis);

            out.attributeLong(null, ATTR_UPDATED_MILLIS, updatedMillis);

            if (stageDir != null) {

                writeStringAttribute(out, ATTR_SESSION_STAGE_DIR,

                        stageDir.getAbsolutePath());
@@ -4024,29 +4024,29 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub { 
            writeBooleanAttribute(out, ATTR_IS_READY, mStagedSessionReady);

            writeBooleanAttribute(out, ATTR_IS_FAILED, mStagedSessionFailed);

            writeBooleanAttribute(out, ATTR_IS_APPLIED, mStagedSessionApplied);

            writeIntAttribute(out, ATTR_STAGED_SESSION_ERROR_CODE, mStagedSessionErrorCode);

            out.attributeInt(null, ATTR_STAGED_SESSION_ERROR_CODE, mStagedSessionErrorCode);

            writeStringAttribute(out, ATTR_STAGED_SESSION_ERROR_MESSAGE,

                    mStagedSessionErrorMessage);

            // TODO(patb,109941548): avoid writing to xml and instead infer / validate this after

            //                       we've read all sessions.

            writeIntAttribute(out, ATTR_PARENT_SESSION_ID, mParentSessionId);

            writeIntAttribute(out, ATTR_MODE, params.mode);

            writeIntAttribute(out, ATTR_INSTALL_FLAGS, params.installFlags);

            writeIntAttribute(out, ATTR_INSTALL_LOCATION, params.installLocation);

            writeLongAttribute(out, ATTR_SIZE_BYTES, params.sizeBytes);

            out.attributeInt(null, ATTR_PARENT_SESSION_ID, mParentSessionId);

            out.attributeInt(null, ATTR_MODE, params.mode);

            out.attributeInt(null, ATTR_INSTALL_FLAGS, params.installFlags);

            out.attributeInt(null, ATTR_INSTALL_LOCATION, params.installLocation);

            out.attributeLong(null, ATTR_SIZE_BYTES, params.sizeBytes);

            writeStringAttribute(out, ATTR_APP_PACKAGE_NAME, params.appPackageName);

            writeStringAttribute(out, ATTR_APP_LABEL, params.appLabel);

            writeUriAttribute(out, ATTR_ORIGINATING_URI, params.originatingUri);

            writeIntAttribute(out, ATTR_ORIGINATING_UID, params.originatingUid);

            out.attributeInt(null, ATTR_ORIGINATING_UID, params.originatingUid);

            writeUriAttribute(out, ATTR_REFERRER_URI, params.referrerUri);

            writeStringAttribute(out, ATTR_ABI_OVERRIDE, params.abiOverride);

            writeStringAttribute(out, ATTR_VOLUME_UUID, params.volumeUuid);

            writeIntAttribute(out, ATTR_INSTALL_REASON, params.installReason);

            out.attributeInt(null, ATTR_INSTALL_REASON, params.installReason);



            final boolean isDataLoader = params.dataLoaderParams != null;

            writeBooleanAttribute(out, ATTR_IS_DATALOADER, isDataLoader);

            if (isDataLoader) {

                writeIntAttribute(out, ATTR_DATALOADER_TYPE, params.dataLoaderParams.getType());

                out.attributeInt(null, ATTR_DATALOADER_TYPE, params.dataLoaderParams.getType());

                writeStringAttribute(out, ATTR_DATALOADER_PACKAGE_NAME,

                        params.dataLoaderParams.getComponentName().getPackageName());

                writeStringAttribute(out, ATTR_DATALOADER_CLASS_NAME,
@@ -4082,16 +4082,16 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub { 
            final int[] childSessionIds = getChildSessionIdsLocked();

            for (int childSessionId : childSessionIds) {

                out.startTag(null, TAG_CHILD_SESSION);

                writeIntAttribute(out, ATTR_SESSION_ID, childSessionId);

                out.attributeInt(null, ATTR_SESSION_ID, childSessionId);

                out.endTag(null, TAG_CHILD_SESSION);

            }



            final InstallationFile[] files = getInstallationFilesLocked();

            for (InstallationFile file : files) {

                out.startTag(null, TAG_SESSION_FILE);

                writeIntAttribute(out, ATTR_LOCATION, file.getLocation());

                out.attributeInt(null, ATTR_LOCATION, file.getLocation());

                writeStringAttribute(out, ATTR_NAME, file.getName());

                writeLongAttribute(out, ATTR_LENGTH_BYTES, file.getLengthBytes());

                out.attributeLong(null, ATTR_LENGTH_BYTES, file.getLengthBytes());

                writeByteArrayAttribute(out, ATTR_METADATA, file.getMetadata());

                writeByteArrayAttribute(out, ATTR_SIGNATURE, file.getSignature());

                out.endTag(null, TAG_SESSION_FILE);
@@ -4104,7 +4104,7 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub { 
                    CertifiedChecksum checksum = checksums.get(j);

                    out.startTag(null, TAG_SESSION_CHECKSUM);

                    writeStringAttribute(out, ATTR_NAME, fileName);

                    writeIntAttribute(out, ATTR_CHECKSUM_KIND, checksum.getChecksum().getType());

                    out.attributeInt(null, ATTR_CHECKSUM_KIND, checksum.getChecksum().getType());

                    writeByteArrayAttribute(out, ATTR_CHECKSUM_VALUE,

                            checksum.getChecksum().getValue());

                    writeStringAttribute(out, ATTR_CHECKSUM_PACKAGE, checksum.getPackageName());
@@ -4147,51 +4147,51 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub { 
            @NonNull StagingManager stagingManager, @NonNull File sessionsDir,

            @NonNull PackageSessionProvider sessionProvider)

            throws IOException, XmlPullParserException {

        final int sessionId = readIntAttribute(in, ATTR_SESSION_ID);

        final int userId = readIntAttribute(in, ATTR_USER_ID);

        final int sessionId = in.getAttributeInt(null, ATTR_SESSION_ID);

        final int userId = in.getAttributeInt(null, ATTR_USER_ID);

        final String installerPackageName = readStringAttribute(in, ATTR_INSTALLER_PACKAGE_NAME);

        final String installerAttributionTag = readStringAttribute(in,

                ATTR_INSTALLER_ATTRIBUTION_TAG);

        final int installerUid = readIntAttribute(in, ATTR_INSTALLER_UID, pm.getPackageUid(

        final int installerUid = in.getAttributeInt(null, ATTR_INSTALLER_UID, pm.getPackageUid(

                installerPackageName, PackageManager.MATCH_UNINSTALLED_PACKAGES, userId));

        final String installInitiatingPackageName =

                readStringAttribute(in, ATTR_INITIATING_PACKAGE_NAME);

        final String installOriginatingPackageName =

                readStringAttribute(in, ATTR_ORIGINATING_PACKAGE_NAME);

        final long createdMillis = readLongAttribute(in, ATTR_CREATED_MILLIS);

        long updatedMillis = readLongAttribute(in, ATTR_UPDATED_MILLIS);

        final long createdMillis = in.getAttributeLong(null, ATTR_CREATED_MILLIS);

        long updatedMillis = in.getAttributeLong(null, ATTR_UPDATED_MILLIS);

        final String stageDirRaw = readStringAttribute(in, ATTR_SESSION_STAGE_DIR);

        final File stageDir = (stageDirRaw != null) ? new File(stageDirRaw) : null;

        final String stageCid = readStringAttribute(in, ATTR_SESSION_STAGE_CID);

        final boolean prepared = readBooleanAttribute(in, ATTR_PREPARED, true);

        final boolean committed = readBooleanAttribute(in, ATTR_COMMITTED);

        final boolean destroyed = readBooleanAttribute(in, ATTR_DESTROYED);

        final boolean sealed = readBooleanAttribute(in, ATTR_SEALED);

        final int parentSessionId = readIntAttribute(in, ATTR_PARENT_SESSION_ID,

        final boolean prepared = in.getAttributeBoolean(null, ATTR_PREPARED, true);

        final boolean committed = in.getAttributeBoolean(null, ATTR_COMMITTED, false);

        final boolean destroyed = in.getAttributeBoolean(null, ATTR_DESTROYED, false);

        final boolean sealed = in.getAttributeBoolean(null, ATTR_SEALED, false);

        final int parentSessionId = in.getAttributeInt(null, ATTR_PARENT_SESSION_ID,

                SessionInfo.INVALID_ID);



        final SessionParams params = new SessionParams(

                SessionParams.MODE_INVALID);

        params.isMultiPackage = readBooleanAttribute(in, ATTR_MULTI_PACKAGE, false);

        params.isStaged = readBooleanAttribute(in, ATTR_STAGED_SESSION, false);

        params.mode = readIntAttribute(in, ATTR_MODE);

        params.installFlags = readIntAttribute(in, ATTR_INSTALL_FLAGS);

        params.installLocation = readIntAttribute(in, ATTR_INSTALL_LOCATION);

        params.sizeBytes = readLongAttribute(in, ATTR_SIZE_BYTES);

        params.isMultiPackage = in.getAttributeBoolean(null, ATTR_MULTI_PACKAGE, false);

        params.isStaged = in.getAttributeBoolean(null, ATTR_STAGED_SESSION, false);

        params.mode = in.getAttributeInt(null, ATTR_MODE);

        params.installFlags = in.getAttributeInt(null, ATTR_INSTALL_FLAGS);

        params.installLocation = in.getAttributeInt(null, ATTR_INSTALL_LOCATION);

        params.sizeBytes = in.getAttributeLong(null, ATTR_SIZE_BYTES);

        params.appPackageName = readStringAttribute(in, ATTR_APP_PACKAGE_NAME);

        params.appIcon = readBitmapAttribute(in, ATTR_APP_ICON);

        params.appLabel = readStringAttribute(in, ATTR_APP_LABEL);

        params.originatingUri = readUriAttribute(in, ATTR_ORIGINATING_URI);

        params.originatingUid =

                readIntAttribute(in, ATTR_ORIGINATING_UID, SessionParams.UID_UNKNOWN);

                in.getAttributeInt(null, ATTR_ORIGINATING_UID, SessionParams.UID_UNKNOWN);

        params.referrerUri = readUriAttribute(in, ATTR_REFERRER_URI);

        params.abiOverride = readStringAttribute(in, ATTR_ABI_OVERRIDE);

        params.volumeUuid = readStringAttribute(in, ATTR_VOLUME_UUID);

        params.installReason = readIntAttribute(in, ATTR_INSTALL_REASON);

        params.installReason = in.getAttributeInt(null, ATTR_INSTALL_REASON);



        if (readBooleanAttribute(in, ATTR_IS_DATALOADER)) {

        if (in.getAttributeBoolean(null, ATTR_IS_DATALOADER, false)) {

            params.dataLoaderParams = new DataLoaderParams(

                    readIntAttribute(in, ATTR_DATALOADER_TYPE),

                    in.getAttributeInt(null, ATTR_DATALOADER_TYPE),

                    new ComponentName(

                            readStringAttribute(in, ATTR_DATALOADER_PACKAGE_NAME),

                            readStringAttribute(in, ATTR_DATALOADER_CLASS_NAME)),
@@ -4203,10 +4203,10 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub { 
            params.appIcon = BitmapFactory.decodeFile(appIconFile.getAbsolutePath());

            params.appIconLastModified = appIconFile.lastModified();

        }

        final boolean isReady = readBooleanAttribute(in, ATTR_IS_READY);

        final boolean isFailed = readBooleanAttribute(in, ATTR_IS_FAILED);

        final boolean isApplied = readBooleanAttribute(in, ATTR_IS_APPLIED);

        final int stagedSessionErrorCode = readIntAttribute(in, ATTR_STAGED_SESSION_ERROR_CODE,

        final boolean isReady = in.getAttributeBoolean(null, ATTR_IS_READY, false);

        final boolean isFailed = in.getAttributeBoolean(null, ATTR_IS_FAILED, false);

        final boolean isApplied = in.getAttributeBoolean(null, ATTR_IS_APPLIED, false);

        final int stagedSessionErrorCode = in.getAttributeInt(null, ATTR_STAGED_SESSION_ERROR_CODE,

                SessionInfo.STAGED_SESSION_NO_ERROR);

        final String stagedSessionErrorMessage = readStringAttribute(in,

                ATTR_STAGED_SESSION_ERROR_MESSAGE);
@@ -4242,23 +4242,24 @@ public class PackageInstallerSession extends IPackageInstallerSession.Stub { 


            }

            if (TAG_AUTO_REVOKE_PERMISSIONS_MODE.equals(in.getName())) {

                autoRevokePermissionsMode = readIntAttribute(in, ATTR_MODE);

                autoRevokePermissionsMode = in.getAttributeInt(null, ATTR_MODE);

            }

            if (TAG_CHILD_SESSION.equals(in.getName())) {

                childSessionIds.add(readIntAttribute(in, ATTR_SESSION_ID, SessionInfo.INVALID_ID));

                childSessionIds.add(in.getAttributeInt(null, ATTR_SESSION_ID,

                        SessionInfo.INVALID_ID));

            }

            if (TAG_SESSION_FILE.equals(in.getName())) {

                files.add(new InstallationFile(

                        readIntAttribute(in, ATTR_LOCATION, 0),

                        in.getAttributeInt(null, ATTR_LOCATION, 0),

                        readStringAttribute(in, ATTR_NAME),

                        readLongAttribute(in, ATTR_LENGTH_BYTES, -1),

                        in.getAttributeLong(null, ATTR_LENGTH_BYTES, -1),

                        readByteArrayAttribute(in, ATTR_METADATA),

                        readByteArrayAttribute(in, ATTR_SIGNATURE)));

            }

            if (TAG_SESSION_CHECKSUM.equals(in.getName())) {

                final String fileName = readStringAttribute(in, ATTR_NAME);

                final CertifiedChecksum certifiedChecksum = new CertifiedChecksum(

                        new Checksum(readIntAttribute(in, ATTR_CHECKSUM_KIND, 0),

                        new Checksum(in.getAttributeInt(null, ATTR_CHECKSUM_KIND, 0),

                                readByteArrayAttribute(in, ATTR_CHECKSUM_VALUE)),

                        readStringAttribute(in, ATTR_CHECKSUM_PACKAGE),

                        readByteArrayAttribute(in, ATTR_CHECKSUM_CERTIFICATE));

services/core/java/com/android/server/pm/PackageSignatures.java

+6 −8
Original line number Diff line number Diff line
@@ -60,16 +60,14 @@ class PackageSignatures { 
            return;

        }

        serializer.startTag(null, tagName);

        serializer.attribute(null, "count", Integer.toString(mSigningDetails.signatures.length));

        serializer.attribute(null, "schemeVersion",

                Integer.toString(mSigningDetails.signatureSchemeVersion));

        serializer.attributeInt(null, "count", mSigningDetails.signatures.length);

        serializer.attributeInt(null, "schemeVersion", mSigningDetails.signatureSchemeVersion);

        writeCertsListXml(serializer, writtenSignatures, mSigningDetails.signatures, false);



        // if we have past signer certificate information, write it out

        if (mSigningDetails.pastSigningCertificates != null) {

            serializer.startTag(null, "pastSigs");

            serializer.attribute(null, "count",

                    Integer.toString(mSigningDetails.pastSigningCertificates.length));

            serializer.attributeInt(null, "count", mSigningDetails.pastSigningCertificates.length);

            writeCertsListXml(serializer, writtenSignatures,

                    mSigningDetails.pastSigningCertificates, true);

            serializer.endTag(null, "pastSigs");
@@ -89,19 +87,19 @@ class PackageSignatures { 
            for (j=0; j<numWritten; j++) {

                Signature writtenSig = writtenSignatures.get(j);

                if (writtenSig.hashCode() == sigHash && writtenSig.equals(sig)) {

                    serializer.attribute(null, "index", Integer.toString(j));

                    serializer.attributeInt(null, "index", j);

                    break;

                }

            }

            if (j >= numWritten) {

                writtenSignatures.add(sig);

                serializer.attribute(null, "index", Integer.toString(numWritten));

                serializer.attributeInt(null, "index", numWritten);

                serializer.attribute(null, "key", sig.toCharsString());

            }

            // The flags attribute is only written for previous signatures to represent the

            // capabilities the developer wants to grant to the previous signing certificates.

            if (isPastSigs) {

                serializer.attribute(null, "flags", Integer.toString(sig.getFlags()));

                serializer.attributeInt(null, "flags", sig.getFlags());

            }

            serializer.endTag(null, "cert");

        }