Merge branch 'master' into bc/index-scheduler

Author: Brian Chen

apk-size/app/build.gradle

@@ -15,7 +15,42 @@
 apply plugin: "com.android.application"
 apply from: "default.gradle"
 android {
-    flavorDimensions "apkSize"
+    flavorDimensions "firebase", "abi"
+
+    // https://developer.android.com/ndk/guides/abis
+    productFlavors {
+        "universal" {
+            dimension "abi"
+        }
+
+        "armeabi-v7a" {
+            dimension "abi"
+            ndk {
+                abiFilters "armeabi-v7a"
+            }
+        }
+
+        "arm64-v8a" {
+            dimension "abi"
+            ndk {
+                abiFilters "arm64-v8a"
+            }
+        }
+
+        "x86" {
+            dimension "abi"
+            ndk {
+                abiFilters "x86"
+            }
+        }
+
+        "x86_64" {
+            dimension "abi"
+            ndk {
+                abiFilters "x86_64"
+            }
+        }
+    }
 
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_8

apk-size/app/configure.gradle

@@ -26,9 +26,30 @@ if (project.hasProperty('sdks')) {
         sdks.split(',').each { sdk ->
             def (groupId, artifactId, version) = sdk.split(':')
             productFlavors.create(artifactId) {
-                dimension 'apkSize'
+                dimension 'firebase'
             }
             dependencies.add("${artifactId}Implementation", sdk)
         }
+
+        // Ignore debug builds as measurements are not reproducible due to disabled ZipAlign.
+        // Ignore per-architecture builds for all products except for firebase-crashlytics-ndk.
+        variantFilter { variant ->
+            def buildType = variant.buildType.name
+            def flavors = variant.flavors*.name
+            if (buildType == 'debug'
+                    || ('firebase-crashlytics-ndk' in flavors && 'universal' in flavors)
+                    || !('firebase-crashlytics-ndk' in flavors || 'universal' in flavors)) {
+                setIgnore(true)
+            }
+        }
+
+        applicationVariants.all { variant ->
+            def product = variant.productFlavors[0].name
+            def abi = variant.productFlavors[1].name
+            def buildType = variant.buildType.name
+            variant.outputs.all {
+                outputFileName = "${product}::${buildType}::${abi}.apk"
+            }
+        }
     }
 }

apk-size/app/default.gradle

@@ -57,13 +57,6 @@ android {
             shrinkResources false
         }
     }
