chrome/browser/android/shortcut_helper.cc

// Copyright 2013 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.

#include "chrome/browser/android/shortcut_helper.h"

#include <jni.h>
#include <utility>

#include "base/android/jni_android.h"
#include "base/android/jni_array.h"
#include "base/android/jni_string.h"
#include "base/bind.h"
#include "base/callback.h"
#include "base/guid.h"
#include "base/optional.h"
#include "base/strings/string16.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/thread_restrictions.h"
#include "base/time/time.h"
#include "chrome/browser/android/color_helpers.h"
#include "chrome/browser/android/webapk/chrome_webapk_host.h"
#include "chrome/browser/android/webapk/webapk_install_service.h"
#include "chrome/browser/android/webapk/webapk_metrics.h"
#include "chrome/common/chrome_switches.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/manifest_icon_downloader.h"
#include "content/public/browser/web_contents.h"
#include "jni/ShortcutHelper_jni.h"
#include "third_party/blink/public/common/manifest/manifest.h"
#include "third_party/blink/public/common/manifest/manifest_icon_selector.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/android/java_bitmap.h"
#include "ui/gfx/color_analysis.h"
#include "url/gurl.h"

using base::android::JavaParamRef;
using base::android::ScopedJavaLocalRef;

namespace {

int g_ideal_homescreen_icon_size = -1;
int g_minimum_homescreen_icon_size = -1;
int g_ideal_splash_image_size = -1;
int g_minimum_splash_image_size = -1;
int g_ideal_badge_icon_size = -1;

int g_default_rgb_icon_value = 145;

// Retrieves and caches the ideal and minimum sizes of the Home screen icon
// and the splash screen image.
void GetHomescreenIconAndSplashImageSizes() {
  JNIEnv* env = base::android::AttachCurrentThread();
  ScopedJavaLocalRef<jintArray> java_size_array =
      Java_ShortcutHelper_getHomeScreenIconAndSplashImageSizes(env);
  std::vector<int> sizes;
  base::android::JavaIntArrayToIntVector(env, java_size_array, &sizes);

  // Check that the size returned is what is expected.
  DCHECK(sizes.size() == 5);

  // This ordering must be kept up to date with the Java ShortcutHelper.
  g_ideal_homescreen_icon_size = sizes[0];
  g_minimum_homescreen_icon_size = sizes[1];
  g_ideal_splash_image_size = sizes[2];
  g_minimum_splash_image_size = sizes[3];
  g_ideal_badge_icon_size = sizes[4];

  // Try to ensure that the data returned is sane.
  DCHECK(g_minimum_homescreen_icon_size <= g_ideal_homescreen_icon_size);
  DCHECK(g_minimum_splash_image_size <= g_ideal_splash_image_size);
}

// Adds a shortcut which opens in a fullscreen window to the launcher.
// |splash_image_callback| will be invoked once the Java-side operation has
// completed. This is necessary as Java will asynchronously create and
// populate a WebappDataStorage object for standalone-capable sites. This must
// exist before the splash image can be stored.
void AddWebappWithSkBitmap(const ShortcutInfo& info,
                           const std::string& webapp_id,
                           const SkBitmap& icon_bitmap,
                           bool is_icon_maskable,
                           base::OnceClosure splash_image_callback) {
  // Send the data to the Java side to create the shortcut.
  JNIEnv* env = base::android::AttachCurrentThread();
  ScopedJavaLocalRef<jstring> java_webapp_id =
      base::android::ConvertUTF8ToJavaString(env, webapp_id);
  ScopedJavaLocalRef<jstring> java_url =
      base::android::ConvertUTF8ToJavaString(env, info.url.spec());
  ScopedJavaLocalRef<jstring> java_scope_url =
      base::android::ConvertUTF8ToJavaString(env, info.scope.spec());
  ScopedJavaLocalRef<jstring> java_user_title =
      base::android::ConvertUTF16ToJavaString(env, info.user_title);
  ScopedJavaLocalRef<jstring> java_name =
      base::android::ConvertUTF16ToJavaString(env, info.name);
  ScopedJavaLocalRef<jstring> java_short_name =
      base::android::ConvertUTF16ToJavaString(env, info.short_name);
  ScopedJavaLocalRef<jstring> java_best_primary_icon_url =
      base::android::ConvertUTF8ToJavaString(env,
                                             info.best_primary_icon_url.spec());
  ScopedJavaLocalRef<jstring> java_splash_screen_url =
      base::android::ConvertUTF8ToJavaString(env,
                                             info.splash_screen_url.spec());
  ScopedJavaLocalRef<jobject> java_bitmap;
  if (!icon_bitmap.drawsNothing())
    java_bitmap = gfx::ConvertToJavaBitmap(&icon_bitmap);

  // The callback will need to be run after shortcut creation completes in order
  // to download the splash image and save it to the WebappDataStorage. Create a
  // copy of the callback here and send the pointer to Java, which will send it
  // back once the asynchronous shortcut creation process finishes.
  uintptr_t callback_pointer = reinterpret_cast<uintptr_t>(
      new base::OnceClosure(std::move(splash_image_callback)));

  Java_ShortcutHelper_addWebapp(
      env, java_webapp_id, java_url, java_scope_url, java_user_title, java_name,
      java_short_name, java_best_primary_icon_url, java_bitmap,
      is_icon_maskable, info.display, info.orientation, info.source,
      OptionalSkColorToJavaColor(info.theme_color),
      OptionalSkColorToJavaColor(info.background_color), java_splash_screen_url,
      callback_pointer);
}

// Adds a shortcut which opens in a browser tab to the launcher.
void AddShortcutWithSkBitmap(const ShortcutInfo& info,
                             const std::string& id,
                             const SkBitmap& icon_bitmap,
                             bool is_icon_maskable) {
  JNIEnv* env = base::android::AttachCurrentThread();
  ScopedJavaLocalRef<jstring> java_id =
      base::android::ConvertUTF8ToJavaString(env, id);
  ScopedJavaLocalRef<jstring> java_url =
      base::android::ConvertUTF8ToJavaString(env, info.url.spec());
  ScopedJavaLocalRef<jstring> java_user_title =
      base::android::ConvertUTF16ToJavaString(env, info.user_title);
  ScopedJavaLocalRef<jobject> java_bitmap;
  if (!icon_bitmap.drawsNothing())
    java_bitmap = gfx::ConvertToJavaBitmap(&icon_bitmap);

  Java_ShortcutHelper_addShortcut(env, java_id, java_url, java_user_title,
                                  java_bitmap, is_icon_maskable, info.source);
}

}  // anonymous namespace

