Do screenshot capture async for share intents.

chrome/android/java/src/org/chromium/chrome/browser/share/ShareHelper.java

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.share;
 
 import android.annotation.TargetApi;
 import android.app.Activity;
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
@@ skipping 24 matching lines @@
 
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.ApplicationState;
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.ContextUtils;
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.chrome.R;
+import org.chromium.chrome.browser.ChromeFileProvider;
 import org.chromium.components.dom_distiller.core.DomDistillerUrlUtils;
 import org.chromium.ui.UiUtils;
 
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
@@ skipping 150 matching lines @@
      *
      * @param shareDirectly Whether it should share directly with the activity that was most
      *                      recently used to share.
      * @param saveLastUsed Whether to save the chosen activity for future direct sharing.
      * @param activity Activity that is used to access package manager.
      * @param title Title of the page to be shared.
      * @param text Text to be shared. If both |text| and |url| are supplied, they are concatenated
      *             with a space.
      * @param url URL of the page to be shared.
      * @param offlineUri URI to the offline MHTML file to be shared.
-     * @param screenshot Screenshot of the page to be shared.
+     * @param screenshotUri Uri of the screenshot of the page to be shared.
      * @param callback Optional callback to be called when user makes a choice. Will not be called
      *                 if receiving a response when the user makes a choice is not supported (on
      *                 older Android versions).
      */
     public static void share(boolean shareDirectly, boolean saveLastUsed, Activity activity,
-            String title, String text, String url, @Nullable Uri offlineUri, Bitmap screenshot,
+            String title, String text, String url, @Nullable Uri offlineUri, Uri screenshotUri,
             @Nullable TargetChosenCallback callback) {
         if (shareDirectly) {
-            shareWithLastUsed(activity, title, text, url, offlineUri, screenshot);
+            shareWithLastUsed(activity, title, text, url, offlineUri, screenshotUri);
         } else if (TargetChosenReceiver.isSupported()) {
-            makeIntentAndShare(saveLastUsed, activity, title, text, url, offlineUri, screenshot,
+            makeIntentAndShare(saveLastUsed, activity, title, text, url, offlineUri, screenshotUri,
                     null, callback);
         } else {
             showShareDialog(
-                    saveLastUsed, activity, title, text, url, offlineUri, screenshot, callback);
+                    saveLastUsed, activity, title, text, url, offlineUri, screenshotUri, callback);
         }
     }
 
     /**
      * Trigger the share action for the given image data.
      * @param activity The activity used to trigger the share action.
      * @param jpegImageData The image data to be shared in jpeg format.
      */
     public static void shareImage(final Activity activity, final byte[] jpegImageData) {
         if (jpegImageData.length == 0) {
@@ skipping 43 matching lines @@
 
                     Intent chooserIntent = Intent.createChooser(getShareImageIntent(imageUri),
                             activity.getString(R.string.share_link_chooser_title));
                     activity.startActivity(chooserIntent);
                 }
             }
         }.execute();
     }
 
     /**
+     * Writes the screenshot file and notifies the file provider that the file is ready to be
+     * accessed by the client.
+     *
+     * The bitmap is compressed to JPEG before being written to the file.
+     *
+     * @param blockingUri The unique id given by the
+     *    {@link ChromeFileProvider#generateUriAndBlockAccess()} for the screenshot.

[Ted C, 2016/09/07 00:30:08]

align with "The unique" above

[ssid, 2016/09/07 00:51:23]

Done.

+     * @param screenshot The screenshot bitmap to be written to file.
+     * @param activity Activity that is used to access package manager.
+     */
+    public static void onScreenshotReady(
+            final Uri blockingUri, final Bitmap screenshot, final Activity activity) {
+        if (screenshot == null) {
+            ChromeFileProvider.notifyFileReady(blockingUri, null);
+            return;
+        }
+
+        new AsyncTask<Void, Void, File>() {
+            @Override
+            protected File doInBackground(Void... params) {
+                FileOutputStream fOut = null;
+                try {
+                    File path = new File(UiUtils.getDirectoryForImageCapture(activity) + "/"
+                            + SHARE_IMAGES_DIRECTORY_NAME);
+                    if (path.exists() || path.mkdir()) {
+                        String fileName = String.valueOf(System.currentTimeMillis());
+                        File saveFile = File.createTempFile(fileName, JPEG_EXTENSION, path);
+                        fOut = new FileOutputStream(saveFile);
+                        screenshot.compress(Bitmap.CompressFormat.JPEG, 85, fOut);
+                        fOut.flush();
+                        fOut.close();
+                        return saveFile;
+                    }
+                } catch (IOException ie) {
+                    if (fOut != null) {
+                        try {
+                            fOut.close();
+                        } catch (IOException e) {
+                            // Ignore exception.
+                        }
+                    }
+                }
+
+                return null;
+            }
+
+            @Override
+            protected void onPostExecute(File saveFile) {
+                Uri fileUri = null;
+                if (ApplicationStatus.getStateForApplication()
+                        != ApplicationState.HAS_DESTROYED_ACTIVITIES
+                        && saveFile != null) {
+                    fileUri = UiUtils.getUriForImageCaptureFile(activity, saveFile);
+                }
+                ChromeFileProvider.notifyFileReady(blockingUri, fileUri);
+            }
+        }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
+    }
+
+    /**
      * Creates and shows a share intent picker dialog.
      *
      * @param saveLastUsed Whether to save the chosen activity for future direct sharing.
      * @param activity Activity that is used to access package manager.
      * @param title Title of the page to be shared.
      * @param text Text to be shared. If both |text| and |url| are supplied, they are concatenated
      *             with a space.
      * @param url URL of the page to be shared.
-     * @oaram Uri URI of the offline page to be shared.
-     * @param screenshot Screenshot of the page to be shared.
+     * @oaram offlineUri URI of the offline page to be shared.
+     * @param screenshotUri Uri of the screenshot of the page to be shared.
      * @param callback Optional callback to be called when user makes a choice. Will not be called
      *                 if receiving a response when the user makes a choice is not supported (on
      *                 older Android versions).
      */
     private static void showShareDialog(final boolean saveLastUsed, final Activity activity,
             final String title, final String text, final String url, final Uri offlineUri,
-            final Bitmap screenshot, @Nullable final TargetChosenCallback callback) {
+            final Uri screenshotUri, @Nullable final TargetChosenCallback callback) {
         Intent intent = getShareIntent(activity, title, text, url, null, null);
         PackageManager manager = activity.getPackageManager();
         List<ResolveInfo> resolveInfoList = manager.queryIntentActivities(intent, 0);
         assert resolveInfoList.size() > 0;
         if (resolveInfoList.size() == 0) return;
         Collections.sort(resolveInfoList, new ResolveInfo.DisplayNameComparator(manager));
 
         final ShareDialogAdapter adapter =
                 new ShareDialogAdapter(activity, manager, resolveInfoList);
         AlertDialog.Builder builder = new AlertDialog.Builder(activity, R.style.AlertDialogTheme);
         builder.setTitle(activity.getString(R.string.share_link_chooser_title));
         builder.setAdapter(adapter, null);
 
         final AlertDialog dialog = builder.create();
         dialog.show();
         dialog.getListView().setOnItemClickListener(new OnItemClickListener() {
             @Override
             public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                 ResolveInfo info = adapter.getItem(position);
                 ActivityInfo ai = info.activityInfo;
                 ComponentName component =
                         new ComponentName(ai.applicationInfo.packageName, ai.name);
                 if (callback != null) callback.onTargetChosen(component);
                 if (saveLastUsed) setLastShareComponentName(component);
-                makeIntentAndShare(
-                        false, activity, title, text, url, offlineUri, screenshot, component, null);
+                makeIntentAndShare(false, activity, title, text, url, offlineUri, screenshotUri,
+                        component, null);
                 dialog.dismiss();
             }
         });
     }
 
     /**
      * Starts a share intent with the activity that was most recently used to share.
      * If there is no most recently used activity, it does nothing.
      * @param activity Activity that is used to start the share intent.
      * @param title Title of the page to be shared.
      * @param text Text to be shared. If both |text| and |url| are supplied, they are concatenated
      *             with a space.
      * @param url URL of the page to be shared.
-     * @oaram Uri URI of the offline page to be shared.
-     * @param screenshot Screenshot of the page to be shared.
+     * @oaram offlineUri URI of the offline page to be shared.
+     * @param screenshotUri Uri of the screenshot of the page to be shared.
      */
     private static void shareWithLastUsed(Activity activity, String title, String text, String url,
-            Uri offlineUri, Bitmap screenshot) {
+            Uri offlineUri, Uri screenshotUri) {
         ComponentName component = getLastShareComponentName();
         if (component == null) return;
         makeIntentAndShare(
-                false, activity, title, text, url, offlineUri, screenshot, component, null);
+                false, activity, title, text, url, offlineUri, screenshotUri, component, null);
     }
 
     private static void shareIntent(boolean saveLastUsed, Activity activity, Intent sharingIntent,
                                     @Nullable TargetChosenCallback callback) {
         if (sharingIntent.getComponent() != null) {
             // If a component was specified, there should not also be a callback.
             assert callback == null;
             activity.startActivity(sharingIntent);
         } else {
             assert TargetChosenReceiver.isSupported();
             TargetChosenReceiver.sendChooserIntent(saveLastUsed, activity, sharingIntent, callback);
         }
     }
 
     private static void makeIntentAndShare(final boolean saveLastUsed, final Activity activity,
             final String title, final String text, final String url, final Uri offlineUri,
-            final Bitmap screenshot, final ComponentName component,
+            final Uri screenshotUri, final ComponentName component,
             @Nullable final TargetChosenCallback callback) {
-        if (screenshot == null) {
-            Intent intent = getDirectShareIntentForComponent(
-                    activity, title, text, url, offlineUri, null, component);
-            shareIntent(saveLastUsed, activity, intent, callback);
-        } else {
-            new AsyncTask<Void, Void, File>() {
-                @Override
-                protected File doInBackground(Void... params) {
-                    FileOutputStream fOut = null;
-                    try {
-                        File path = new File(UiUtils.getDirectoryForImageCapture(activity),
-                                SHARE_IMAGES_DIRECTORY_NAME);
-                        if (path.exists() || path.mkdir()) {
-                            File saveFile = File.createTempFile(
-                                    String.valueOf(System.currentTimeMillis()),
-                                    JPEG_EXTENSION, path);
-                            fOut = new FileOutputStream(saveFile);
-                            screenshot.compress(Bitmap.CompressFormat.JPEG, 85, fOut);
-                            fOut.flush();
-                            fOut.close();
-
-                            return saveFile;
-                        }
-                    } catch (IOException ie) {
-                        if (fOut != null) {
-                            try {
-                                fOut.close();
-                            } catch (IOException e) {
-                                // Ignore exception.
-                            }
-                        }
-                    }
-
-                    return null;
-                }
-
-                @Override
-                protected void onPostExecute(File saveFile) {
-                    if (ApplicationStatus.getStateForApplication()
-                            != ApplicationState.HAS_DESTROYED_ACTIVITIES) {
-                        Uri screenshotUri = saveFile == null
-                                ? null : UiUtils.getUriForImageCaptureFile(activity, saveFile);
-                        shareIntent(saveLastUsed, activity,
-                                getDirectShareIntentForComponent(activity, title, text, url,
-                                            offlineUri, screenshotUri, component),
-                                callback);
-                    }
-                }
-            }.execute();
-        }
+        Intent intent = getDirectShareIntentForComponent(
+                activity, title, text, url, offlineUri, screenshotUri, component);
+        shareIntent(saveLastUsed, activity, intent, callback);
     }
 
     /**
      * Set the icon and the title for the menu item used for direct share.
      *
      * @param activity Activity that is used to access the package manager.
      * @param item The menu item that is used for direct share
      */
     public static void configureDirectShareMenuItem(Activity activity, MenuItem item) {
         Drawable directShareIcon = null;
@@ skipping 53 matching lines @@
                     "Android.IsLastSharedAppInfoRetrieved", retrieved);
         }
 
         item.setIcon(directShareIcon);
         if (directShareTitle != null) {
             item.setTitle(activity.getString(R.string.accessibility_menu_share_via,
                     directShareTitle));
         }
     }
 
