Add logic for the apk hash, but continue to fall back to the external code hash

Author: Rachel Prince

-P

@@ -66,14 +66,13 @@ class CheckForNewReleaseClient {
       @NonNull FirebaseApp firebaseApp,
       @NonNull FirebaseAppDistributionTesterApiClient firebaseAppDistributionTesterApiClient,
       @NonNull FirebaseInstallationsApi firebaseInstallationsApi,
+      @NonNull ReleaseIdentifierStorage releaseIdentifierStorage,
       @NonNull Executor executor) {
     this.firebaseApp = firebaseApp;
     this.firebaseAppDistributionTesterApiClient = firebaseAppDistributionTesterApiClient;
     this.firebaseInstallationsApi = firebaseInstallationsApi;
-    // TODO: verify if this is best way to use executorservice here
+    this.releaseIdentifierStorage = releaseIdentifierStorage;
     this.checkForNewReleaseExecutor = executor;
-    this.releaseIdentifierStorage =
-        new ReleaseIdentifierStorage(firebaseApp.getApplicationContext());
   }
 
   @NonNull
@@ -152,7 +151,7 @@ private boolean isNewerBuildVersion(AppDistributionReleaseInternal newRelease)
   @VisibleForTesting
   boolean isInstalledRelease(AppDistributionReleaseInternal newRelease) {
     if (newRelease.getBinaryType().equals(BinaryType.APK)) {
-      return hasSameCodeHashAsInstallledRelease(newRelease);
+      return hasSameApkHashAsInstalledRelease(newRelease);
     }
 
     if (newRelease.getIasArtifactId() == null) {
@@ -181,7 +180,7 @@ private long getInstalledAppVersionCode(Context context) throws FirebaseAppDistr
   }
 
   @VisibleForTesting
-  String extractApkCodeHash(PackageInfo packageInfo) {
+  String extractApkHash(PackageInfo packageInfo) {
     File sourceFile = new File(packageInfo.applicationInfo.sourceDir);
 
     String key =
@@ -190,26 +189,28 @@ String extractApkCodeHash(PackageInfo packageInfo) {
     if (!cachedCodeHashes.containsKey(key)) {
       cachedCodeHashes.put(key, calculateApkInternalCodeHash(sourceFile));
     }
-    return releaseIdentifierStorage.getExternalCodeHash(cachedCodeHashes.get(key));
+    return cachedCodeHashes.get(key);
   }
 
-  private boolean hasSameCodeHashAsInstallledRelease(AppDistributionReleaseInternal newRelease) {
+  private boolean hasSameApkHashAsInstalledRelease(AppDistributionReleaseInternal newRelease) {
     try {
       Context context = firebaseApp.getApplicationContext();
       PackageInfo metadataPackageInfo =
           context
               .getPackageManager()
               .getPackageInfo(context.getPackageName(), PackageManager.GET_META_DATA);
-      String externalCodeHash = extractApkCodeHash(metadataPackageInfo);
-      // Will trigger during the first install of the app since no zipHash to externalCodeHash
-      // mapping will have been set in ReleaseIdentifierStorage yet
-      if (externalCodeHash == null) {
-        return false;
+      String installedReleaseApkHash = extractApkHash(metadataPackageInfo);
+
+      if (installedReleaseApkHash.isEmpty() || newRelease.getApkHash().isEmpty()) {
+        // We don't have enough information about the APK hashes. Fallback to the external codehash.
+        // TODO: Consider removing this when all returned releases have the efficient ApkHash
+        String externalCodeHash =
+            releaseIdentifierStorage.getExternalCodeHash(installedReleaseApkHash);
+        return externalCodeHash != null && externalCodeHash.equals(newRelease.getCodeHash());
       }
-
-      // If the codeHash for the retrieved newRelease is equal to the stored codeHash
+      // If the hash of the zipped APK for the retrieved newRelease is equal to the stored hash
       // of the installed release, then they are the same release.
-      return externalCodeHash.equals(newRelease.getCodeHash());
+      return installedReleaseApkHash.equals(newRelease.getApkHash());
     } catch (PackageManager.NameNotFoundException e) {
       LogWrapper.getInstance().e(TAG + "Unable to locate App.", e);
       return false;

firebase-app-distribution/src/main/java/com/google/firebase/appdistribution/CheckForNewReleaseClient.java

@@ -50,6 +50,7 @@ class FirebaseAppDistributionTesterApiClient {
   private static final String RELEASE_NOTES_JSON_KEY = "releaseNotes";
   private static final String BINARY_TYPE_JSON_KEY = "binaryType";
   private static final String CODE_HASH_KEY = "codeHash";
+  private static final String APK_HASH_KEY = "apkHash";
   private static final String IAS_ARTIFACT_ID_KEY = "iasArtifactId";
   private static final String DOWNLOAD_URL_KEY = "downloadUrl";
 
@@ -81,6 +82,7 @@ class FirebaseAppDistributionTesterApiClient {
       final String buildVersion = newReleaseJson.getString(BUILD_VERSION_JSON_KEY);
       String releaseNotes = tryGetValue(newReleaseJson, RELEASE_NOTES_JSON_KEY);
       String codeHash = tryGetValue(newReleaseJson, CODE_HASH_KEY);
+      String apkHash = tryGetValue(newReleaseJson, APK_HASH_KEY);
       String iasArtifactId = tryGetValue(newReleaseJson, IAS_ARTIFACT_ID_KEY);
       String downloadUrl = tryGetValue(newReleaseJson, DOWNLOAD_URL_KEY);
 
@@ -97,6 +99,7 @@ class FirebaseAppDistributionTesterApiClient {
               .setBinaryType(binaryType)
               .setIasArtifactId(iasArtifactId)
               .setCodeHash(codeHash)
+              .setApkHash(apkHash)
               .setDownloadUrl(downloadUrl)
               .build();
       inputStream.close();

firebase-app-distribution/src/main/java/com/google/firebase/appdistribution/FirebaseAppDistributionTesterApiClient.java

@@ -55,6 +55,10 @@ public static Builder builder() {
   @Nullable
   public abstract String getCodeHash();
 
+  /** Efficient hash of an Android apk. Used to identify a release */
+  @Nullable
+  public abstract String getApkHash();
+
   /**
    * IAS artifact id. This value is inserted into the manifest of APK's installed via Used to map a
    * release to an APK installed via an app bundle
@@ -85,6 +89,9 @@ public abstract static class Builder {
     @NonNull
     public abstract Builder setCodeHash(@NonNull String value);
 
+    @NonNull
+    public abstract Builder setApkHash(@NonNull String value);
+
     @NonNull
     public abstract Builder setIasArtifactId(@NonNull String value);
 

firebase-app-distribution/src/main/java/com/google/firebase/appdistribution/internal/AppDistributionReleaseInternal.java

@@ -8,6 +8,7 @@
     "downloadUrl":"http://test-url-apk",
     "latest": true,
     "codeHash": "code-hash-apk-1",
+    "apkHash": "apk-hash-1",
     "fileSize": "3725041",
     "expirationTime": "2021-12-04T17:10:03Z",
     "binaryType": "APK"

firebase-app-distribution/src/test/assets/testApkReleaseResponse.json

@@ -14,6 +14,7 @@
 
 package com.google.firebase.appdistribution;
 
+import static com.google.firebase.appdistribution.BinaryType.APK;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
@@ -64,27 +65,12 @@ public class CheckForNewReleaseClientTest {
   private static final String TEST_AUTH_TOKEN = "fad.auth.token";
   private static final String TEST_IAS_ARTIFACT_ID = "ias-artifact-id";
   private static final String IAS_ARTIFACT_ID_KEY = "com.android.vending.internal.apk.id";
-  private static final String TEST_CODEHASH_1 = "abcdef";
-  private static final String TEST_CODEHASH_2 = "ghiklm";
-  private static final long INSTALLED_VERSION_CODE = 2;
-
-  private static final AppDistributionReleaseInternal TEST_RELEASE_NEWER_APK =
-      AppDistributionReleaseInternal.builder()
-          .setBuildVersion("3")
-          .setDisplayVersion("3.0")
-          .setReleaseNotes("Newer version.")
-          .setBinaryType(BinaryType.APK)
-          .setCodeHash(TEST_CODEHASH_1)
-          .build();
-
-  private static final AppDistributionReleaseInternal TEST_RELEASE_CURRENT =
-      AppDistributionReleaseInternal.builder()
-          .setBinaryType(BinaryType.APK)
-          .setBuildVersion(Long.toString(INSTALLED_VERSION_CODE))
-          .setDisplayVersion("2.0")
-          .setReleaseNotes("Current version.")
-          .setCodeHash(TEST_CODEHASH_2)
-          .build();
+  private static final String NEW_CODEHASH = "abcdef";
+  private static final String CURRENT_CODEHASH = "ghiklm";
+  private static final String NEW_APK_HASH = "newApkHash";
+  private static final String CURRENT_APK_HASH = "currentApkHash";
+  private static final long INSTALLED_VERSION_CODE = 1;
+  private static final long NEW_VERSION_CODE = 2;
 
   private CheckForNewReleaseClient checkForNewReleaseClient;
   private ShadowPackageManager shadowPackageManager;
@@ -93,6 +79,7 @@ public class CheckForNewReleaseClientTest {
   @Mock private FirebaseInstallationsApi mockFirebaseInstallations;
   @Mock private FirebaseAppDistributionTesterApiClient mockFirebaseAppDistributionTesterApiClient;
   @Mock private InstallationTokenResult mockInstallationTokenResult;
+  @Mock private ReleaseIdentifierStorage mockReleaseIdentifierStorage;
 
   Executor testExecutor = Executors.newSingleThreadExecutor();
 
@@ -142,6 +129,7 @@ public void setup() {
                 firebaseApp,
                 mockFirebaseAppDistributionTesterApiClient,
                 mockFirebaseInstallations,
+                mockReleaseIdentifierStorage,
                 testExecutor));
   }
 
@@ -166,7 +154,7 @@ public void checkForNewReleaseTask_whenCalledMultipleTimes_returnsTheSameTask()
   public void checkForNewRelease_succeeds() throws Exception {
     when(mockFirebaseAppDistributionTesterApiClient.fetchNewRelease(
             any(), any(), any(), any(), any()))
-        .thenReturn(TEST_RELEASE_NEWER_APK);
+        .thenReturn(getTestNewRelease().build());
     when(mockFirebaseInstallations.getId()).thenReturn(Tasks.forResult(TEST_FID_1));
     when(mockFirebaseInstallations.getToken(false))
         .thenReturn(Tasks.forResult(mockInstallationTokenResult));
@@ -177,7 +165,7 @@ public void checkForNewRelease_succeeds() throws Exception {
     task.addOnCompleteListener(testExecutor, onCompleteListener);
 
     AppDistributionReleaseInternal appDistributionReleaseInternal = onCompleteListener.await();
-    assertEquals(TEST_RELEASE_NEWER_APK, appDistributionReleaseInternal);
+    assertEquals(getTestNewRelease().build(), appDistributionReleaseInternal);
     verify(mockFirebaseInstallations, times(1)).getId();
     verify(mockFirebaseInstallations, times(1)).getToken(false);
   }
@@ -186,7 +174,7 @@ public void checkForNewRelease_succeeds() throws Exception {
   public void checkForNewRelease_nonAppDistroFailure() throws Exception {
     when(mockFirebaseAppDistributionTesterApiClient.fetchNewRelease(
             any(), any(), any(), any(), any()))
-        .thenReturn(TEST_RELEASE_CURRENT);
+        .thenReturn(getTestInstalledRelease().build());
     Exception expectedException = new Exception("test ex");
     when(mockFirebaseInstallations.getId()).thenReturn(Tasks.forException(expectedException));
     when(mockFirebaseInstallations.getToken(false))
@@ -235,23 +223,23 @@ public void getNewReleaseFromClient_whenNewReleaseIsNewerBuildThanInstalled_retu
       throws Exception {
     when(mockFirebaseAppDistributionTesterApiClient.fetchNewRelease(
             TEST_FID_1, TEST_APP_ID_1, TEST_API_KEY, TEST_AUTH_TOKEN, applicationContext))
-        .thenReturn(TEST_RELEASE_NEWER_APK);
+        .thenReturn(getTestNewRelease().build());
 
     AppDistributionReleaseInternal release =
         checkForNewReleaseClient.getNewReleaseFromClient(
             TEST_FID_1, TEST_APP_ID_1, TEST_API_KEY, TEST_AUTH_TOKEN);
 
     assertNotNull(release);
-    assertEquals(TEST_RELEASE_NEWER_APK.getBuildVersion(), release.getBuildVersion());
+    assertEquals(Long.toString(NEW_VERSION_CODE), release.getBuildVersion());
   }
 
   @Test
   public void getNewReleaseFromClient_whenNewReleaseIsSameRelease_returnsNull() throws Exception {
     when(mockFirebaseAppDistributionTesterApiClient.fetchNewRelease(
             TEST_FID_1, TEST_APP_ID_1, TEST_API_KEY, TEST_AUTH_TOKEN, applicationContext))
-        .thenReturn(TEST_RELEASE_CURRENT);
+        .thenReturn(getTestInstalledRelease().build());
 
-    doReturn(TEST_CODEHASH_2).when(checkForNewReleaseClient).extractApkCodeHash(any());
+    doReturn(CURRENT_APK_HASH).when(checkForNewReleaseClient).extractApkHash(any());
 
     AppDistributionReleaseInternal release =
         checkForNewReleaseClient.getNewReleaseFromClient(
@@ -265,10 +253,7 @@ public void handleNewReleaseFromClient_whenNewAabIsAvailable_returnsRelease() th
     when(mockFirebaseAppDistributionTesterApiClient.fetchNewRelease(
             any(), any(), any(), any(), any()))
         .thenReturn(
-            AppDistributionReleaseInternal.builder()
-                .setBuildVersion(TEST_RELEASE_CURRENT.getBuildVersion())
-                .setDisplayVersion(TEST_RELEASE_CURRENT.getDisplayVersion())
-                .setCodeHash("codehash")
+            getTestNewRelease()
                 .setDownloadUrl("http://fake-download-url")
                 .setIasArtifactId("test-ias-artifact-id-2")
                 .setBinaryType(BinaryType.AAB)
@@ -278,10 +263,7 @@ public void handleNewReleaseFromClient_whenNewAabIsAvailable_returnsRelease() th
         checkForNewReleaseClient.getNewReleaseFromClient(
             TEST_FID_1, TEST_APP_ID_1, TEST_API_KEY, TEST_AUTH_TOKEN);
     assertEquals(
-        AppDistributionReleaseInternal.builder()
-            .setBuildVersion(TEST_RELEASE_CURRENT.getBuildVersion())
-            .setDisplayVersion(TEST_RELEASE_CURRENT.getDisplayVersion())
-            .setCodeHash("codehash")
+        getTestNewRelease()
             .setDownloadUrl("http://fake-download-url")
             .setIasArtifactId("test-ias-artifact-id-2")
             .setBinaryType(BinaryType.AAB)
@@ -295,10 +277,7 @@ public void handleNewReleaseFromClient_whenNewReleaseIsSameAsInstalledAab_return
     when(mockFirebaseAppDistributionTesterApiClient.fetchNewRelease(
             any(), any(), any(), any(), any()))
         .thenReturn(
-            AppDistributionReleaseInternal.builder()
-                .setBuildVersion(TEST_RELEASE_CURRENT.getBuildVersion())
-                .setDisplayVersion(TEST_RELEASE_CURRENT.getDisplayVersion())
-                .setCodeHash("codehash")
+            getTestInstalledRelease()
                 .setDownloadUrl("http://fake-download-url")
                 .setIasArtifactId(TEST_IAS_ARTIFACT_ID)
                 .setBinaryType(BinaryType.AAB)
@@ -311,15 +290,25 @@ public void handleNewReleaseFromClient_whenNewReleaseIsSameAsInstalledAab_return
   }
 
   @Test
-  public void isInstalledRelease_whenCodeHashesEqual_returnsTrue() {
-    doReturn(TEST_CODEHASH_1).when(checkForNewReleaseClient).extractApkCodeHash(any());
-    assertTrue(checkForNewReleaseClient.isInstalledRelease(TEST_RELEASE_NEWER_APK));
+  public void isInstalledRelease_whenApkHashesEqual_returnsTrue() {
+    doReturn(CURRENT_APK_HASH).when(checkForNewReleaseClient).extractApkHash(any());
+    assertTrue(checkForNewReleaseClient.isInstalledRelease(getTestInstalledRelease().build()));
   }
 
   @Test
-  public void isInstalledRelease_whenCodeHashesNotEqual_returnsFalse() {
-    doReturn(TEST_CODEHASH_2).when(checkForNewReleaseClient).extractApkCodeHash(any());
-    assertFalse(checkForNewReleaseClient.isInstalledRelease(TEST_RELEASE_NEWER_APK));
+  public void isInstalledRelease_whenApkHashesNotEqual_returnsFalse() {
+    doReturn(CURRENT_APK_HASH).when(checkForNewReleaseClient).extractApkHash(any());
+    assertFalse(checkForNewReleaseClient.isInstalledRelease(getTestNewRelease().build()));
+  }
+
+  @Test
+  public void isInstalledRelease_ifApkHashNotPresent_fallsBackToExternalCodeHash() {
+    doReturn(CURRENT_APK_HASH).when(checkForNewReleaseClient).extractApkHash(any());
+    when(mockReleaseIdentifierStorage.getExternalCodeHash(any())).thenReturn(CURRENT_CODEHASH);
+
+    assertFalse(
+        checkForNewReleaseClient.isInstalledRelease(getTestNewRelease().setApkHash("").build()));
+    verify(mockReleaseIdentifierStorage).getExternalCodeHash(CURRENT_APK_HASH);
   }
 
   @Test
@@ -332,13 +321,33 @@ public void extractApkCodeHash_ifKeyInCachedCodeHashes_doesNotRecalculateZipHash
               ApplicationProvider.getApplicationContext().getPackageName());
       mockedReleaseIdentificationUtils
           .when(() -> ReleaseIdentificationUtils.calculateApkInternalCodeHash(any()))
-          .thenReturn(TEST_CODEHASH_1);
+          .thenReturn(NEW_CODEHASH);
 
-      checkForNewReleaseClient.extractApkCodeHash(packageInfo);
-      checkForNewReleaseClient.extractApkCodeHash(packageInfo);
+      checkForNewReleaseClient.extractApkHash(packageInfo);
+      checkForNewReleaseClient.extractApkHash(packageInfo);
       // check that calculateApkInternalCodeHash is only called once
       mockedReleaseIdentificationUtils.verify(
           () -> ReleaseIdentificationUtils.calculateApkInternalCodeHash(any()));
     }
   }
+
+  private AppDistributionReleaseInternal.Builder getTestNewRelease() {
+    return AppDistributionReleaseInternal.builder()
+        .setBuildVersion(Long.toString(NEW_VERSION_CODE))
+        .setDisplayVersion("2.0")
+        .setReleaseNotes("Newer version.")
+        .setCodeHash(NEW_CODEHASH)
+        .setBinaryType(APK)
+        .setApkHash(NEW_APK_HASH);
+  }
+
+  private AppDistributionReleaseInternal.Builder getTestInstalledRelease() {
+    return AppDistributionReleaseInternal.builder()
+        .setBuildVersion(Long.toString(INSTALLED_VERSION_CODE))
+        .setDisplayVersion("1.0")
+        .setReleaseNotes("Current version.")
+        .setCodeHash(CURRENT_CODEHASH)
+        .setBinaryType(APK)
+        .setApkHash(CURRENT_APK_HASH);
+  }
 }

firebase-app-distribution/src/test/java/com/google/firebase/appdistribution/CheckForNewReleaseClientTest.java

@@ -81,6 +81,7 @@ public void fetchNewRelease_whenResponseSuccessfulForApk_returnsRelease() throws
     assertEquals(release.getReleaseNotes(), "This is a test release.");
     assertEquals(release.getDownloadUrl(), "http://test-url-apk");
     assertEquals(release.getCodeHash(), "code-hash-apk-1");
+    assertEquals(release.getApkHash(), "apk-hash-1");
   }
 
   @Test