// static
std::unique_ptr<ShortcutInfo> ShortcutHelper::CreateShortcutInfo(
    const GURL& manifest_url,
    const blink::Manifest& manifest,
    const GURL& primary_icon_url,
    const GURL& badge_icon_url) {
  auto shortcut_info = std::make_unique<ShortcutInfo>(GURL());
  if (!manifest.IsEmpty()) {
    shortcut_info->UpdateFromManifest(manifest);
    shortcut_info->manifest_url = manifest_url;
    shortcut_info->best_primary_icon_url = primary_icon_url;
    shortcut_info->best_badge_icon_url = badge_icon_url;
  }

  shortcut_info->ideal_splash_image_size_in_px = GetIdealSplashImageSizeInPx();
  shortcut_info->minimum_splash_image_size_in_px =
      GetMinimumSplashImageSizeInPx();
  shortcut_info->splash_image_url =
      blink::ManifestIconSelector::FindBestMatchingIcon(
          manifest.icons, shortcut_info->ideal_splash_image_size_in_px,
          shortcut_info->minimum_splash_image_size_in_px,
          blink::Manifest::ImageResource::Purpose::ANY);

  return shortcut_info;
}

// static
void ShortcutHelper::AddToLauncherWithSkBitmap(
    content::WebContents* web_contents,
    const ShortcutInfo& info,
    const SkBitmap& icon_bitmap,
    bool is_icon_maskable) {
  std::string webapp_id = base::GenerateGUID();
  if (info.display == blink::kWebDisplayModeStandalone ||
      info.display == blink::kWebDisplayModeFullscreen ||
      info.display == blink::kWebDisplayModeMinimalUi) {
    AddWebappWithSkBitmap(
        info, webapp_id, icon_bitmap, is_icon_maskable,
        base::BindOnce(&ShortcutHelper::FetchSplashScreenImage, web_contents,
                       info.splash_image_url,
                       info.ideal_splash_image_size_in_px,
                       info.minimum_splash_image_size_in_px, webapp_id));
    return;
  }
  AddShortcutWithSkBitmap(info, webapp_id, icon_bitmap, is_icon_maskable);
}

