Merge branch 'master' into wuandy/SquashBasedOnSebastianDraft

Author: wu-hui

firebase-app-distribution/src/main/AndroidManifest.xml

@@ -44,12 +44,12 @@
 
         <provider
             android:name="androidx.core.content.FileProvider"
-            android:authorities="${applicationId}.provider"
+            android:authorities="${applicationId}.appdistro.fileprovider"
             android:exported="false"
             android:grantUriPermissions="true">
             <meta-data
                 android:name="android.support.FILE_PROVIDER_PATHS"
-                android:resource="@xml/provider_paths" />
+                android:resource="@xml/appdistro_provider_paths" />
         </provider>
     </application>
 </manifest>

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,33 +36,33 @@
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 
-class CheckForUpdateClient {
-  private static final int UPDATE_THREAD_POOL_SIZE = 4;
-  private static final String TAG = "CheckForUpdateClient:";
+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,
@@ -71,67 +71,66 @@ 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) {
@@ -143,23 +142,23 @@ AppDistributionReleaseInternal getLatestReleaseFromClient(
     }
   }
 
-  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(
@@ -193,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 =
@@ -207,9 +206,9 @@ 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;

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

@@ -36,7 +36,7 @@ public class FirebaseAppDistribution implements Application.ActivityLifecycleCal
 
   private final FirebaseApp firebaseApp;
   private final TesterSignInClient testerSignInClient;
-  private final CheckForUpdateClient checkForUpdateClient;
+  private final CheckForNewReleaseClient checkForNewReleaseClient;
   private final UpdateAppClient updateAppClient;
   private Activity currentActivity;
   private static final int UNKNOWN_RELEASE_FILE_SIZE = -1;
@@ -45,7 +45,7 @@ public class FirebaseAppDistribution implements Application.ActivityLifecycleCal
   private UpdateTaskImpl cachedUpdateIfNewReleaseTask;
 
   private final Object updateTaskLock = new Object();
-  private Task<AppDistributionRelease> cachedCheckForUpdateTask;
+  private Task<AppDistributionRelease> cachedCheckForNewReleaseTask;
 
   private AppDistributionReleaseInternal cachedNewRelease;
   private final SignInStorage signInStorage;
@@ -55,12 +55,12 @@ public class FirebaseAppDistribution implements Application.ActivityLifecycleCal
   FirebaseAppDistribution(
       @NonNull FirebaseApp firebaseApp,
       @NonNull TesterSignInClient testerSignInClient,
-      @NonNull CheckForUpdateClient checkForUpdateClient,
+      @NonNull CheckForNewReleaseClient checkForNewReleaseClient,
       @NonNull UpdateAppClient updateAppClient,
       @NonNull SignInStorage signInStorage) {
     this.firebaseApp = firebaseApp;
     this.testerSignInClient = testerSignInClient;
-    this.checkForUpdateClient = checkForUpdateClient;
+    this.checkForNewReleaseClient = checkForNewReleaseClient;
     this.updateAppClient = updateAppClient;
     this.signInStorage = signInStorage;
   }
@@ -73,7 +73,7 @@ public FirebaseAppDistribution(
     this(
         firebaseApp,
         new TesterSignInClient(firebaseApp, firebaseInstallationsApi, signInStorage),
-        new CheckForUpdateClient(
+        new CheckForNewReleaseClient(
             firebaseApp, new FirebaseAppDistributionTesterApiClient(), firebaseInstallationsApi),
         new UpdateAppClient(firebaseApp),
         signInStorage);
@@ -171,21 +171,21 @@ public Task<Void> signInTester() {
    */
   @NonNull
   public synchronized Task<AppDistributionRelease> checkForNewRelease() {
-    if (cachedCheckForUpdateTask != null && !cachedCheckForUpdateTask.isComplete()) {
+    if (cachedCheckForNewReleaseTask != null && !cachedCheckForNewReleaseTask.isComplete()) {
       LogWrapper.getInstance().v("Response in progress");
-      return cachedCheckForUpdateTask;
+      return cachedCheckForNewReleaseTask;
     }
-    cachedCheckForUpdateTask =
+    cachedCheckForNewReleaseTask =
         signInTester()
-            .onSuccessTask(unused -> this.checkForUpdateClient.checkForUpdate())
+            .onSuccessTask(unused -> this.checkForNewReleaseClient.checkForNewRelease())
             .onSuccessTask(
                 appDistributionReleaseInternal -> {
                   setCachedNewRelease(appDistributionReleaseInternal);
                   return Tasks.forResult(
                       ReleaseUtils.convertToAppDistributionRelease(appDistributionReleaseInternal));
                 });
 
-    return cachedCheckForUpdateTask;
+    return cachedCheckForNewReleaseTask;
   }
 
   /**
@@ -194,7 +194,7 @@ public synchronized Task<AppDistributionRelease> checkForNewRelease() {
    * complete the download and installation.
    *
    * <p>cancels task with FirebaseAppDistributionException with UPDATE_NOT_AVAILABLE exception if no
-   * new release is cached from checkForUpdate
+   * new release is cached from checkForNewRelease
    */
   @NonNull
   public synchronized UpdateTask updateApp() {

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

@@ -46,32 +46,32 @@ class FirebaseAppDistributionTesterApiClient {
   private static final String TAG = "TesterApiClient:";
   public static final int DEFAULT_BUFFER_SIZE = 8192;
 
-  public @NonNull AppDistributionReleaseInternal fetchLatestRelease(
+  public @NonNull AppDistributionReleaseInternal fetchNewRelease(
       @NonNull String fid, @NonNull String appId, @NonNull String apiKey, @NonNull String authToken)
       throws FirebaseAppDistributionException {
 
-    AppDistributionReleaseInternal latestRelease;
+    AppDistributionReleaseInternal newRelease;
     HttpsURLConnection connection = openHttpsUrlConnection(appId, fid);
     try {
       connection.setRequestMethod(REQUEST_METHOD);
       connection.setRequestProperty(API_KEY_HEADER, apiKey);
       connection.setRequestProperty(INSTALLATION_AUTH_HEADER, authToken);
 
       InputStream inputStream = connection.getInputStream();
-      JSONObject latestReleaseJson = readFetchReleaseInputStream(inputStream);
-      final String displayVersion = latestReleaseJson.getString(DISPLAY_VERSION_JSON_KEY);
-      final String buildVersion = latestReleaseJson.getString(BUILD_VERSION_JSON_KEY);
-      String releaseNotes = tryGetValue(latestReleaseJson, RELEASE_NOTES_JSON_KEY);
-      String codeHash = tryGetValue(latestReleaseJson, CODE_HASH_KEY);
-      String iasArtifactId = tryGetValue(latestReleaseJson, IAS_ARTIFACT_ID_KEY);
-      String downloadUrl = tryGetValue(latestReleaseJson, DOWNLOAD_URL_KEY);
+      JSONObject newReleaseJson = readFetchReleaseInputStream(inputStream);
+      final String displayVersion = newReleaseJson.getString(DISPLAY_VERSION_JSON_KEY);
+      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 iasArtifactId = tryGetValue(newReleaseJson, IAS_ARTIFACT_ID_KEY);
+      String downloadUrl = tryGetValue(newReleaseJson, DOWNLOAD_URL_KEY);
 
       final BinaryType binaryType =
-          latestReleaseJson.getString(BINARY_TYPE_JSON_KEY).equals("APK")
+          newReleaseJson.getString(BINARY_TYPE_JSON_KEY).equals("APK")
               ? BinaryType.APK
               : BinaryType.AAB;
 
-      latestRelease =
+      newRelease =
           AppDistributionReleaseInternal.builder()
               .setDisplayVersion(displayVersion)
               .setBuildVersion(buildVersion)
@@ -85,7 +85,7 @@ class FirebaseAppDistributionTesterApiClient {
 
     } catch (IOException | JSONException e) {
       if (e instanceof JSONException) {
-        LogWrapper.getInstance().e(TAG + "Error parsing the latest release.", e);
+        LogWrapper.getInstance().e(TAG + "Error parsing the new release.", e);
         throw new FirebaseAppDistributionException(
             Constants.ErrorMessages.JSON_PARSING_ERROR, NETWORK_FAILURE, e);
       }
@@ -94,7 +94,7 @@ class FirebaseAppDistributionTesterApiClient {
       connection.disconnect();
     }
 
-    return latestRelease;
+    return newRelease;
   }
 
   private FirebaseAppDistributionException getExceptionForHttpResponse(
@@ -136,19 +136,19 @@ private String tryGetValue(JSONObject jsonObject, String key) {
 
   private JSONObject readFetchReleaseInputStream(InputStream in)
       throws FirebaseAppDistributionException, IOException {
-    JSONObject latestRelease;
+    JSONObject newRelease;
     InputStream jsonIn = new BufferedInputStream(in);
     String result = convertInputStreamToString(jsonIn);
     try {
       JSONObject json = new JSONObject(result);
-      latestRelease = json.getJSONArray("releases").getJSONObject(0);
+      newRelease = json.getJSONArray("releases").getJSONObject(0);
     } catch (JSONException e) {
       throw new FirebaseAppDistributionException(
           Constants.ErrorMessages.JSON_PARSING_ERROR,
           FirebaseAppDistributionException.Status.UNKNOWN,
           e);
     }
-    return latestRelease;
+    return newRelease;
   }
 
   HttpsURLConnection openHttpsUrlConnection(String appId, String fid)

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

@@ -45,14 +45,22 @@ protected void onCreate(@NonNull Bundle savedInstanceState) {
     String path = originalIntent.getStringExtra("INSTALL_PATH");
     Intent intent = new Intent(Intent.ACTION_VIEW);
     intent.putExtra(Intent.EXTRA_RETURN_RESULT, true);
-    Uri apkUri =
-        FileProvider.getUriForFile(
-            getApplicationContext(),
-            getApplicationContext().getPackageName() + ".provider",
-            new File(path));
+    File apkFile = new File(path);
     String APK_MIME_TYPE = "application/vnd.android.package-archive";
-    intent.setDataAndType(apkUri, APK_MIME_TYPE);
-    intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+
+    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
+      Uri apkUri =
+          FileProvider.getUriForFile(
+              getApplicationContext(),
+              getApplicationContext().getPackageName() + ".appdistro.fileprovider",
+              apkFile);
+      intent.setDataAndType(apkUri, APK_MIME_TYPE);
+      intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+    } else {
+      LogWrapper.getInstance().d("Requesting a vanilla URI");
+      intent.setDataAndType(Uri.fromFile(apkFile), APK_MIME_TYPE);
+    }
+
     mStartForResult.launch(intent);
   }