Persist DartCallbackCache contents across launches

lib/ui/plugins/callback_cache.cc

@@ -2,17 +2,39 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <fstream>
+#include <iterator>
+
 #include "flutter/lib/ui/plugins/callback_cache.h"
+#include "flutter/fml/build_config.h"
 #include "flutter/fml/logging.h"
+#include "flutter/fml/paths.h"
 #include "third_party/tonic/converter/dart_converter.h"
+#include "third_party/rapidjson/rapidjson/document.h"
+#include "third_party/rapidjson/rapidjson/stringbuffer.h"
+#include "third_party/rapidjson/rapidjson/writer.h"
 
 using tonic::ToDart;
+using rapidjson::Document;
+using rapidjson::StringBuffer;
+using rapidjson::Writer;
 
 namespace blink {
 
+static const char* kHandleKey = "handle";
+static const char* kRepresentationKey = "representation";
+static const char* kNameKey = "name";
+static const char* kClassNameKey = "class_name";
+static const char* kLibraryPathKey = "library_path";
+static const char* kCacheName = "flutter_callback_cache.json";
 std::mutex DartCallbackCache::mutex_;
+std::string DartCallbackCache::cache_path_;
 std::map<int64_t, DartCallbackRepresentation> DartCallbackCache::cache_;
 
+void DartCallbackCache::SetCachePath(const std::string& path) {
+  cache_path_ = fml::paths::JoinPaths({path, kCacheName});
+}
+
 Dart_Handle DartCallbackCache::GetCallback(int64_t handle) {
   std::lock_guard<std::mutex> lock(mutex_);
   auto iterator = cache_.find(handle);
@@ -34,6 +56,7 @@ int64_t DartCallbackCache::GetCallbackHandle(const std::string& name,
 
   if (cache_.find(hash) == cache_.end()) {
     cache_[hash] = {name, class_name, library_path};
+    SaveCacheToDisk();
   }
   return hash;
 }
@@ -48,6 +71,82 @@ DartCallbackCache::GetCallbackInformation(int64_t handle) {
   return nullptr;
 }
 
+void DartCallbackCache::SaveCacheToDisk() {
+  // Cache JSON format
+  // [
+  //   {
+  //      "hash": 42,
+  //      "representation": {
+  //          "name": "...",
+  //          "class_name": "...",
+  //          "library_path": "..."
+  //      }
+  //   },
+  //   {
+  //   ...
+  //   }
+  // ]
+  StringBuffer s;
+  Writer<StringBuffer> writer(s);
+  writer.StartArray();
+  for (auto iterator = cache_.begin(); iterator != cache_.end(); ++iterator) {
+    int64_t hash = iterator->first;
+    DartCallbackRepresentation cb = iterator->second;
+    writer.StartObject();
+    writer.Key(kHandleKey);
+    writer.Int64(hash);
+    writer.Key(kRepresentationKey);
+    writer.StartObject();
+    writer.Key(kNameKey);
+    writer.String(cb.name.c_str());
+    writer.Key(kClassNameKey);
+    writer.String(cb.class_name.c_str());
+    writer.Key(kLibraryPathKey);
+    writer.String(cb.library_path.c_str());
+    writer.EndObject();
+    writer.EndObject();
+  }
+  writer.EndArray();
+
+  std::ofstream output(cache_path_);
+  output << s.GetString();
+  output.close();
+}
+
+void DartCallbackCache::LoadCacheFromDisk() {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  // Don't reload the cache if it's already populated.
+  if (!cache_.empty()) {
+    return;
+  }
+  std::ifstream input(cache_path_);
+  if (!input) {
+    return;
+  }
+  std::string cache_contents{std::istreambuf_iterator<char>(input),
+                             std::istreambuf_iterator<char>()};
+  Document d;
+  d.Parse(cache_contents.c_str());
+  if (d.HasParseError() || !d.IsArray()) {
+    FML_LOG(WARNING) << "Could not parse callback cache, aborting restore";
+    // TODO(bkonyi): log and bail (delete cache?)
+    return;
+  }
+  const auto entries = d.GetArray();
+  for (auto it = entries.begin(); it != entries.end(); ++it) {
+    const auto root_obj = it->GetObject();
+    const auto representation = root_obj[kRepresentationKey].GetObject();
+
+    const int64_t hash = root_obj[kHandleKey].GetInt64();
+    DartCallbackRepresentation cb;
+    cb.name = representation[kNameKey].GetString();
+    cb.class_name = representation[kClassNameKey].GetString();
+    cb.library_path = representation[kLibraryPathKey].GetString();
+    cache_[hash] = cb;
+  }
+}
+
 Dart_Handle DartCallbackCache::LookupDartClosure(
     const std::string& name,
     const std::string& class_name,

lib/ui/plugins/callback_cache.h

@@ -14,8 +14,6 @@
 #include "flutter/fml/synchronization/thread_annotations.h"
 #include "third_party/dart/runtime/include/dart_api.h"
 
-#define DART_CALLBACK_INVALID_HANDLE -1
-
 namespace blink {
 
 typedef struct {
@@ -26,6 +24,7 @@ typedef struct {
 
 class DartCallbackCache {
  public:
+  static void SetCachePath(const std::string& path);
   static int64_t GetCallbackHandle(const std::string& name,
                                    const std::string& class_name,
                                    const std::string& library_path)
@@ -36,12 +35,17 @@ class DartCallbackCache {
   static std::unique_ptr<DartCallbackRepresentation> GetCallbackInformation(
       int64_t handle) FML_LOCKS_EXCLUDED(mutex_);
 
+  static void LoadCacheFromDisk() FML_LOCKS_EXCLUDED(mutex_);
+
  private:
   static Dart_Handle LookupDartClosure(const std::string& name,
                                        const std::string& class_name,
                                        const std::string& library_path);
 
+  static void SaveCacheToDisk() FML_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
   static std::mutex mutex_;
+  static std::string cache_path_;
 
   static std::map<int64_t, DartCallbackRepresentation> cache_
       FML_GUARDED_BY(mutex_);

shell/platform/android/flutter_main.cc

@@ -15,6 +15,7 @@
 #include "flutter/fml/message_loop.h"
 #include "flutter/fml/paths.h"
 #include "flutter/fml/platform/android/jni_util.h"
+#include "flutter/lib/ui/plugins/callback_cache.h"
 #include "flutter/runtime/dart_vm.h"
 #include "flutter/runtime/start_up.h"
 #include "flutter/shell/common/shell.h"
@@ -44,7 +45,8 @@ void FlutterMain::Init(JNIEnv* env,
                        jclass clazz,
                        jobject context,
                        jobjectArray jargs,
-                       jstring bundlePath) {
+                       jstring bundlePath,
+                       jstring appRootPath) {
   std::vector<std::string> args;
   args.push_back("flutter");
   for (auto& arg : fml::jni::StringArrayToVector(env, jargs)) {
@@ -56,6 +58,10 @@ void FlutterMain::Init(JNIEnv* env,
 
   settings.assets_path = fml::jni::JavaStringToString(env, bundlePath);
 
+  // Restore the callback cache.
+  blink::DartCallbackCache::SetCachePath(fml::jni::JavaStringToString(env, appRootPath));
+  blink::DartCallbackCache::LoadCacheFromDisk();
+
   if (!blink::DartVM::IsRunningPrecompiledCode()) {
     // Check to see if the appropriate kernel files are present and configure
     // settings accordingly.
@@ -97,7 +103,7 @@ bool FlutterMain::Register(JNIEnv* env) {
       {
           .name = "nativeInit",
           .signature = "(Landroid/content/Context;[Ljava/lang/String;Ljava/"
-                       "lang/String;)V",
+                       "lang/String;Ljava/lang/String;)V",
           .fnPtr = reinterpret_cast<void*>(&Init),
       },
       {

shell/platform/android/flutter_main.h

@@ -31,7 +31,8 @@ class FlutterMain {
                    jclass clazz,
                    jobject context,
                    jobjectArray jargs,
-                   jstring bundlePath);
+                   jstring bundlePath,
+                   jstring appRootPath);
 
   FML_DISALLOW_COPY_AND_ASSIGN(FlutterMain);
 };

shell/platform/android/io/flutter/util/PathUtils.java

@@ -7,6 +7,10 @@
 import android.content.Context;
 
 public final class PathUtils {
+    public static String getFilesDir(Context applicationContext) {
+        return applicationContext.getFilesDir().getPath();
+    }
+
     public static String getDataDirectory(Context applicationContext) {
         return applicationContext.getDir("flutter", Context.MODE_PRIVATE).getPath();
     }

shell/platform/android/io/flutter/view/FlutterMain.java

@@ -219,8 +219,9 @@ public static void ensureInitializationComplete(Context applicationContext, Stri
             }
 
             String appBundlePath = findAppBundlePath(applicationContext);
+            String appRootPath = PathUtils.getFilesDir(applicationContext);
             nativeInit(applicationContext, shellArgs.toArray(new String[0]),
-                appBundlePath);
+                appBundlePath, appRootPath);
 
             sInitialized = true;
         } catch (Exception e) {
@@ -229,7 +230,7 @@ public static void ensureInitializationComplete(Context applicationContext, Stri
         }
     }
 
-    private static native void nativeInit(Context context, String[] args, String bundlePath);
+    private static native void nativeInit(Context context, String[] args, String bundlePath, String appRootPath);
     private static native void nativeRecordStartTimestamp(long initTimeMillis);
 
     /**

shell/platform/darwin/ios/framework/Headers/FlutterPlugin.h

@@ -59,6 +59,15 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (BOOL)application:(UIApplication*)application
     didFinishLaunchingWithOptions:(NSDictionary*)launchOptions;
+
+/**
+ Called if this plugin has been registered for `UIApplicationDelegate` callbacks.
+
+ - Returns: `NO` if this plugin vetoes application launch.
+ */
+- (BOOL)application:(UIApplication*)application
+    willFinishLaunchingWithOptions:(NSDictionary*)launchOptions;
+
 /**
  Called if this plugin has been registered for `UIApplicationDelegate` callbacks.
  */

shell/platform/darwin/ios/framework/Headers/FlutterPluginAppLifeCycleDelegate.h

@@ -29,6 +29,14 @@ FLUTTER_EXPORT
 - (BOOL)application:(UIApplication*)application
     didFinishLaunchingWithOptions:(NSDictionary*)launchOptions;
 
+/**
+ Calls all plugins registered for `UIApplicationDelegate` callbacks.
+
+ - Returns: `NO` if any plugin vetoes application launch.
+ */
+- (BOOL)application:(UIApplication*)application
+    willFinishLaunchingWithOptions:(NSDictionary*)launchOptions;
+
 /**
  Calls all plugins registered for `UIApplicationDelegate` callbacks.
  */

shell/platform/darwin/ios/framework/Source/FlutterAppDelegate.mm

@@ -22,6 +22,11 @@ - (void)dealloc {
   [super dealloc];
 }
 
+- (BOOL)application:(UIApplication*)application
+    willFinishLaunchingWithOptions:(NSDictionary*)launchOptions {
+  return [_lifeCycleDelegate application:application willFinishLaunchingWithOptions:launchOptions];
+}
+
 - (BOOL)application:(UIApplication*)application
     didFinishLaunchingWithOptions:(NSDictionary*)launchOptions {
   return [_lifeCycleDelegate application:application didFinishLaunchingWithOptions:launchOptions];

shell/platform/darwin/ios/framework/Source/FlutterPluginAppLifeCycleDelegate.mm

@@ -2,10 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "flutter/lib/ui/plugins/callback_cache.h"
 #include "flutter/shell/platform/darwin/ios/framework/Headers/FlutterPluginAppLifeCycleDelegate.h"
 #include "flutter/fml/logging.h"
+#include "flutter/fml/paths.h"
 #include "flutter/shell/platform/darwin/ios/framework/Headers/FlutterViewController.h"
 
+static const char* kCallbackCacheSubDir = "Library/Caches/";
+
 @implementation FlutterPluginAppLifeCycleDelegate {
   UIBackgroundTaskIdentifier _debugBackgroundTask;
 
@@ -15,6 +19,8 @@ @implementation FlutterPluginAppLifeCycleDelegate {
 
 - (instancetype)init {
   if (self = [super init]) {
+    std::string cachePath = fml::paths::JoinPaths({getenv("HOME"), kCallbackCacheSubDir});
+    blink::DartCallbackCache::SetCachePath(cachePath);
     _pluginDelegates = [[NSPointerArray weakObjectsPointerArray] retain];
   }
   return self;
@@ -51,6 +57,22 @@ - (BOOL)application:(UIApplication*)application
   return YES;
 }
 
+- (BOOL)application:(UIApplication*)application
+    willFinishLaunchingWithOptions:(NSDictionary*)launchOptions {
+  blink::DartCallbackCache::LoadCacheFromDisk();
+  for (id<FlutterPlugin> plugin in [_pluginDelegates allObjects]) {
+    if (!plugin) {
+      continue;
+    }
+    if ([plugin respondsToSelector:_cmd]) {
+      if (![plugin application:application willFinishLaunchingWithOptions:launchOptions]) {
+        return NO;
+      }
+    }
+  }
+  return YES;
+}
+
 // Returns the key window's rootViewController, if it's a FlutterViewController.
 // Otherwise, returns nil.
 - (FlutterViewController*)rootFlutterViewController {