void ShortcutHelper::ShowWebApkInstallInProgressToast() {
  Java_ShortcutHelper_showWebApkInstallInProgressToast(
      base::android::AttachCurrentThread());
}

int ShortcutHelper::GetIdealHomescreenIconSizeInPx() {
  if (g_ideal_homescreen_icon_size == -1)
    GetHomescreenIconAndSplashImageSizes();
  return g_ideal_homescreen_icon_size;
}

int ShortcutHelper::GetMinimumHomescreenIconSizeInPx() {
  if (g_minimum_homescreen_icon_size == -1)
    GetHomescreenIconAndSplashImageSizes();
  return g_minimum_homescreen_icon_size;
}

int ShortcutHelper::GetIdealSplashImageSizeInPx() {
  if (g_ideal_splash_image_size == -1)
    GetHomescreenIconAndSplashImageSizes();
  return g_ideal_splash_image_size;
}

int ShortcutHelper::GetMinimumSplashImageSizeInPx() {
  if (g_minimum_splash_image_size == -1)
    GetHomescreenIconAndSplashImageSizes();
  return g_minimum_splash_image_size;
}

int ShortcutHelper::GetIdealBadgeIconSizeInPx() {
  if (g_ideal_badge_icon_size == -1)
    GetHomescreenIconAndSplashImageSizes();
  return g_ideal_badge_icon_size;
}

// static
void ShortcutHelper::FetchSplashScreenImage(
    content::WebContents* web_contents,
    const GURL& image_url,
    const int ideal_splash_image_size_in_px,
    const int minimum_splash_image_size_in_px,
    const std::string& webapp_id) {
  // This is a fire and forget task. It is not vital for the splash screen image
  // to be downloaded so if the downloader returns false there is no fallback.
  content::ManifestIconDownloader::Download(
      web_contents, image_url, ideal_splash_image_size_in_px,
      minimum_splash_image_size_in_px,
      base::BindOnce(&ShortcutHelper::StoreWebappSplashImage, webapp_id));
}

// static
void ShortcutHelper::StoreWebappSplashImage(const std::string& webapp_id,
                                            const SkBitmap& splash_image) {
  if (splash_image.drawsNothing())
    return;

  JNIEnv* env = base::android::AttachCurrentThread();
  ScopedJavaLocalRef<jstring> java_webapp_id =
      base::android::ConvertUTF8ToJavaString(env, webapp_id);
  ScopedJavaLocalRef<jobject> java_splash_image =
      gfx::ConvertToJavaBitmap(&splash_image);

  Java_ShortcutHelper_storeWebappSplashImage(env, java_webapp_id,
                                             java_splash_image);
}

// static
SkBitmap ShortcutHelper::FinalizeLauncherIconInBackground(
    const SkBitmap& bitmap,
    bool is_icon_maskable,
    const GURL& url,
    bool* is_generated) {
  base::AssertLongCPUWorkAllowed();

  JNIEnv* env = base::android::AttachCurrentThread();
  ScopedJavaLocalRef<jobject> result;
  *is_generated = false;

  if (!bitmap.isNull()) {
    if (Java_ShortcutHelper_isIconLargeEnoughForLauncher(env, bitmap.width(),
                                                         bitmap.height())) {
      ScopedJavaLocalRef<jobject> java_bitmap =
          gfx::ConvertToJavaBitmap(&bitmap);
      result = Java_ShortcutHelper_createHomeScreenIconFromWebIcon(
          env, java_bitmap, is_icon_maskable);
    }
  }

  if (result.is_null()) {
    ScopedJavaLocalRef<jstring> java_url =
        base::android::ConvertUTF8ToJavaString(env, url.spec());
    SkColor mean_color =
        SkColorSetRGB(g_default_rgb_icon_value, g_default_rgb_icon_value,
                      g_default_rgb_icon_value);

    if (!bitmap.isNull())
      mean_color = color_utils::CalculateKMeanColorOfBitmap(bitmap);

    *is_generated = true;
    result = Java_ShortcutHelper_generateHomeScreenIcon(
        env, java_url, SkColorGetR(mean_color), SkColorGetG(mean_color),
        SkColorGetB(mean_color));
  }

  return result.obj()
             ? gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(result))
             : SkBitmap();
}

