Add auto plugin registration to FlutterFragmentActivity as well

Author: xster

shell/platform/android/io/flutter/embedding/android/FlutterFragmentActivity.java

@@ -41,6 +41,7 @@
 import io.flutter.embedding.engine.FlutterShellArgs;
 import io.flutter.plugin.platform.PlatformPlugin;
 import io.flutter.view.FlutterMain;
+import java.lang.reflect.Method;
 
 /**
  * A Flutter {@code Activity} that is based upon {@link FragmentActivity}.
@@ -554,13 +555,18 @@ public FlutterEngine provideFlutterEngine(@NonNull Context context) {
   }
 
   /**
-   * Hook for subclasses to easily configure a {@code FlutterEngine}, e.g., register plugins.
+   * Hook for subclasses to easily configure a {@code FlutterEngine}.
    *
    * <p>This method is called after {@link #provideFlutterEngine(Context)}.
+   *
+   * <p>All plugins listed in the app's pubspec are registered in the base implementation of this
+   * method. To avoid automatic plugin registration, override this method without invoking super().
+   * To keep automatic plugin registration and further configure the flutterEngine, override this
+   * method, invoke super(), and then configure the flutterEngine as desired.
    */
   @Override
   public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
-    // No-op. Hook for subclasses.
+    registerPlugins(flutterEngine);
   }
 
   /**
@@ -710,4 +716,34 @@ protected RenderMode getRenderMode() {
   private boolean isDebuggable() {
     return (getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
   }
+
+  /**
+   * Registers all plugins that an app lists in its pubspec.yaml.
+   *
+   * <p>The Flutter tool generates a class called GeneratedPluginRegistrant, which includes the code
+   * necessary to register every plugin in the pubspec.yaml with a given {@code FlutterEngine}. The
+   * GeneratedPluginRegistrant must be generated per app, because each app uses different sets of
+   * plugins. Therefore, the Android embedding cannot place a compile-time dependency on this
+   * generated class. This method uses reflection to attempt to locate the generated file and then
+   * use it at runtime.
+   *
+   * <p>This method fizzles if the GeneratedPluginRegistrant cannot be found or invoked. This
+   * situation should never occur, but if any eventuality comes up that prevents an app from using
+   * this behavior, that app can still write code that explicitly registers plugins.
+   */
+  private static void registerPlugins(@NonNull FlutterEngine flutterEngine) {
+    try {
+      Class<?> generatedPluginRegistrant =
+          Class.forName("io.flutter.plugins.GeneratedPluginRegistrant");
+      Method registrationMethod =
+          generatedPluginRegistrant.getDeclaredMethod("registerWith", FlutterEngine.class);
+      registrationMethod.invoke(null, flutterEngine);
+    } catch (Exception e) {
+      Log.w(
+          TAG,
+          "Tried to automatically register plugins with FlutterEngine ("
+              + flutterEngine
+              + ") but could not find and invoke the GeneratedPluginRegistrant.");
+    }
+  }
 }

shell/platform/android/test/io/flutter/embedding/android/FlutterFragmentActivityTest.java

@@ -1,18 +1,40 @@
 package io.flutter.embedding.android;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
+import android.content.Context;
 import android.content.Intent;
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import io.flutter.embedding.android.FlutterActivityLaunchConfigs.BackgroundMode;
+import io.flutter.embedding.engine.FlutterEngine;
+import io.flutter.embedding.engine.FlutterJNI;
+import io.flutter.embedding.engine.loader.FlutterLoader;
+import io.flutter.plugins.GeneratedPluginRegistrant;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.robolectric.Robolectric;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.annotation.Config;
 
 @Config(manifest = Config.NONE)
 @RunWith(RobolectricTestRunner.class)
 public class FlutterFragmentActivityTest {
+  @Before
+  public void setUp() {
+    GeneratedPluginRegistrant.clearRegisteredEngines();
+  }
+
+  @After
+  public void tearDown() {
+    GeneratedPluginRegistrant.clearRegisteredEngines();
+  }
 
   @Test
   public void createFlutterFragment__defaultRenderModeSurface() {
@@ -44,6 +66,39 @@ protected RenderMode getRenderMode() {
     assertEquals(activity.createFlutterFragment().getRenderMode(), RenderMode.texture);
   }
 
+  @Test
+  public void itRegistersPluginsAtConfigurationTime() {
+    FlutterFragmentActivity activity =
+        Robolectric.buildActivity(FlutterFragmentActivityWithProvidedEngine.class).get();
+    assertTrue(GeneratedPluginRegistrant.getRegisteredEngines().isEmpty());
+
+    // Calling onCreate on the FlutterFragmentActivity will create a FlutterFragment and
+    // commit it to the fragment manager. This attaches the fragment to the FlutterFragmentActivity
+    // creating and configuring the engine.
+    activity.onCreate(null);
+
+    List<FlutterEngine> registeredEngines = GeneratedPluginRegistrant.getRegisteredEngines();
+    assertEquals(1, registeredEngines.size());
+    assertEquals(activity.getFlutterEngine(), registeredEngines.get(0));
+  }
+
+  static class FlutterFragmentActivityWithProvidedEngine extends FlutterFragmentActivity {
+    @Override
+    protected FlutterFragment createFlutterFragment() {
+      return FlutterFragment.createDefault();
+    }
+
+    @Nullable
+    @Override
+    public FlutterEngine provideFlutterEngine(@NonNull Context context) {
+      FlutterJNI flutterJNI = mock(FlutterJNI.class);
+      when(flutterJNI.isAttached()).thenReturn(true);
+
+      return new FlutterEngine(
+          context, mock(FlutterLoader.class), flutterJNI, new String[] {}, false);
+    }
+  }
+
   private static class FakeFlutterFragmentActivity extends FlutterFragmentActivity {
     @Override
     public Intent getIntent() {