diff --git a/api/system-current.txt b/api/system-current.txt index 2bd06bdcb2efa..2cdad1bdd36f6 100644 --- a/api/system-current.txt +++ b/api/system-current.txt @@ -1672,18 +1672,12 @@ package android.content.pm.permission { package android.content.rollback { public final class PackageRollbackInfo implements android.os.Parcelable { - ctor public PackageRollbackInfo(String, android.content.rollback.PackageRollbackInfo.PackageVersion, android.content.rollback.PackageRollbackInfo.PackageVersion); method public int describeContents(); + method public String getPackageName(); + method public android.content.pm.VersionedPackage getVersionRolledBackFrom(); + method public android.content.pm.VersionedPackage getVersionRolledBackTo(); method public void writeToParcel(android.os.Parcel, int); field public static final android.os.Parcelable.Creator CREATOR; - field public final android.content.rollback.PackageRollbackInfo.PackageVersion higherVersion; - field public final android.content.rollback.PackageRollbackInfo.PackageVersion lowerVersion; - field public final String packageName; - } - - public static class PackageRollbackInfo.PackageVersion { - ctor public PackageRollbackInfo.PackageVersion(long); - field public final long versionCode; } public final class RollbackInfo implements android.os.Parcelable { diff --git a/core/java/android/content/rollback/PackageRollbackInfo.java b/core/java/android/content/rollback/PackageRollbackInfo.java index 204002426d173..4644a83de4623 100644 --- a/core/java/android/content/rollback/PackageRollbackInfo.java +++ b/core/java/android/content/rollback/PackageRollbackInfo.java @@ -17,11 +17,10 @@ package android.content.rollback; import android.annotation.SystemApi; +import android.content.pm.VersionedPackage; import android.os.Parcel; import android.os.Parcelable; -import java.util.Objects; - /** * Information about a rollback available for a particular package. * @@ -29,59 +28,41 @@ import java.util.Objects; */ @SystemApi public final class PackageRollbackInfo implements Parcelable { - /** - * The name of a package being rolled back. - */ - public final String packageName; + + private final VersionedPackage mVersionRolledBackFrom; + private final VersionedPackage mVersionRolledBackTo; /** - * The version the package was rolled back from. + * Returns the name of the package to roll back from. */ - public final PackageVersion higherVersion; - - /** - * The version the package was rolled back to. - */ - public final PackageVersion lowerVersion; - - /** - * Represents a version of a package. - */ - public static class PackageVersion { - public final long versionCode; - - // TODO(b/120200473): Include apk sha or some other way to distinguish - // between two different apks with the same version code. - public PackageVersion(long versionCode) { - this.versionCode = versionCode; - } - - @Override - public boolean equals(Object other) { - if (other instanceof PackageVersion) { - PackageVersion otherVersion = (PackageVersion) other; - return versionCode == otherVersion.versionCode; - } - return false; - } - - @Override - public int hashCode() { - return Objects.hash(versionCode); - } + public String getPackageName() { + return mVersionRolledBackFrom.getPackageName(); } - public PackageRollbackInfo(String packageName, - PackageVersion higherVersion, PackageVersion lowerVersion) { - this.packageName = packageName; - this.higherVersion = higherVersion; - this.lowerVersion = lowerVersion; + /** + * Returns the version of the package rolled back from. + */ + public VersionedPackage getVersionRolledBackFrom() { + return mVersionRolledBackFrom; + } + + /** + * Returns the version of the package rolled back to. + */ + public VersionedPackage getVersionRolledBackTo() { + return mVersionRolledBackTo; + } + + /** @hide */ + public PackageRollbackInfo(VersionedPackage packageRolledBackFrom, + VersionedPackage packageRolledBackTo) { + this.mVersionRolledBackFrom = packageRolledBackFrom; + this.mVersionRolledBackTo = packageRolledBackTo; } private PackageRollbackInfo(Parcel in) { - this.packageName = in.readString(); - this.higherVersion = new PackageVersion(in.readLong()); - this.lowerVersion = new PackageVersion(in.readLong()); + this.mVersionRolledBackFrom = VersionedPackage.CREATOR.createFromParcel(in); + this.mVersionRolledBackTo = VersionedPackage.CREATOR.createFromParcel(in); } @Override @@ -91,9 +72,8 @@ public final class PackageRollbackInfo implements Parcelable { @Override public void writeToParcel(Parcel out, int flags) { - out.writeString(packageName); - out.writeLong(higherVersion.versionCode); - out.writeLong(lowerVersion.versionCode); + mVersionRolledBackFrom.writeToParcel(out, flags); + mVersionRolledBackTo.writeToParcel(out, flags); } public static final Parcelable.Creator CREATOR = diff --git a/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java b/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java index 0b0f1dca98d38..2b76d00481820 100644 --- a/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java +++ b/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java @@ -32,6 +32,7 @@ import android.content.pm.PackageManagerInternal; import android.content.pm.PackageParser; import android.content.pm.ParceledListSlice; import android.content.pm.StringParceledListSlice; +import android.content.pm.VersionedPackage; import android.content.rollback.IRollbackManager; import android.content.rollback.PackageRollbackInfo; import android.content.rollback.RollbackInfo; @@ -219,7 +220,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { // it's out of date or not, so no need to check package versions here. for (PackageRollbackInfo info : data.packages) { - if (info.packageName.equals(packageName)) { + if (info.getPackageName().equals(packageName)) { // TODO: Once the RollbackInfo API supports info about // dependant packages, add that info here. return new RollbackInfo(data.rollbackId, info); @@ -240,7 +241,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { for (int i = 0; i < mAvailableRollbacks.size(); ++i) { RollbackData data = mAvailableRollbacks.get(i); for (PackageRollbackInfo info : data.packages) { - packageNames.add(info.packageName); + packageNames.add(info.getPackageName()); } } } @@ -282,7 +283,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { */ private void executeRollbackInternal(RollbackInfo rollback, String callerPackageName, IntentSender statusReceiver) { - String targetPackageName = rollback.targetPackage.packageName; + String targetPackageName = rollback.targetPackage.getPackageName(); Log.i(TAG, "Initiating rollback of " + targetPackageName); // Get the latest RollbackData for the target package. @@ -306,15 +307,14 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { // Figure out how to ensure we don't commit the rollback if // roll forward happens at the same time. for (PackageRollbackInfo info : data.packages) { - PackageRollbackInfo.PackageVersion installedVersion = - getInstalledPackageVersion(info.packageName); + VersionedPackage installedVersion = getInstalledPackageVersion(info.getPackageName()); if (installedVersion == null) { // TODO: Test this case sendFailure(statusReceiver, "Package to roll back is not installed"); return; } - if (!info.higherVersion.equals(installedVersion)) { + if (!packageVersionsEqual(info.getVersionRolledBackFrom(), installedVersion)) { // TODO: Test this case sendFailure(statusReceiver, "Package version to roll back not installed."); return; @@ -357,7 +357,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { // TODO: Will it always be called "base.apk"? What about splits? // What about apex? - File packageDir = new File(data.backupDir, info.packageName); + File packageDir = new File(data.backupDir, info.getPackageName()); File baseApk = new File(packageDir, "base.apk"); try (ParcelFileDescriptor fd = ParcelFileDescriptor.open(baseApk, ParcelFileDescriptor.MODE_READ_ONLY)) { @@ -431,7 +431,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { while (iter.hasNext()) { RollbackData data = iter.next(); for (PackageRollbackInfo info : data.packages) { - if (info.packageName.equals(packageName)) { + if (info.getPackageName().equals(packageName)) { iter.remove(); mRollbackStore.deleteAvailableRollback(data); break; @@ -493,8 +493,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { private void onPackageReplaced(String packageName) { // TODO: Could this end up incorrectly deleting a rollback for a // package that is about to be installed? - PackageRollbackInfo.PackageVersion installedVersion = - getInstalledPackageVersion(packageName); + VersionedPackage installedVersion = getInstalledPackageVersion(packageName); synchronized (mLock) { ensureRollbackDataLoadedLocked(); @@ -502,8 +501,10 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { while (iter.hasNext()) { RollbackData data = iter.next(); for (PackageRollbackInfo info : data.packages) { - if (info.packageName.equals(packageName) - && !info.higherVersion.equals(installedVersion)) { + if (info.getPackageName().equals(packageName) + && !packageVersionsEqual( + info.getVersionRolledBackFrom(), + installedVersion)) { iter.remove(); mRollbackStore.deleteAvailableRollback(data); break; @@ -526,7 +527,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { boolean changed = false; while (iter.hasNext()) { RollbackInfo rollback = iter.next(); - if (packageName.equals(rollback.targetPackage.packageName)) { + if (packageName.equals(rollback.targetPackage.getPackageName())) { iter.remove(); changed = true; } @@ -701,8 +702,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { return false; } - PackageRollbackInfo.PackageVersion newVersion = - new PackageRollbackInfo.PackageVersion(newPackage.versionCode); + VersionedPackage newVersion = new VersionedPackage(packageName, newPackage.versionCode); // Get information about the currently installed package. PackageManagerInternal pm = LocalServices.getService(PackageManagerInternal.class); @@ -713,8 +713,8 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { Log.e(TAG, packageName + " is not installed"); return false; } - PackageRollbackInfo.PackageVersion installedVersion = - new PackageRollbackInfo.PackageVersion(installedPackage.getLongVersionCode()); + VersionedPackage installedVersion = new VersionedPackage(packageName, + installedPackage.getLongVersionCode()); for (int user : installedUsers) { final int storageFlags; @@ -735,8 +735,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { } } - PackageRollbackInfo info = new PackageRollbackInfo( - packageName, newVersion, installedVersion); + PackageRollbackInfo info = new PackageRollbackInfo(newVersion, installedVersion); RollbackData data; try { @@ -832,7 +831,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { * Gets the version of the package currently installed. * Returns null if the package is not currently installed. */ - private PackageRollbackInfo.PackageVersion getInstalledPackageVersion(String packageName) { + private VersionedPackage getInstalledPackageVersion(String packageName) { PackageManager pm = mContext.getPackageManager(); PackageInfo pkgInfo = null; try { @@ -841,7 +840,12 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { return null; } - return new PackageRollbackInfo.PackageVersion(pkgInfo.getLongVersionCode()); + return new VersionedPackage(packageName, pkgInfo.getLongVersionCode()); + } + + private boolean packageVersionsEqual(VersionedPackage a, VersionedPackage b) { + return a.getPackageName().equals(b.getPackageName()) + && a.getLongVersionCode() == b.getLongVersionCode(); } private class SessionCallback extends PackageInstaller.SessionCallback { @@ -917,7 +921,7 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub { for (int i = 0; i < mAvailableRollbacks.size(); ++i) { RollbackData data = mAvailableRollbacks.get(i); for (PackageRollbackInfo info : data.packages) { - if (info.packageName.equals(packageName)) { + if (info.getPackageName().equals(packageName)) { return data; } } diff --git a/services/core/java/com/android/server/rollback/RollbackStore.java b/services/core/java/com/android/server/rollback/RollbackStore.java index 52208597af2b5..7738be9d32bbc 100644 --- a/services/core/java/com/android/server/rollback/RollbackStore.java +++ b/services/core/java/com/android/server/rollback/RollbackStore.java @@ -16,6 +16,7 @@ package com.android.server.rollback; +import android.content.pm.VersionedPackage; import android.content.rollback.PackageRollbackInfo; import android.content.rollback.RollbackInfo; import android.util.Log; @@ -116,9 +117,9 @@ class RollbackStore { String packageName = element.getString("packageName"); long higherVersionCode = element.getLong("higherVersionCode"); long lowerVersionCode = element.getLong("lowerVersionCode"); - PackageRollbackInfo target = new PackageRollbackInfo(packageName, - new PackageRollbackInfo.PackageVersion(higherVersionCode), - new PackageRollbackInfo.PackageVersion(lowerVersionCode)); + PackageRollbackInfo target = new PackageRollbackInfo( + new VersionedPackage(packageName, higherVersionCode), + new VersionedPackage(packageName, lowerVersionCode)); RollbackInfo rollback = new RollbackInfo(rollbackId, target); recentlyExecutedRollbacks.add(rollback); } @@ -157,9 +158,11 @@ class RollbackStore { JSONArray packagesJson = new JSONArray(); for (PackageRollbackInfo info : data.packages) { JSONObject infoJson = new JSONObject(); - infoJson.put("packageName", info.packageName); - infoJson.put("higherVersionCode", info.higherVersion.versionCode); - infoJson.put("lowerVersionCode", info.lowerVersion.versionCode); + infoJson.put("packageName", info.getPackageName()); + infoJson.put("higherVersionCode", + info.getVersionRolledBackFrom().getLongVersionCode()); + infoJson.put("lowerVersionCode", + info.getVersionRolledBackTo().getVersionCode()); packagesJson.put(infoJson); } dataJson.put("rollbackId", data.rollbackId); @@ -197,9 +200,11 @@ class RollbackStore { RollbackInfo rollback = recentlyExecutedRollbacks.get(i); JSONObject element = new JSONObject(); element.put("rollbackId", rollback.getRollbackId()); - element.put("packageName", rollback.targetPackage.packageName); - element.put("higherVersionCode", rollback.targetPackage.higherVersion.versionCode); - element.put("lowerVersionCode", rollback.targetPackage.lowerVersion.versionCode); + element.put("packageName", rollback.targetPackage.getPackageName()); + element.put("higherVersionCode", + rollback.targetPackage.getVersionRolledBackFrom().getLongVersionCode()); + element.put("lowerVersionCode", + rollback.targetPackage.getVersionRolledBackTo().getLongVersionCode()); array.put(element); } @@ -231,9 +236,9 @@ class RollbackStore { String packageName = infoJson.getString("packageName"); long higherVersionCode = infoJson.getLong("higherVersionCode"); long lowerVersionCode = infoJson.getLong("lowerVersionCode"); - data.packages.add(new PackageRollbackInfo(packageName, - new PackageRollbackInfo.PackageVersion(higherVersionCode), - new PackageRollbackInfo.PackageVersion(lowerVersionCode))); + data.packages.add(new PackageRollbackInfo( + new VersionedPackage(packageName, higherVersionCode), + new VersionedPackage(packageName, lowerVersionCode))); } data.timestamp = Instant.parse(dataJson.getString("timestamp")); diff --git a/tests/RollbackTest/src/com/android/tests/rollback/RollbackTest.java b/tests/RollbackTest/src/com/android/tests/rollback/RollbackTest.java index ec6f4b55d3ea7..b9271fe5d1353 100644 --- a/tests/RollbackTest/src/com/android/tests/rollback/RollbackTest.java +++ b/tests/RollbackTest/src/com/android/tests/rollback/RollbackTest.java @@ -22,6 +22,7 @@ import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; +import android.content.rollback.PackageRollbackInfo; import android.content.rollback.RollbackInfo; import android.content.rollback.RollbackManager; import android.net.Uri; @@ -98,7 +99,7 @@ public class RollbackTest { // so that's not the case! for (int i = 0; i < 5; ++i) { for (RollbackInfo info : rm.getRecentlyExecutedRollbacks()) { - if (TEST_APP_A.equals(info.targetPackage.packageName)) { + if (TEST_APP_A.equals(info.targetPackage.getPackageName())) { Log.i(TAG, "Sleeping 1 second to wait for uninstall to take effect."); Thread.sleep(1000); break; @@ -116,7 +117,7 @@ public class RollbackTest { // There should be no recently executed rollbacks for this package. for (RollbackInfo info : rm.getRecentlyExecutedRollbacks()) { - assertNotEquals(TEST_APP_A, info.targetPackage.packageName); + assertNotEquals(TEST_APP_A, info.targetPackage.getPackageName()); } // Install v1 of the app (without rollbacks enabled). @@ -135,9 +136,7 @@ public class RollbackTest { assertTrue(rm.getPackagesWithAvailableRollbacks().contains(TEST_APP_A)); RollbackInfo rollback = rm.getAvailableRollback(TEST_APP_A); assertNotNull(rollback); - assertEquals(TEST_APP_A, rollback.targetPackage.packageName); - assertEquals(2, rollback.targetPackage.higherVersion.versionCode); - assertEquals(1, rollback.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_A, 2, 1, rollback.targetPackage); // We should not have received any rollback requests yet. // TODO: Possibly flaky if, by chance, some other app on device @@ -159,15 +158,13 @@ public class RollbackTest { // Verify the recent rollback has been recorded. rollback = null; for (RollbackInfo r : rm.getRecentlyExecutedRollbacks()) { - if (TEST_APP_A.equals(r.targetPackage.packageName)) { + if (TEST_APP_A.equals(r.targetPackage.getPackageName())) { assertNull(rollback); rollback = r; } } assertNotNull(rollback); - assertEquals(TEST_APP_A, rollback.targetPackage.packageName); - assertEquals(2, rollback.targetPackage.higherVersion.versionCode); - assertEquals(1, rollback.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_A, 2, 1, rollback.targetPackage); broadcastReceiver.unregister(); context.unregisterReceiver(enableRollbackReceiver); @@ -208,16 +205,12 @@ public class RollbackTest { assertTrue(rm.getPackagesWithAvailableRollbacks().contains(TEST_APP_A)); RollbackInfo rollbackA = rm.getAvailableRollback(TEST_APP_A); assertNotNull(rollbackA); - assertEquals(TEST_APP_A, rollbackA.targetPackage.packageName); - assertEquals(2, rollbackA.targetPackage.higherVersion.versionCode); - assertEquals(1, rollbackA.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_A, 2, 1, rollbackA.targetPackage); assertTrue(rm.getPackagesWithAvailableRollbacks().contains(TEST_APP_B)); RollbackInfo rollbackB = rm.getAvailableRollback(TEST_APP_B); assertNotNull(rollbackB); - assertEquals(TEST_APP_B, rollbackB.targetPackage.packageName); - assertEquals(2, rollbackB.targetPackage.higherVersion.versionCode); - assertEquals(1, rollbackB.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_B, 2, 1, rollbackB.targetPackage); // Reload the persisted data. rm.reloadPersistedData(); @@ -225,16 +218,12 @@ public class RollbackTest { // The apps should still be available for rollback. rollbackA = rm.getAvailableRollback(TEST_APP_A); assertNotNull(rollbackA); - assertEquals(TEST_APP_A, rollbackA.targetPackage.packageName); - assertEquals(2, rollbackA.targetPackage.higherVersion.versionCode); - assertEquals(1, rollbackA.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_A, 2, 1, rollbackA.targetPackage); assertTrue(rm.getPackagesWithAvailableRollbacks().contains(TEST_APP_B)); rollbackB = rm.getAvailableRollback(TEST_APP_B); assertNotNull(rollbackB); - assertEquals(TEST_APP_B, rollbackB.targetPackage.packageName); - assertEquals(2, rollbackB.targetPackage.higherVersion.versionCode); - assertEquals(1, rollbackB.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_B, 2, 1, rollbackB.targetPackage); // Rollback of B should not rollback A RollbackTestUtils.rollback(rollbackB); @@ -278,16 +267,12 @@ public class RollbackTest { assertTrue(rm.getPackagesWithAvailableRollbacks().contains(TEST_APP_A)); RollbackInfo rollbackA = rm.getAvailableRollback(TEST_APP_A); assertNotNull(rollbackA); - assertEquals(TEST_APP_A, rollbackA.targetPackage.packageName); - assertEquals(2, rollbackA.targetPackage.higherVersion.versionCode); - assertEquals(1, rollbackA.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_A, 2, 1, rollbackA.targetPackage); assertTrue(rm.getPackagesWithAvailableRollbacks().contains(TEST_APP_B)); RollbackInfo rollbackB = rm.getAvailableRollback(TEST_APP_B); assertNotNull(rollbackB); - assertEquals(TEST_APP_B, rollbackB.targetPackage.packageName); - assertEquals(2, rollbackB.targetPackage.higherVersion.versionCode); - assertEquals(1, rollbackB.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_B, 2, 1, rollbackB.targetPackage); // Reload the persisted data. rm.reloadPersistedData(); @@ -295,16 +280,12 @@ public class RollbackTest { // The apps should still be available for rollback. rollbackA = rm.getAvailableRollback(TEST_APP_A); assertNotNull(rollbackA); - assertEquals(TEST_APP_A, rollbackA.targetPackage.packageName); - assertEquals(2, rollbackA.targetPackage.higherVersion.versionCode); - assertEquals(1, rollbackA.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_A, 2, 1, rollbackA.targetPackage); assertTrue(rm.getPackagesWithAvailableRollbacks().contains(TEST_APP_B)); rollbackB = rm.getAvailableRollback(TEST_APP_B); assertNotNull(rollbackB); - assertEquals(TEST_APP_B, rollbackB.targetPackage.packageName); - assertEquals(2, rollbackB.targetPackage.higherVersion.versionCode); - assertEquals(1, rollbackB.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_B, 2, 1, rollbackB.targetPackage); // Rollback of B should rollback A as well RollbackTestUtils.rollback(rollbackB); @@ -348,15 +329,13 @@ public class RollbackTest { // Verify the recent rollback has been recorded. rollback = null; for (RollbackInfo r : rm.getRecentlyExecutedRollbacks()) { - if (TEST_APP_A.equals(r.targetPackage.packageName)) { + if (TEST_APP_A.equals(r.targetPackage.getPackageName())) { assertNull(rollback); rollback = r; } } assertNotNull(rollback); - assertEquals(TEST_APP_A, rollback.targetPackage.packageName); - assertEquals(2, rollback.targetPackage.higherVersion.versionCode); - assertEquals(1, rollback.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_A, 2, 1, rollback.targetPackage); // Reload the persisted data. rm.reloadPersistedData(); @@ -364,15 +343,13 @@ public class RollbackTest { // Verify the recent rollback is still recorded. rollback = null; for (RollbackInfo r : rm.getRecentlyExecutedRollbacks()) { - if (TEST_APP_A.equals(r.targetPackage.packageName)) { + if (TEST_APP_A.equals(r.targetPackage.getPackageName())) { assertNull(rollback); rollback = r; } } assertNotNull(rollback); - assertEquals(TEST_APP_A, rollback.targetPackage.packageName); - assertEquals(2, rollback.targetPackage.higherVersion.versionCode); - assertEquals(1, rollback.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_A, 2, 1, rollback.targetPackage); } finally { RollbackTestUtils.dropShellPermissionIdentity(); } @@ -404,9 +381,7 @@ public class RollbackTest { assertTrue(rm.getPackagesWithAvailableRollbacks().contains(TEST_APP_A)); RollbackInfo rollback = rm.getAvailableRollback(TEST_APP_A); assertNotNull(rollback); - assertEquals(TEST_APP_A, rollback.targetPackage.packageName); - assertEquals(2, rollback.targetPackage.higherVersion.versionCode); - assertEquals(1, rollback.targetPackage.lowerVersion.versionCode); + assertPackageRollbackInfoEquals(TEST_APP_A, 2, 1, rollback.targetPackage); // Expire the rollback. rm.expireRollbackForPackage(TEST_APP_A); @@ -549,11 +524,11 @@ public class RollbackTest { Thread.sleep(1000); RollbackInfo rollbackA = rm.getAvailableRollback(TEST_APP_A); assertNotNull(rollbackA); - assertEquals(TEST_APP_A, rollbackA.targetPackage.packageName); + assertEquals(TEST_APP_A, rollbackA.targetPackage.getPackageName()); RollbackInfo rollbackB = rm.getAvailableRollback(TEST_APP_B); assertNotNull(rollbackB); - assertEquals(TEST_APP_B, rollbackB.targetPackage.packageName); + assertEquals(TEST_APP_B, rollbackB.targetPackage.getPackageName()); // Executing rollback should roll back the correct package. RollbackTestUtils.rollback(rollbackA); @@ -670,7 +645,7 @@ public class RollbackTest { // We should not see a recent rollback listed for TEST_APP_B for (RollbackInfo r : rm.getRecentlyExecutedRollbacks()) { - assertNotEquals(TEST_APP_B, r.targetPackage.packageName); + assertNotEquals(TEST_APP_B, r.targetPackage.getPackageName()); } // TODO: Test the listed dependent apps for the recently executed @@ -680,4 +655,15 @@ public class RollbackTest { RollbackTestUtils.dropShellPermissionIdentity(); } } + + // Helper function to test the value of a PackageRollbackInfo + private void assertPackageRollbackInfoEquals(String packageName, + long versionRolledBackFrom, long versionRolledBackTo, + PackageRollbackInfo info) { + assertEquals(packageName, info.getPackageName()); + assertEquals(packageName, info.getVersionRolledBackFrom().getPackageName()); + assertEquals(versionRolledBackFrom, info.getVersionRolledBackFrom().getLongVersionCode()); + assertEquals(packageName, info.getVersionRolledBackTo().getPackageName()); + assertEquals(versionRolledBackTo, info.getVersionRolledBackTo().getLongVersionCode()); + } }