Rename functions for clarity

Author: Rachel Prince

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

@@ -14,7 +14,7 @@
 
 package com.google.firebase.appdistribution;
 
-import static com.google.firebase.appdistribution.internal.ReleaseIdentificationUtils.calculateApkInternalCodeHash;
+import static com.google.firebase.appdistribution.internal.ReleaseIdentificationUtils.calculateApkHash;
 
 import android.content.Context;
 import android.content.pm.PackageInfo;
@@ -43,7 +43,7 @@ class CheckForNewReleaseClient {
   private final FirebaseApp firebaseApp;
   private final FirebaseAppDistributionTesterApiClient firebaseAppDistributionTesterApiClient;
   private final FirebaseInstallationsApi firebaseInstallationsApi;
-  private static final ConcurrentMap<String, String> cachedCodeHashes = new ConcurrentHashMap<>();
+  private static final ConcurrentMap<String, String> cachedApkHashes = new ConcurrentHashMap<>();
   private final ReleaseIdentifierStorage releaseIdentifierStorage;
 
   Task<AppDistributionReleaseInternal> cachedCheckForNewRelease = null;
@@ -127,7 +127,8 @@ AppDistributionReleaseInternal getNewReleaseFromClient(
           firebaseAppDistributionTesterApiClient.fetchNewRelease(
               fid, appId, apiKey, authToken, firebaseApp.getApplicationContext());
 
-      if (isNewerBuildVersion(retrievedNewRelease) || !isInstalledRelease(retrievedNewRelease)) {
+      if (isNewerBuildVersion(retrievedNewRelease)
+          || !isSameAsInstalledRelease(retrievedNewRelease)) {
         return retrievedNewRelease;
       } else {
         // Return null if retrieved new release is older or currently installed
@@ -149,9 +150,9 @@ private boolean isNewerBuildVersion(AppDistributionReleaseInternal newRelease)
   }
 
   @VisibleForTesting
-  boolean isInstalledRelease(AppDistributionReleaseInternal newRelease) {
+  boolean isSameAsInstalledRelease(AppDistributionReleaseInternal newRelease) {
     if (newRelease.getBinaryType().equals(BinaryType.APK)) {
-      return hasSameApkHashAsInstalledRelease(newRelease);
+      return hasSameHashAsInstalledRelease(newRelease);
     }
 
     if (newRelease.getIasArtifactId() == null) {
@@ -186,13 +187,13 @@ String extractApkHash(PackageInfo packageInfo) {
     String key =
         String.format(
             Locale.ENGLISH, "%s.%d", sourceFile.getAbsolutePath(), sourceFile.lastModified());
-    if (!cachedCodeHashes.containsKey(key)) {
-      cachedCodeHashes.put(key, calculateApkInternalCodeHash(sourceFile));
+    if (!cachedApkHashes.containsKey(key)) {
+      cachedApkHashes.put(key, calculateApkHash(sourceFile));
     }
-    return cachedCodeHashes.get(key);
+    return cachedApkHashes.get(key);
   }
 
-  private boolean hasSameApkHashAsInstalledRelease(AppDistributionReleaseInternal newRelease) {
+  private boolean hasSameHashAsInstalledRelease(AppDistributionReleaseInternal newRelease) {
     try {
       Context context = firebaseApp.getApplicationContext();
       PackageInfo metadataPackageInfo =

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

@@ -16,7 +16,7 @@
 
 import static com.google.firebase.appdistribution.FirebaseAppDistributionException.Status;
 import static com.google.firebase.appdistribution.FirebaseAppDistributionException.Status.NETWORK_FAILURE;
-import static com.google.firebase.appdistribution.internal.ReleaseIdentificationUtils.calculateApkInternalCodeHash;
+import static com.google.firebase.appdistribution.internal.ReleaseIdentificationUtils.calculateApkHash;
 
 import android.app.Activity;
 import android.content.Context;
@@ -237,7 +237,7 @@ private void downloadToDisk(
 
     File downloadedFile = new File(firebaseApp.getApplicationContext().getFilesDir(), fileName);
 
-    String internalCodeHash = calculateApkInternalCodeHash(downloadedFile);
+    String internalCodeHash = calculateApkHash(downloadedFile);
 
     if (internalCodeHash != null) {
       releaseIdentifierStorage.setCodeHashMap(internalCodeHash, newRelease);

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

@@ -52,7 +52,7 @@ public static String extractInternalAppSharingArtifactId(@NonNull Context appCon
   }
 
   @Nullable
-  public static String calculateApkInternalCodeHash(@NonNull File file) {
+  public static String calculateApkHash(@NonNull File file) {
     Log.v(TAG, String.format("Calculating release id for %s", file.getPath()));
     Log.v(TAG, String.format("File size: %d", file.length()));
 
@@ -64,8 +64,10 @@ public static String calculateApkInternalCodeHash(@NonNull File file) {
       ArrayList<Byte> checksums = new ArrayList<>();
 
       // Since calculating the codeHash returned from the release backend is computationally
-      // expensive, using existing checksum data from the ZipFile we can quickly calculate
-      // an intermediate hash that then gets mapped to the backend's returned release codehash
+      // expensive, we has the existing checksum data from the ZipFile and compare it to
+      // (1) the apk hash returned by the backend, or (2) look up a mapping from the apk zip hash to
+      // the
+      // full codehash, and compare that to the codehash to the backend
       ZipFile zis = new ZipFile(file);
       try {
         Enumeration<? extends ZipEntry> zipEntries = zis.entries();

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

@@ -290,44 +290,46 @@ public void handleNewReleaseFromClient_whenNewReleaseIsSameAsInstalledAab_return
   }
 
   @Test
-  public void isInstalledRelease_whenApkHashesEqual_returnsTrue() {
+  public void iisSameAsInstalledRelease_whenApkHashesEqual_returnsTrue() {
     doReturn(CURRENT_APK_HASH).when(checkForNewReleaseClient).extractApkHash(any());
-    assertTrue(checkForNewReleaseClient.isInstalledRelease(getTestInstalledRelease().build()));
+    assertTrue(
+        checkForNewReleaseClient.isSameAsInstalledRelease(getTestInstalledRelease().build()));
   }
 
   @Test
-  public void isInstalledRelease_whenApkHashesNotEqual_returnsFalse() {
+  public void isSameAsInstalledRelease_whenApkHashesNotEqual_returnsFalse() {
     doReturn(CURRENT_APK_HASH).when(checkForNewReleaseClient).extractApkHash(any());
-    assertFalse(checkForNewReleaseClient.isInstalledRelease(getTestNewRelease().build()));
+    assertFalse(checkForNewReleaseClient.isSameAsInstalledRelease(getTestNewRelease().build()));
   }
 
   @Test
-  public void isInstalledRelease_ifApkHashNotPresent_fallsBackToExternalCodeHash() {
+  public void isSameAsInstalledRelease_ifApkHashNotPresent_fallsBackToExternalCodeHash() {
     doReturn(CURRENT_APK_HASH).when(checkForNewReleaseClient).extractApkHash(any());
     when(mockReleaseIdentifierStorage.getExternalCodeHash(any())).thenReturn(CURRENT_CODEHASH);
 
     assertFalse(
-        checkForNewReleaseClient.isInstalledRelease(getTestNewRelease().setApkHash("").build()));
+        checkForNewReleaseClient.isSameAsInstalledRelease(
+            getTestNewRelease().setApkHash("").build()));
     verify(mockReleaseIdentifierStorage).getExternalCodeHash(CURRENT_APK_HASH);
   }
 
   @Test
-  public void extractApkCodeHash_ifKeyInCachedCodeHashes_doesNotRecalculateZipHash() {
+  public void extractApkHash_ifKeyInCachedApkHashes_doesNotRecalculateZipHash() {
 
     try (MockedStatic mockedReleaseIdentificationUtils =
         mockStatic(ReleaseIdentificationUtils.class)) {
       PackageInfo packageInfo =
           shadowPackageManager.getInternalMutablePackageInfo(
               ApplicationProvider.getApplicationContext().getPackageName());
       mockedReleaseIdentificationUtils
-          .when(() -> ReleaseIdentificationUtils.calculateApkInternalCodeHash(any()))
+          .when(() -> ReleaseIdentificationUtils.calculateApkHash(any()))
           .thenReturn(NEW_CODEHASH);
 
       checkForNewReleaseClient.extractApkHash(packageInfo);
       checkForNewReleaseClient.extractApkHash(packageInfo);
       // check that calculateApkInternalCodeHash is only called once
       mockedReleaseIdentificationUtils.verify(
-          () -> ReleaseIdentificationUtils.calculateApkInternalCodeHash(any()));
+          () -> ReleaseIdentificationUtils.calculateApkHash(any()));
     }
   }