// static
std::string ShortcutHelper::QueryFirstWebApkPackage(const GURL& url) {
  JNIEnv* env = base::android::AttachCurrentThread();
  ScopedJavaLocalRef<jstring> java_url =
      base::android::ConvertUTF8ToJavaString(env, url.spec());
  ScopedJavaLocalRef<jstring> java_webapk_package_name =
      Java_ShortcutHelper_queryFirstWebApkPackage(env, java_url);

  std::string webapk_package_name = "";
  if (java_webapk_package_name.obj()) {
    webapk_package_name =
        base::android::ConvertJavaStringToUTF8(env, java_webapk_package_name);
  }
  return webapk_package_name;
}

// static
bool ShortcutHelper::IsWebApkInstalled(content::BrowserContext* browser_context,
                                       const GURL& start_url,
                                       const GURL& manifest_url) {
  return !QueryFirstWebApkPackage(start_url).empty() ||
         WebApkInstallService::Get(browser_context)
             ->IsInstallInProgress(manifest_url);
}

GURL ShortcutHelper::GetScopeFromURL(const GURL& url) {
  JNIEnv* env = base::android::AttachCurrentThread();
  ScopedJavaLocalRef<jstring> java_url =
      base::android::ConvertUTF8ToJavaString(env, url.spec());
  ScopedJavaLocalRef<jstring> java_scope_url =
      Java_ShortcutHelper_getScopeFromUrl(env, java_url);
  return GURL(base::android::ConvertJavaStringToUTF16(env, java_scope_url));
}

void ShortcutHelper::RetrieveWebApks(const WebApkInfoCallback& callback) {
  uintptr_t callback_pointer =
      reinterpret_cast<uintptr_t>(new WebApkInfoCallback(callback));
  Java_ShortcutHelper_retrieveWebApks(base::android::AttachCurrentThread(),
                                      callback_pointer);
}

// Callback used by Java when the shortcut has been created.
// |splash_image_callback| is a pointer to a base::OnceClosure allocated in
// AddShortcutWithSkBitmap, so reinterpret_cast it back and run it.
//
// This callback should only ever be called when the shortcut was for a
// webapp-capable site; otherwise, |splash_image_callback| will have never been
// allocated and doesn't need to be run or deleted.
void JNI_ShortcutHelper_OnWebappDataStored(JNIEnv* env,
                                           jlong jsplash_image_callback) {
  DCHECK(jsplash_image_callback);
  base::OnceClosure* splash_image_callback =
      reinterpret_cast<base::OnceClosure*>(jsplash_image_callback);
  std::move(*splash_image_callback).Run();
  delete splash_image_callback;
}