+    /*
+     * Stores the component selected for sharing last time share was called.
+     *
+     * This method is public since it is used in tests to avoid creating share dialog.
+     */
+    @VisibleForTesting
+    public static void setLastShareComponentName(ComponentName component) {
+        SharedPreferences preferences = ContextUtils.getAppSharedPreferences();
+        SharedPreferences.Editor editor = preferences.edit();
+        editor.putString(PACKAGE_NAME_KEY, component.getPackageName());
+        editor.putString(CLASS_NAME_KEY, component.getClassName());
+        editor.apply();
+    }
+
     @VisibleForTesting
     public static Intent getShareIntent(Activity activity, String title, String text, String url,
             Uri offlineUri, Uri screenshotUri) {
         if (!TextUtils.isEmpty(url)) {
             url = DomDistillerUrlUtils.getOriginalUrlFromDistillerUrl(url);
             if (!TextUtils.isEmpty(text)) {
                 // Concatenate text and URL with a space.
                 text = text + " " + url;
             } else {
                 text = url;
@@ skipping 43 matching lines @@
         return intent;
     }
 
     private static ComponentName getLastShareComponentName() {
         SharedPreferences preferences = ContextUtils.getAppSharedPreferences();
         String packageName = preferences.getString(PACKAGE_NAME_KEY, null);
         String className = preferences.getString(CLASS_NAME_KEY, null);
         if (packageName == null || className == null) return null;
         return new ComponentName(packageName, className);
     }
-
-    private static void setLastShareComponentName(ComponentName component) {
-        SharedPreferences preferences = ContextUtils.getAppSharedPreferences();
-        SharedPreferences.Editor editor = preferences.edit();
-        editor.putString(PACKAGE_NAME_KEY, component.getPackageName());
-        editor.putString(CLASS_NAME_KEY, component.getClassName());
-        editor.apply();
-    }
 }