com/android/server/pm/ShortcutPackageInfo.java - platform/prebuilts/fullsdk/sources/android-28 - Git at Google

 /*
  * Copyright (C) 2016 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.server.pm;

 import android.annotation.NonNull;
 import android.annotation.UserIdInt;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManagerInternal;
 import android.content.pm.ShortcutInfo;
 import android.content.pm.Signature;
 import android.content.pm.SigningInfo;
 import android.util.Slog;

 import com.android.internal.annotations.VisibleForTesting;
 import com.android.server.LocalServices;
 import com.android.server.backup.BackupUtils;

 import libcore.util.HexEncoding;

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

 import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Base64;

 /**
  * Package information used by {@link android.content.pm.ShortcutManager} for backup / restore.
  *
  * All methods should be guarded by {@code ShortcutService.mLock}.
  */
 class ShortcutPackageInfo {
     private static final String TAG = ShortcutService.TAG;

     static final String TAG_ROOT = "package-info";
     private static final String ATTR_VERSION = "version";
     private static final String ATTR_LAST_UPDATE_TIME = "last_udpate_time";
     private static final String ATTR_BACKUP_SOURCE_VERSION = "bk_src_version";
     private static final String ATTR_BACKUP_ALLOWED = "allow-backup";
     private static final String ATTR_BACKUP_ALLOWED_INITIALIZED = "allow-backup-initialized";
     private static final String ATTR_BACKUP_SOURCE_BACKUP_ALLOWED = "bk_src_backup-allowed";
     private static final String ATTR_SHADOW = "shadow";

     private static final String TAG_SIGNATURE = "signature";
     private static final String ATTR_SIGNATURE_HASH = "hash";

     /**
      * When true, this package information was restored from the previous device, and the app hasn't
      * been installed yet.
      */
     private boolean mIsShadow;
     private long mVersionCode = ShortcutInfo.VERSION_CODE_UNKNOWN;
     private long mBackupSourceVersionCode = ShortcutInfo.VERSION_CODE_UNKNOWN;
     private long mLastUpdateTime;
     private ArrayList<byte[]> mSigHashes;

     // mBackupAllowed didn't used to be parsisted, so we don't restore it from a file.
     // mBackupAllowed will always start with false, and will have been updated before making a
     // backup next time, which works file.
     // We just don't want to print an uninitialzied mBackupAlldowed value on dumpsys, so
     // we use this boolean to control dumpsys.
     private boolean mBackupAllowedInitialized;
     private boolean mBackupAllowed;
     private boolean mBackupSourceBackupAllowed;

     private ShortcutPackageInfo(long versionCode, long lastUpdateTime,
             ArrayList<byte[]> sigHashes, boolean isShadow) {
         mVersionCode = versionCode;
         mLastUpdateTime = lastUpdateTime;
         mIsShadow = isShadow;
         mSigHashes = sigHashes;
         mBackupAllowed = false; // By default, we assume false.
         mBackupSourceBackupAllowed = false;
     }

     public static ShortcutPackageInfo newEmpty() {
         return new ShortcutPackageInfo(ShortcutInfo.VERSION_CODE_UNKNOWN, /* last update time =*/ 0,
                 new ArrayList<>(0), /* isShadow */ false);
     }

     public boolean isShadow() {
         return mIsShadow;
     }

     public void setShadow(boolean shadow) {
         mIsShadow = shadow;
     }

     public long getVersionCode() {
         return mVersionCode;
     }

     public long getBackupSourceVersionCode() {
         return mBackupSourceVersionCode;
     }

     @VisibleForTesting
     public boolean isBackupSourceBackupAllowed() {
         return mBackupSourceBackupAllowed;
     }

     public long getLastUpdateTime() {
         return mLastUpdateTime;
     }

     public boolean isBackupAllowed() {
         return mBackupAllowed;
     }

     /**
      * Set {@link #mVersionCode}, {@link #mLastUpdateTime} and {@link #mBackupAllowed}
      * from a {@link PackageInfo}.
      */
     public void updateFromPackageInfo(@NonNull PackageInfo pi) {
         if (pi != null) {
             mVersionCode = pi.getLongVersionCode();
             mLastUpdateTime = pi.lastUpdateTime;
             mBackupAllowed = ShortcutService.shouldBackupApp(pi);
             mBackupAllowedInitialized = true;
         }
     }

     public boolean hasSignatures() {
         return mSigHashes.size() > 0;
     }

     //@DisabledReason
     public int canRestoreTo(ShortcutService s, PackageInfo currentPackage, boolean anyVersionOkay) {
         PackageManagerInternal pmi = LocalServices.getService(PackageManagerInternal.class);
         if (!BackupUtils.signaturesMatch(mSigHashes, currentPackage, pmi)) {
             Slog.w(TAG, "Can't restore: Package signature mismatch");
             return ShortcutInfo.DISABLED_REASON_SIGNATURE_MISMATCH;
         }
         if (!ShortcutService.shouldBackupApp(currentPackage) || !mBackupSourceBackupAllowed) {
             // "allowBackup" was true when backed up, but now false.
             Slog.w(TAG, "Can't restore: package didn't or doesn't allow backup");
             return ShortcutInfo.DISABLED_REASON_BACKUP_NOT_SUPPORTED;
         }
         if (!anyVersionOkay && (currentPackage.getLongVersionCode() < mBackupSourceVersionCode)) {
             Slog.w(TAG, String.format(
                     "Can't restore: package current version %d < backed up version %d",
                     currentPackage.getLongVersionCode(), mBackupSourceVersionCode));
             return ShortcutInfo.DISABLED_REASON_VERSION_LOWER;
         }
         return ShortcutInfo.DISABLED_REASON_NOT_DISABLED;
     }

     @VisibleForTesting
     public static ShortcutPackageInfo generateForInstalledPackageForTest(
             ShortcutService s, String packageName, @UserIdInt int packageUserId) {
         final PackageInfo pi = s.getPackageInfoWithSignatures(packageName, packageUserId);
         // retrieve the newest sigs
         SigningInfo signingInfo = pi.signingInfo;
         if (signingInfo == null) {
             Slog.e(TAG, "Can't get signatures: package=" + packageName);
             return null;
         }
         // TODO (b/73988180) use entire signing history in case of rollbacks
         Signature[] signatures = signingInfo.getApkContentsSigners();
         final ShortcutPackageInfo ret = new ShortcutPackageInfo(pi.getLongVersionCode(),
                 pi.lastUpdateTime, BackupUtils.hashSignatureArray(signatures), /* shadow=*/ false);

         ret.mBackupSourceBackupAllowed = s.shouldBackupApp(pi);
         ret.mBackupSourceVersionCode = pi.getLongVersionCode();
         return ret;
     }

     public void refreshSignature(ShortcutService s, ShortcutPackageItem pkg) {
         if (mIsShadow) {
             s.wtf("Attempted to refresh package info for shadow package " + pkg.getPackageName()
                     + ", user=" + pkg.getOwnerUserId());
             return;
         }
         // Note use mUserId here, rather than userId.
         final PackageInfo pi = s.getPackageInfoWithSignatures(
                 pkg.getPackageName(), pkg.getPackageUserId());
         if (pi == null) {
             Slog.w(TAG, "Package not found: " + pkg.getPackageName());
             return;
         }
         // retrieve the newest sigs
         SigningInfo signingInfo = pi.signingInfo;
         if (signingInfo == null) {
             Slog.w(TAG, "Not refreshing signature for " + pkg.getPackageName()
                     + " since it appears to have no signing info.");
             return;
         }
         // TODO (b/73988180) use entire signing history in case of rollbacks
         Signature[] signatures = signingInfo.getApkContentsSigners();
         mSigHashes = BackupUtils.hashSignatureArray(signatures);
     }

     public void saveToXml(ShortcutService s, XmlSerializer out, boolean forBackup)
             throws IOException {
         if (forBackup && !mBackupAllowedInitialized) {
             s.wtf("Backup happened before mBackupAllowed is initialized.");
         }

         out.startTag(null, TAG_ROOT);

         ShortcutService.writeAttr(out, ATTR_VERSION, mVersionCode);
         ShortcutService.writeAttr(out, ATTR_LAST_UPDATE_TIME, mLastUpdateTime);
         ShortcutService.writeAttr(out, ATTR_SHADOW, mIsShadow);
         ShortcutService.writeAttr(out, ATTR_BACKUP_ALLOWED, mBackupAllowed);

         // We don't need to save this field (we don't even read it back), but it'll show up
         // in the dumpsys in the backup / restore payload.
         ShortcutService.writeAttr(out, ATTR_BACKUP_ALLOWED_INITIALIZED, mBackupAllowedInitialized);

         ShortcutService.writeAttr(out, ATTR_BACKUP_SOURCE_VERSION, mBackupSourceVersionCode);
         ShortcutService.writeAttr(out,
                 ATTR_BACKUP_SOURCE_BACKUP_ALLOWED, mBackupSourceBackupAllowed);


         for (int i = 0; i < mSigHashes.size(); i++) {
             out.startTag(null, TAG_SIGNATURE);
             final String encoded = Base64.getEncoder().encodeToString(mSigHashes.get(i));
             ShortcutService.writeAttr(out, ATTR_SIGNATURE_HASH, encoded);
             out.endTag(null, TAG_SIGNATURE);
         }
         out.endTag(null, TAG_ROOT);
     }

     public void loadFromXml(XmlPullParser parser, boolean fromBackup)
             throws IOException, XmlPullParserException {
         // Don't use the version code from the backup file.
         final long versionCode = ShortcutService.parseLongAttribute(parser, ATTR_VERSION,
                 ShortcutInfo.VERSION_CODE_UNKNOWN);

         final long lastUpdateTime = ShortcutService.parseLongAttribute(
                 parser, ATTR_LAST_UPDATE_TIME);

         // When restoring from backup, it's always shadow.
         final boolean shadow =
                 fromBackup || ShortcutService.parseBooleanAttribute(parser, ATTR_SHADOW);

         // We didn't used to save these attributes, and all backed up shortcuts were from
         // apps that support backups, so the default values take this fact into consideration.
         final long backupSourceVersion = ShortcutService.parseLongAttribute(parser,
                 ATTR_BACKUP_SOURCE_VERSION, ShortcutInfo.VERSION_CODE_UNKNOWN);

         // Note the only time these "true" default value is used is when restoring from an old
         // build that didn't save ATTR_BACKUP_ALLOWED, and that means all the data included in
         // a backup file were from apps that support backup, so we can just use "true" as the
         // default.
         final boolean backupAllowed = ShortcutService.parseBooleanAttribute(
                 parser, ATTR_BACKUP_ALLOWED, true);
         final boolean backupSourceBackupAllowed = ShortcutService.parseBooleanAttribute(
                 parser, ATTR_BACKUP_SOURCE_BACKUP_ALLOWED, true);

         final ArrayList<byte[]> hashes = new ArrayList<>();

         final int outerDepth = parser.getDepth();
         int type;
         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
                 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
             if (type != XmlPullParser.START_TAG) {
                 continue;
             }
             final int depth = parser.getDepth();
             final String tag = parser.getName();

             if (depth == outerDepth + 1) {
                 switch (tag) {
                     case TAG_SIGNATURE: {
                         final String hash = ShortcutService.parseStringAttribute(
                                 parser, ATTR_SIGNATURE_HASH);
                         // Throws IllegalArgumentException if hash is invalid base64 data
                         final byte[] decoded = Base64.getDecoder().decode(hash);
                         hashes.add(decoded);
                         continue;
                     }
                 }
             }
             ShortcutService.warnForInvalidTag(depth, tag);
         }

         // Successfully loaded; replace the fields.
         if (fromBackup) {
             mVersionCode = ShortcutInfo.VERSION_CODE_UNKNOWN;
             mBackupSourceVersionCode = versionCode;
             mBackupSourceBackupAllowed = backupAllowed;
         } else {
             mVersionCode = versionCode;
             mBackupSourceVersionCode = backupSourceVersion;
             mBackupSourceBackupAllowed = backupSourceBackupAllowed;
         }
         mLastUpdateTime = lastUpdateTime;
         mIsShadow = shadow;
         mSigHashes = hashes;

         // Note we don't restore it from the file because it didn't used to be saved.
         // We always start by assuming backup is disabled for the current package,
         // and this field will have been updated before we actually create a backup, at the same
         // time when we update the version code.
         // Until then, the value of mBackupAllowed shouldn't matter, but we don't want to print
         // a false flag on dumpsys, so set mBackupAllowedInitialized to false.
         mBackupAllowed = false;
         mBackupAllowedInitialized = false;
     }

     public void dump(PrintWriter pw, String prefix) {
         pw.println();

         pw.print(prefix);
         pw.println("PackageInfo:");

         pw.print(prefix);
         pw.print("  IsShadow: ");
         pw.print(mIsShadow);
         pw.print(mIsShadow ? " (not installed)" : " (installed)");
         pw.println();

         pw.print(prefix);
         pw.print("  Version: ");
         pw.print(mVersionCode);
         pw.println();

         if (mBackupAllowedInitialized) {
             pw.print(prefix);
             pw.print("  Backup Allowed: ");
             pw.print(mBackupAllowed);
             pw.println();
         }

         if (mBackupSourceVersionCode != ShortcutInfo.VERSION_CODE_UNKNOWN) {
             pw.print(prefix);
             pw.print("  Backup source version: ");
             pw.print(mBackupSourceVersionCode);
             pw.println();

             pw.print(prefix);
             pw.print("  Backup source backup allowed: ");
             pw.print(mBackupSourceBackupAllowed);
             pw.println();
         }

         pw.print(prefix);
         pw.print("  Last package update time: ");
         pw.print(mLastUpdateTime);
         pw.println();

         for (int i = 0; i < mSigHashes.size(); i++) {
             pw.print(prefix);
             pw.print("    ");
             pw.print("SigHash: ");
             pw.println(HexEncoding.encode(mSigHashes.get(i)));
         }
     }
 }
	/*
	* Copyright (C) 2016 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.server.pm;

	import android.annotation.NonNull;
	import android.annotation.UserIdInt;
	import android.content.pm.PackageInfo;
	import android.content.pm.PackageManagerInternal;
	import android.content.pm.ShortcutInfo;
	import android.content.pm.Signature;
	import android.content.pm.SigningInfo;
	import android.util.Slog;

	import com.android.internal.annotations.VisibleForTesting;
	import com.android.server.LocalServices;
	import com.android.server.backup.BackupUtils;

	import libcore.util.HexEncoding;

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

	import java.io.IOException;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Base64;

	/**
	* Package information used by {@link android.content.pm.ShortcutManager} for backup / restore.
	*
	* All methods should be guarded by {@code ShortcutService.mLock}.
	*/
	class ShortcutPackageInfo {
	private static final String TAG = ShortcutService.TAG;

	static final String TAG_ROOT = "package-info";
	private static final String ATTR_VERSION = "version";
	private static final String ATTR_LAST_UPDATE_TIME = "last_udpate_time";
	private static final String ATTR_BACKUP_SOURCE_VERSION = "bk_src_version";
	private static final String ATTR_BACKUP_ALLOWED = "allow-backup";
	private static final String ATTR_BACKUP_ALLOWED_INITIALIZED = "allow-backup-initialized";
	private static final String ATTR_BACKUP_SOURCE_BACKUP_ALLOWED = "bk_src_backup-allowed";
	private static final String ATTR_SHADOW = "shadow";

	private static final String TAG_SIGNATURE = "signature";
	private static final String ATTR_SIGNATURE_HASH = "hash";

	/**
	* When true, this package information was restored from the previous device, and the app hasn't
	* been installed yet.
	*/
	private boolean mIsShadow;
	private long mVersionCode = ShortcutInfo.VERSION_CODE_UNKNOWN;
	private long mBackupSourceVersionCode = ShortcutInfo.VERSION_CODE_UNKNOWN;
	private long mLastUpdateTime;
	private ArrayList<byte[]> mSigHashes;

	// mBackupAllowed didn't used to be parsisted, so we don't restore it from a file.
	// mBackupAllowed will always start with false, and will have been updated before making a
	// backup next time, which works file.
	// We just don't want to print an uninitialzied mBackupAlldowed value on dumpsys, so
	// we use this boolean to control dumpsys.
	private boolean mBackupAllowedInitialized;
	private boolean mBackupAllowed;
	private boolean mBackupSourceBackupAllowed;

	private ShortcutPackageInfo(long versionCode, long lastUpdateTime,
	ArrayList<byte[]> sigHashes, boolean isShadow) {
	mVersionCode = versionCode;
	mLastUpdateTime = lastUpdateTime;
	mIsShadow = isShadow;
	mSigHashes = sigHashes;
	mBackupAllowed = false; // By default, we assume false.
	mBackupSourceBackupAllowed = false;
	}

	public static ShortcutPackageInfo newEmpty() {
	return new ShortcutPackageInfo(ShortcutInfo.VERSION_CODE_UNKNOWN, /* last update time =*/ 0,
	new ArrayList<>(0), /* isShadow */ false);
	}

	public boolean isShadow() {
	return mIsShadow;
	}

	public void setShadow(boolean shadow) {
	mIsShadow = shadow;
	}

	public long getVersionCode() {
	return mVersionCode;
	}

	public long getBackupSourceVersionCode() {
	return mBackupSourceVersionCode;
	}

	@VisibleForTesting
	public boolean isBackupSourceBackupAllowed() {
	return mBackupSourceBackupAllowed;
	}

	public long getLastUpdateTime() {
	return mLastUpdateTime;
	}

	public boolean isBackupAllowed() {
	return mBackupAllowed;
	}

	/**
	* Set {@link #mVersionCode}, {@link #mLastUpdateTime} and {@link #mBackupAllowed}
	* from a {@link PackageInfo}.
	*/
	public void updateFromPackageInfo(@NonNull PackageInfo pi) {
	if (pi != null) {
	mVersionCode = pi.getLongVersionCode();
	mLastUpdateTime = pi.lastUpdateTime;
	mBackupAllowed = ShortcutService.shouldBackupApp(pi);
	mBackupAllowedInitialized = true;
	}
	}

	public boolean hasSignatures() {
	return mSigHashes.size() > 0;
	}

	//@DisabledReason
	public int canRestoreTo(ShortcutService s, PackageInfo currentPackage, boolean anyVersionOkay) {
	PackageManagerInternal pmi = LocalServices.getService(PackageManagerInternal.class);
	if (!BackupUtils.signaturesMatch(mSigHashes, currentPackage, pmi)) {
	Slog.w(TAG, "Can't restore: Package signature mismatch");
	return ShortcutInfo.DISABLED_REASON_SIGNATURE_MISMATCH;
	}
	if (!ShortcutService.shouldBackupApp(currentPackage) \|\| !mBackupSourceBackupAllowed) {
	// "allowBackup" was true when backed up, but now false.
	Slog.w(TAG, "Can't restore: package didn't or doesn't allow backup");
	return ShortcutInfo.DISABLED_REASON_BACKUP_NOT_SUPPORTED;
	}
	if (!anyVersionOkay && (currentPackage.getLongVersionCode() < mBackupSourceVersionCode)) {
	Slog.w(TAG, String.format(
	"Can't restore: package current version %d < backed up version %d",
	currentPackage.getLongVersionCode(), mBackupSourceVersionCode));
	return ShortcutInfo.DISABLED_REASON_VERSION_LOWER;
	}
	return ShortcutInfo.DISABLED_REASON_NOT_DISABLED;
	}

	@VisibleForTesting
	public static ShortcutPackageInfo generateForInstalledPackageForTest(
	ShortcutService s, String packageName, @UserIdInt int packageUserId) {
	final PackageInfo pi = s.getPackageInfoWithSignatures(packageName, packageUserId);
	// retrieve the newest sigs
	SigningInfo signingInfo = pi.signingInfo;
	if (signingInfo == null) {
	Slog.e(TAG, "Can't get signatures: package=" + packageName);
	return null;
	}
	// TODO (b/73988180) use entire signing history in case of rollbacks
	Signature[] signatures = signingInfo.getApkContentsSigners();
	final ShortcutPackageInfo ret = new ShortcutPackageInfo(pi.getLongVersionCode(),
	pi.lastUpdateTime, BackupUtils.hashSignatureArray(signatures), /* shadow=*/ false);

	ret.mBackupSourceBackupAllowed = s.shouldBackupApp(pi);
	ret.mBackupSourceVersionCode = pi.getLongVersionCode();
	return ret;
	}

	public void refreshSignature(ShortcutService s, ShortcutPackageItem pkg) {
	if (mIsShadow) {
	s.wtf("Attempted to refresh package info for shadow package " + pkg.getPackageName()
	+ ", user=" + pkg.getOwnerUserId());
	return;
	}
	// Note use mUserId here, rather than userId.
	final PackageInfo pi = s.getPackageInfoWithSignatures(
	pkg.getPackageName(), pkg.getPackageUserId());
	if (pi == null) {
	Slog.w(TAG, "Package not found: " + pkg.getPackageName());
	return;
	}
	// retrieve the newest sigs
	SigningInfo signingInfo = pi.signingInfo;
	if (signingInfo == null) {
	Slog.w(TAG, "Not refreshing signature for " + pkg.getPackageName()
	+ " since it appears to have no signing info.");
	return;
	}
	// TODO (b/73988180) use entire signing history in case of rollbacks
	Signature[] signatures = signingInfo.getApkContentsSigners();
	mSigHashes = BackupUtils.hashSignatureArray(signatures);
	}

	public void saveToXml(ShortcutService s, XmlSerializer out, boolean forBackup)
	throws IOException {
	if (forBackup && !mBackupAllowedInitialized) {
	s.wtf("Backup happened before mBackupAllowed is initialized.");
	}

	out.startTag(null, TAG_ROOT);

	ShortcutService.writeAttr(out, ATTR_VERSION, mVersionCode);
	ShortcutService.writeAttr(out, ATTR_LAST_UPDATE_TIME, mLastUpdateTime);
	ShortcutService.writeAttr(out, ATTR_SHADOW, mIsShadow);
	ShortcutService.writeAttr(out, ATTR_BACKUP_ALLOWED, mBackupAllowed);

	// We don't need to save this field (we don't even read it back), but it'll show up
	// in the dumpsys in the backup / restore payload.
	ShortcutService.writeAttr(out, ATTR_BACKUP_ALLOWED_INITIALIZED, mBackupAllowedInitialized);

	ShortcutService.writeAttr(out, ATTR_BACKUP_SOURCE_VERSION, mBackupSourceVersionCode);
	ShortcutService.writeAttr(out,
	ATTR_BACKUP_SOURCE_BACKUP_ALLOWED, mBackupSourceBackupAllowed);


	for (int i = 0; i < mSigHashes.size(); i++) {
	out.startTag(null, TAG_SIGNATURE);
	final String encoded = Base64.getEncoder().encodeToString(mSigHashes.get(i));
	ShortcutService.writeAttr(out, ATTR_SIGNATURE_HASH, encoded);
	out.endTag(null, TAG_SIGNATURE);
	}
	out.endTag(null, TAG_ROOT);
	}

	public void loadFromXml(XmlPullParser parser, boolean fromBackup)
	throws IOException, XmlPullParserException {
	// Don't use the version code from the backup file.
	final long versionCode = ShortcutService.parseLongAttribute(parser, ATTR_VERSION,
	ShortcutInfo.VERSION_CODE_UNKNOWN);

	final long lastUpdateTime = ShortcutService.parseLongAttribute(
	parser, ATTR_LAST_UPDATE_TIME);

	// When restoring from backup, it's always shadow.
	final boolean shadow =
	fromBackup \|\| ShortcutService.parseBooleanAttribute(parser, ATTR_SHADOW);

	// We didn't used to save these attributes, and all backed up shortcuts were from
	// apps that support backups, so the default values take this fact into consideration.
	final long backupSourceVersion = ShortcutService.parseLongAttribute(parser,
	ATTR_BACKUP_SOURCE_VERSION, ShortcutInfo.VERSION_CODE_UNKNOWN);

	// Note the only time these "true" default value is used is when restoring from an old
	// build that didn't save ATTR_BACKUP_ALLOWED, and that means all the data included in
	// a backup file were from apps that support backup, so we can just use "true" as the
	// default.
	final boolean backupAllowed = ShortcutService.parseBooleanAttribute(
	parser, ATTR_BACKUP_ALLOWED, true);
	final boolean backupSourceBackupAllowed = ShortcutService.parseBooleanAttribute(
	parser, ATTR_BACKUP_SOURCE_BACKUP_ALLOWED, true);

	final ArrayList<byte[]> hashes = new ArrayList<>();

	final int outerDepth = parser.getDepth();
	int type;
	while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
	&& (type != XmlPullParser.END_TAG \|\| parser.getDepth() > outerDepth)) {
	if (type != XmlPullParser.START_TAG) {
	continue;
	}
	final int depth = parser.getDepth();
	final String tag = parser.getName();

	if (depth == outerDepth + 1) {
	switch (tag) {
	case TAG_SIGNATURE: {
	final String hash = ShortcutService.parseStringAttribute(
	parser, ATTR_SIGNATURE_HASH);
	// Throws IllegalArgumentException if hash is invalid base64 data
	final byte[] decoded = Base64.getDecoder().decode(hash);
	hashes.add(decoded);
	continue;
	}
	}
	}
	ShortcutService.warnForInvalidTag(depth, tag);
	}

	// Successfully loaded; replace the fields.
	if (fromBackup) {
	mVersionCode = ShortcutInfo.VERSION_CODE_UNKNOWN;
	mBackupSourceVersionCode = versionCode;
	mBackupSourceBackupAllowed = backupAllowed;
	} else {
	mVersionCode = versionCode;
	mBackupSourceVersionCode = backupSourceVersion;
	mBackupSourceBackupAllowed = backupSourceBackupAllowed;
	}
	mLastUpdateTime = lastUpdateTime;
	mIsShadow = shadow;
	mSigHashes = hashes;

	// Note we don't restore it from the file because it didn't used to be saved.
	// We always start by assuming backup is disabled for the current package,
	// and this field will have been updated before we actually create a backup, at the same
	// time when we update the version code.
	// Until then, the value of mBackupAllowed shouldn't matter, but we don't want to print
	// a false flag on dumpsys, so set mBackupAllowedInitialized to false.
	mBackupAllowed = false;
	mBackupAllowedInitialized = false;
	}

	public void dump(PrintWriter pw, String prefix) {
	pw.println();

	pw.print(prefix);
	pw.println("PackageInfo:");

	pw.print(prefix);
	pw.print(" IsShadow: ");
	pw.print(mIsShadow);
	pw.print(mIsShadow ? " (not installed)" : " (installed)");
	pw.println();

	pw.print(prefix);
	pw.print(" Version: ");
	pw.print(mVersionCode);
	pw.println();

	if (mBackupAllowedInitialized) {
	pw.print(prefix);
	pw.print(" Backup Allowed: ");
	pw.print(mBackupAllowed);
	pw.println();
	}

	if (mBackupSourceVersionCode != ShortcutInfo.VERSION_CODE_UNKNOWN) {
	pw.print(prefix);
	pw.print(" Backup source version: ");
	pw.print(mBackupSourceVersionCode);
	pw.println();

	pw.print(prefix);
	pw.print(" Backup source backup allowed: ");
	pw.print(mBackupSourceBackupAllowed);
	pw.println();
	}

	pw.print(prefix);
	pw.print(" Last package update time: ");
	pw.print(mLastUpdateTime);
	pw.println();

	for (int i = 0; i < mSigHashes.size(); i++) {
	pw.print(prefix);
	pw.print(" ");
	pw.print("SigHash: ");
	pw.println(HexEncoding.encode(mSigHashes.get(i)));
	}
	}
	}