-
-    variantFilter { variant ->
-        def buildTypeName = variant.buildType*.name
-        if (buildTypeName.contains('debug')) {
-            setIgnore(true)
-        }
-    }
 }
 
 dependencies {

apk-size/app/src/base/base.gradle

@@ -16,7 +16,7 @@
 android {
     productFlavors {
         base {
-            dimension "apkSize"
+            dimension "firebase"
             applicationId "com.google.apksize.base"
         }
     }

apk-size/gradle.properties

@@ -13,5 +13,6 @@
 # limitations under the License.
 
 android.useAndroidX=true
+android.enableJetifier=true
 
 org.gradle.jvmargs=-Xmx8g -XX:MaxPermSize=8g

appcheck/firebase-appcheck-interop/gradle.properties

@@ -1 +1,2 @@
 version=16.0.1
+latestReleasedVersion=16.0.0-beta02

ci/fireci/fireciplugins/binary_size.py

@@ -59,7 +59,7 @@ def binary_size(pull_request, log, metrics_service_url, access_token):
 
   gradle.run('assemble', '--continue', gradle.P('sdks', sdks), workdir='apk-size', check=False)
 
-  test_results = _measure_aar_sizes(artifacts) + _measure_apk_sizes(artifacts)
+  test_results = _measure_aar_sizes(artifacts) + _measure_apk_sizes()
   test_report = {'metric': 'BinarySize', 'results': test_results, 'log': log}
 
   uploader.post_report(test_report, metrics_service_url, access_token)
@@ -79,17 +79,17 @@ def _measure_aar_sizes(artifacts):
   return test_results
 
 
-def _measure_apk_sizes(artifacts):
+def _measure_apk_sizes():
   test_results = []
 
-  for artifact in artifacts:
-    group_id, artifact_id, version = artifact.split(':')
-    apk_files = glob.glob(f'./apk-size/**/{artifact_id}/**/*.apk', recursive=True)
+  apk_files = glob.glob(fr'./apk-size/**/*.apk', recursive=True)
+  for apk_file in apk_files:
+    filename = os.path.basename(apk_file)
+    artifact, build_type, abi = os.path.splitext(filename)[0].split('::')
+    apk_type = build_type if abi == 'universal' else f'{build_type} / {abi}'
+    apk_size = os.path.getsize(apk_file)
 
-    for apk_file in apk_files:
-      build_type = re.search(fr'{artifact_id}/([^/]*)/', apk_file).group(1)
-      apk_size = os.path.getsize(apk_file)
-      test_results.append({'sdk': artifact_id, 'type': f'apk ({build_type})', 'value': apk_size})
+    test_results.append({'sdk': artifact, 'type': f'apk ({apk_type})', 'value': apk_size})
 
   return test_results
 

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

@@ -36,32 +36,33 @@
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 
-class CheckForUpdateClient {
-  private static final int UPDATE_THREAD_POOL_SIZE = 4;
+class CheckForNewReleaseClient {
+  private static final int NEW_RELEASE_THREAD_POOL_SIZE = 4;
+  private static final String TAG = "CheckForNewReleaseClient:";
 
   private final FirebaseApp firebaseApp;
   private final FirebaseAppDistributionTesterApiClient firebaseAppDistributionTesterApiClient;
   private final FirebaseInstallationsApi firebaseInstallationsApi;
   private static final ConcurrentMap<String, String> cachedCodeHashes = new ConcurrentHashMap<>();
   private final ReleaseIdentifierStorage releaseIdentifierStorage;
 
-  Task<AppDistributionReleaseInternal> cachedCheckForUpdate = null;
-  private final Executor checkForUpdateExecutor;
+  Task<AppDistributionReleaseInternal> cachedCheckForNewRelease = null;
+  private final Executor checkForNewReleaseExecutor;
 
-  CheckForUpdateClient(
+  CheckForNewReleaseClient(
       @NonNull FirebaseApp firebaseApp,
       @NonNull FirebaseAppDistributionTesterApiClient firebaseAppDistributionTesterApiClient,
       @NonNull FirebaseInstallationsApi firebaseInstallationsApi) {
     this.firebaseApp = firebaseApp;
     this.firebaseAppDistributionTesterApiClient = firebaseAppDistributionTesterApiClient;
     this.firebaseInstallationsApi = firebaseInstallationsApi;
     // TODO: verify if this is best way to use executorservice here
-    this.checkForUpdateExecutor = Executors.newFixedThreadPool(UPDATE_THREAD_POOL_SIZE);
+    this.checkForNewReleaseExecutor = Executors.newFixedThreadPool(NEW_RELEASE_THREAD_POOL_SIZE);
     this.releaseIdentifierStorage =
         new ReleaseIdentifierStorage(firebaseApp.getApplicationContext());
   }
 
-  CheckForUpdateClient(
+  CheckForNewReleaseClient(
       @NonNull FirebaseApp firebaseApp,
       @NonNull FirebaseAppDistributionTesterApiClient firebaseAppDistributionTesterApiClient,
       @NonNull FirebaseInstallationsApi firebaseInstallationsApi,
@@ -70,94 +71,94 @@ class CheckForUpdateClient {
     this.firebaseAppDistributionTesterApiClient = firebaseAppDistributionTesterApiClient;
     this.firebaseInstallationsApi = firebaseInstallationsApi;
     // TODO: verify if this is best way to use executorservice here
-    this.checkForUpdateExecutor = executor;
+    this.checkForNewReleaseExecutor = executor;
     this.releaseIdentifierStorage =
         new ReleaseIdentifierStorage(firebaseApp.getApplicationContext());
   }
 
   @NonNull
-  public synchronized Task<AppDistributionReleaseInternal> checkForUpdate() {
+  public synchronized Task<AppDistributionReleaseInternal> checkForNewRelease() {
 
-    if (cachedCheckForUpdate != null && !cachedCheckForUpdate.isComplete()) {
-      return cachedCheckForUpdate;
+    if (cachedCheckForNewRelease != null && !cachedCheckForNewRelease.isComplete()) {
+      return cachedCheckForNewRelease;
     }
 
     Task<String> installationIdTask = firebaseInstallationsApi.getId();
     // forceRefresh is false to get locally cached token if available
     Task<InstallationTokenResult> installationAuthTokenTask =
         firebaseInstallationsApi.getToken(false);
 
-    this.cachedCheckForUpdate =
+    this.cachedCheckForNewRelease =
         Tasks.whenAllSuccess(installationIdTask, installationAuthTokenTask)
             .onSuccessTask(
-                checkForUpdateExecutor,
+                checkForNewReleaseExecutor,
                 tasks -> {
                   String fid = installationIdTask.getResult();
                   InstallationTokenResult installationTokenResult =
                       installationAuthTokenTask.getResult();
                   try {
-                    AppDistributionReleaseInternal latestRelease =
-                        getLatestReleaseFromClient(
+                    AppDistributionReleaseInternal newRelease =
+                        getNewReleaseFromClient(
                             fid,
                             firebaseApp.getOptions().getApplicationId(),
                             firebaseApp.getOptions().getApiKey(),
                             installationTokenResult.getToken());
-                    return Tasks.forResult(latestRelease);
+                    return Tasks.forResult(newRelease);
                   } catch (FirebaseAppDistributionException ex) {
                     return Tasks.forException(ex);
                   }
                 })
             .continueWithTask(
-                checkForUpdateExecutor,
+                checkForNewReleaseExecutor,
                 task ->
                     TaskUtils.handleTaskFailure(
                         task,
                         Constants.ErrorMessages.NETWORK_ERROR,
                         FirebaseAppDistributionException.Status.NETWORK_FAILURE));
 
-    return cachedCheckForUpdate;
+    return cachedCheckForNewRelease;
   }
 
   @VisibleForTesting
-  AppDistributionReleaseInternal getLatestReleaseFromClient(
+  AppDistributionReleaseInternal getNewReleaseFromClient(
       String fid, String appId, String apiKey, String authToken)
       throws FirebaseAppDistributionException {
     try {
-      AppDistributionReleaseInternal retrievedLatestRelease =
-          firebaseAppDistributionTesterApiClient.fetchLatestRelease(fid, appId, apiKey, authToken);
+      AppDistributionReleaseInternal retrievedNewRelease =
+          firebaseAppDistributionTesterApiClient.fetchNewRelease(fid, appId, apiKey, authToken);
 
-      if (isNewerBuildVersion(retrievedLatestRelease)
-          || !isInstalledRelease(retrievedLatestRelease)) {
-        return retrievedLatestRelease;
+      if (isNewerBuildVersion(retrievedNewRelease) || !isInstalledRelease(retrievedNewRelease)) {
+        return retrievedNewRelease;
       } else {
-        // Return null if retrieved latest release is older or currently installed
+        // Return null if retrieved new release is older or currently installed
         return null;
       }
     } catch (NumberFormatException e) {
+      LogWrapper.getInstance().e(TAG + "Error parsing buildVersion.", e);
       throw new FirebaseAppDistributionException(
           Constants.ErrorMessages.NETWORK_ERROR,
           FirebaseAppDistributionException.Status.NETWORK_FAILURE,
           e);
     }
   }
 
-  private boolean isNewerBuildVersion(AppDistributionReleaseInternal latestRelease)
+  private boolean isNewerBuildVersion(AppDistributionReleaseInternal newRelease)
       throws FirebaseAppDistributionException {
-    return Long.parseLong(latestRelease.getBuildVersion())
+    return Long.parseLong(newRelease.getBuildVersion())
         > getInstalledAppVersionCode(firebaseApp.getApplicationContext());
   }
 
   @VisibleForTesting
-  boolean isInstalledRelease(AppDistributionReleaseInternal latestRelease) {
-    if (latestRelease.getBinaryType().equals(BinaryType.APK)) {
-      return hasSameCodeHashAsInstallledRelease(latestRelease);
+  boolean isInstalledRelease(AppDistributionReleaseInternal newRelease) {
+    if (newRelease.getBinaryType().equals(BinaryType.APK)) {
+      return hasSameCodeHashAsInstallledRelease(newRelease);
     }
 
-    if (latestRelease.getIasArtifactId() == null) {
+    if (newRelease.getIasArtifactId() == null) {
       return false;
     }
     // AAB BinaryType
-    return latestRelease
+    return newRelease
         .getIasArtifactId()
         .equals(
             ReleaseIdentificationUtils.extractInternalAppSharingArtifactId(
@@ -169,6 +170,7 @@ private long getInstalledAppVersionCode(Context context) throws FirebaseAppDistr
     try {
       pInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
     } catch (PackageManager.NameNotFoundException e) {
+      LogWrapper.getInstance().e(TAG + "Unable to locate Firebase App.", e);
       throw new FirebaseAppDistributionException(
           Constants.ErrorMessages.UNKNOWN_ERROR,
           FirebaseAppDistributionException.Status.UNKNOWN,
@@ -190,7 +192,7 @@ String extractApkCodeHash(PackageInfo packageInfo) {
     return releaseIdentifierStorage.getExternalCodeHash(cachedCodeHashes.get(key));
   }
 
-  private boolean hasSameCodeHashAsInstallledRelease(AppDistributionReleaseInternal latestRelease) {
+  private boolean hasSameCodeHashAsInstallledRelease(AppDistributionReleaseInternal newRelease) {
     try {
       Context context = firebaseApp.getApplicationContext();
       PackageInfo metadataPackageInfo =
@@ -204,10 +206,11 @@ private boolean hasSameCodeHashAsInstallledRelease(AppDistributionReleaseInterna
         return false;
       }
 
-      // If the codeHash for the retrieved latestRelease is equal to the stored codeHash
+      // If the codeHash for the retrieved newRelease is equal to the stored codeHash
       // of the installed release, then they are the same release.
-      return externalCodeHash.equals(latestRelease.getCodeHash());
+      return externalCodeHash.equals(newRelease.getCodeHash());
     } catch (PackageManager.NameNotFoundException e) {
+      LogWrapper.getInstance().e(TAG + "Unable to locate App.", e);
       return false;
     }
   }