void JNI_ShortcutHelper_OnWebApksRetrieved(
    JNIEnv* env,
    const jlong jcallback_pointer,
    const JavaParamRef<jobjectArray>& jnames,
    const JavaParamRef<jobjectArray>& jshort_names,
    const JavaParamRef<jobjectArray>& jpackage_names,
    const JavaParamRef<jintArray>& jshell_apk_versions,
    const JavaParamRef<jintArray>& jversion_codes,
    const JavaParamRef<jobjectArray>& juris,
    const JavaParamRef<jobjectArray>& jscopes,
    const JavaParamRef<jobjectArray>& jmanifest_urls,
    const JavaParamRef<jobjectArray>& jmanifest_start_urls,
    const JavaParamRef<jintArray>& jdisplay_modes,
    const JavaParamRef<jintArray>& jorientations,
    const JavaParamRef<jlongArray>& jtheme_colors,
    const JavaParamRef<jlongArray>& jbackground_colors,
    const JavaParamRef<jlongArray>& jlast_update_check_times_ms,
    const JavaParamRef<jbooleanArray>& jrelax_updates) {
  DCHECK(jcallback_pointer);
  std::vector<std::string> names;
  base::android::AppendJavaStringArrayToStringVector(env, jnames, &names);
  std::vector<std::string> short_names;
  base::android::AppendJavaStringArrayToStringVector(env, jshort_names,
                                                     &short_names);
  std::vector<std::string> package_names;
  base::android::AppendJavaStringArrayToStringVector(env, jpackage_names,
                                                     &package_names);
  std::vector<int> shell_apk_versions;
  base::android::JavaIntArrayToIntVector(env, jshell_apk_versions,
                                         &shell_apk_versions);
  std::vector<int> version_codes;
  base::android::JavaIntArrayToIntVector(env, jversion_codes, &version_codes);
  std::vector<std::string> uris;
  base::android::AppendJavaStringArrayToStringVector(env, juris, &uris);
  std::vector<std::string> scopes;
  base::android::AppendJavaStringArrayToStringVector(env, jscopes, &scopes);
  std::vector<std::string> manifest_urls;
  base::android::AppendJavaStringArrayToStringVector(env, jmanifest_urls,
                                                     &manifest_urls);
  std::vector<std::string> manifest_start_urls;
  base::android::AppendJavaStringArrayToStringVector(env, jmanifest_start_urls,
                                                     &manifest_start_urls);
  std::vector<int> display_modes;
  base::android::JavaIntArrayToIntVector(env, jdisplay_modes, &display_modes);
  std::vector<int> orientations;
  base::android::JavaIntArrayToIntVector(env, jorientations, &orientations);
  std::vector<int64_t> theme_colors;
  base::android::JavaLongArrayToInt64Vector(env, jtheme_colors, &theme_colors);
  std::vector<int64_t> background_colors;
  base::android::JavaLongArrayToInt64Vector(env, jbackground_colors,
                                            &background_colors);
  std::vector<int64_t> last_update_check_times_ms;
  base::android::JavaLongArrayToInt64Vector(env, jlast_update_check_times_ms,
                                            &last_update_check_times_ms);
  std::vector<bool> relax_updates;
  base::android::JavaBooleanArrayToBoolVector(env, jrelax_updates,
                                              &relax_updates);

  DCHECK(short_names.size() == names.size());
  DCHECK(short_names.size() == package_names.size());
  DCHECK(short_names.size() == shell_apk_versions.size());
  DCHECK(short_names.size() == version_codes.size());
  DCHECK(short_names.size() == uris.size());
  DCHECK(short_names.size() == scopes.size());
  DCHECK(short_names.size() == manifest_urls.size());
  DCHECK(short_names.size() == manifest_start_urls.size());
  DCHECK(short_names.size() == display_modes.size());
  DCHECK(short_names.size() == orientations.size());
  DCHECK(short_names.size() == theme_colors.size());
  DCHECK(short_names.size() == background_colors.size());
  DCHECK(short_names.size() == last_update_check_times_ms.size());
  DCHECK(short_names.size() == relax_updates.size());

  std::vector<WebApkInfo> webapk_list;
  webapk_list.reserve(short_names.size());
  for (size_t i = 0; i < short_names.size(); ++i) {
    webapk_list.push_back(WebApkInfo(
        std::move(names[i]), std::move(short_names[i]),
        std::move(package_names[i]), shell_apk_versions[i], version_codes[i],
        std::move(uris[i]), std::move(scopes[i]), std::move(manifest_urls[i]),
        std::move(manifest_start_urls[i]),
        static_cast<blink::WebDisplayMode>(display_modes[i]),
        static_cast<blink::WebScreenOrientationLockType>(orientations[i]),
        JavaColorToOptionalSkColor(theme_colors[i]),
        JavaColorToOptionalSkColor(background_colors[i]),
        base::Time::FromJavaTime(last_update_check_times_ms[i]),
        relax_updates[i]));
  }

  ShortcutHelper::WebApkInfoCallback* webapk_list_callback =
      reinterpret_cast<ShortcutHelper::WebApkInfoCallback*>(jcallback_pointer);
  webapk_list_callback->Run(webapk_list);
  delete webapk_list_callback;
}