(原创)Flutter与Native页面互相跳转

前言

实际开发混合项目时,常常会有页面跳转的需求

如果是原生界面和flutter界面需要互相跳转

这种情况应该怎么处理呢?

今天这篇博客主要就来介绍下这个情况

其实想一下,这个问题可以拆成四个小的问题来分析:

1:原生界面自己怎么跳转?

2:Flutter界面互相跳转

2:原生界面跳转Flutter

3:Flutter跳转原生界面

第一点很好理解

拿android来说

就是startActivity

本篇博客主要讲一下后面三点的办法

当然,本篇博客主要讲我知道的方法

如果有更好的方法,欢迎评论区留言

Flutter界面互相跳转

Flutter界面互相跳转,一般使用Navigator类

比如我们要跳转到另外一个页面,我们可以这样写:

dart 复制代码
final result = await Navigator.push(
      context, MaterialPageRoute(builder: (context) => SecondPage(params: "firstpage",)));

使用Navigator.push进行跳转,参数放在目标页面的构造方法内

result 为页面返回后传递的值

而SecondPage退出的时候,则可以这样写:

dart 复制代码
Navigator.pop(context, "hi good");

第二个参数是返回给上一个页面的数据

getx跳转

除了使用自带的Navigator,我们还可以借助第三方库

先引入getx:

dart 复制代码
  get: 4.6.0

跳转的时候:

dart 复制代码
final result = await Get.to(GetxSecondPage(params: 'firstpage',));

返回的时候:

dart 复制代码
Get.back(result: "hi good");

当然,这是最基础的用法

我们还可以自定义路由

首先我们要使用GetMaterialApp:

dart 复制代码
class GetxJump extends StatelessWidget {
  const GetxJump({super.key});

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return GetMaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      initialRoute: "/",
      getPages: [
        GetPage(name: '/', page: () => GetxFirstPage()),
        GetPage(name: '/GetxSecondPage', page: () => GetxSecondPage()),
      ],
      // home: GetxFirstPage(),
    );
  }
}

在getPages里定义我们的路由,'/'为默认的第一个页面

这时候就不用配置home属性了

然后GetxFirstPage跳转到GetxSecondPage的时候:

dart 复制代码
final result = await Get.toNamed("/GetxSecondPage",arguments: "firstpage--arguments");

返回的逻辑还是一样的,用Get.back即可

原生界面跳转Flutter

fragment显示Flutter页面

Flutter的页面,其实都是存在于一个叫做FlutterActivity的安卓页面上的

我们可以打开我们的任意一个Flutter项目,可以看到MainActivity是继承的FlutterActivity

其实我们也可以把Flutter的页面理解为一个webview

在讲跳转之前,我们先尝试,用一个fragment来显示Flutter页面

我们在Flutter项目中创建一个Activity,布局如下:

dart 复制代码
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  android:orientation="vertical"
  android:gravity="center">

  <FrameLayout
    android:id="@+id/flutterframelayout"
    android:layout_width="match_parent"
    android:layout_height="500dp"
    />

</LinearLayout>

然后我们在Activity的onCreate方法中写如下代码:

dart 复制代码
    var flutterFragment = FlutterFragment.createDefault()
    supportFragmentManager
      .beginTransaction()
      .add(R.id.flutterframelayout, flutterFragment)
      .commit()

注意,我们的Activity并没有继承FlutterActivity

而是直接继承最基础的AppCompatActivity

这时候我们运行代码,会发现我们也显示出了Flutter的Hello world界面

这时候flutter的页面大小就是我们fragment的大小,所以看起来有点怪

其实我们还可以让这个flutter页面和我们的Activity通信

这样一个页面就又有原生又有flutter界面了

具体通信可以查看这篇博客:
Flutter与Native通信的方式:MethodChannel

讲这个主要是为了帮助大家更好的认识Flutter

讲完这点,再来介绍一个东西:

FlutterEngine

我们刚刚用FlutterFragment.createDefault()来创建了一个FlutterFragment

其实FlutterFragment还有两种创建方式

这边都列出来:

dart 复制代码
FlutterFragment.withNewEngine().build<FlutterFragment>()  重新创建一个Engine,指定main方法作为Flutter程序入口
FlutterFragment.createDefault()  使用默认的,指定main方法作为Flutter程序入口
FlutterFragment.withCachedEngine("engine_id")  根据engine_id找到Engine,然后Engine可以配置自己指定的程序入口

可以看到,这里面有一个Engine,那么Engine是什么呢?

这里的Engine其实指的是FlutterEngine

下面就介绍下它

认识Engine

Engine翻译过来有引擎,发动机的意思

说明它的确是Flutter中很重要的一部分

Engine有一个很重要的作用就是负责配置Flutter页面的方法入口

比如,我们在写最简单的Flutter项目时,会发现Flutter的代码都是以main方法作为入口

就像这样:

dart 复制代码
void main() => runApp(const MyApp());

加上前面说的,Flutter的页面是类似以webview的形式放在安卓的Activity上面的

那么他们是怎么关联起来的呢?

下面就会一一讲到

这部分内容有点多,如果想直接看用法,

可以点到"跳转到一个FlutterActivity"目录查看怎么使用就好了

FlutterFragment如何被创建

我们先看下一个FlutterFragmentActivity是怎么处理的

在FlutterFragmentActivity的onCreate方法里,我们找到了一个ensureFlutterFragmentCreated方法:

这个方法的代码我贴出来:

dart 复制代码
  private void ensureFlutterFragmentCreated() {
    if (flutterFragment == null) {
      // If both activity and fragment have been destroyed, the activity restore may have
      // already recreated a new instance of the fragment again via the FragmentActivity.onCreate
      // and the FragmentManager.
      flutterFragment = retrieveExistingFlutterFragmentIfPossible();
    }
    if (flutterFragment == null) {
      // No FlutterFragment exists yet. This must be the initial Activity creation. We will create
      // and add a new FlutterFragment to this Activity.
      flutterFragment = createFlutterFragment();
      FragmentManager fragmentManager = getSupportFragmentManager();
      fragmentManager
          .beginTransaction()
          .add(FRAGMENT_CONTAINER_ID, flutterFragment, TAG_FLUTTER_FRAGMENT)
          .commit();
    }
  }

可以看到,就是调用createFlutterFragment去创建了一个Fragment

其实这个Fragment就是显示我们Flutter页面的Fragment

不信再来看下createFlutterFragment方法:

dart 复制代码
  @NonNull
  protected FlutterFragment createFlutterFragment() {
    final BackgroundMode backgroundMode = getBackgroundMode();
    final RenderMode renderMode = getRenderMode();
    final TransparencyMode transparencyMode =
        backgroundMode == BackgroundMode.opaque
            ? TransparencyMode.opaque
            : TransparencyMode.transparent;
    final boolean shouldDelayFirstAndroidViewDraw = renderMode == RenderMode.surface;

    if (getCachedEngineId() != null) {
      Log.v(
          TAG,
          "Creating FlutterFragment with cached engine:\n"
              + "Cached engine ID: "
              + getCachedEngineId()
              + "\n"
              + "Will destroy engine when Activity is destroyed: "
              + shouldDestroyEngineWithHost()
              + "\n"
              + "Background transparency mode: "
              + backgroundMode
              + "\n"
              + "Will attach FlutterEngine to Activity: "
              + shouldAttachEngineToActivity());

      return FlutterFragment.withCachedEngine(getCachedEngineId())
          .renderMode(renderMode)
          .transparencyMode(transparencyMode)
          .handleDeeplinking(shouldHandleDeeplinking())
          .shouldAttachEngineToActivity(shouldAttachEngineToActivity())
          .destroyEngineWithFragment(shouldDestroyEngineWithHost())
          .shouldDelayFirstAndroidViewDraw(shouldDelayFirstAndroidViewDraw)
          .build();
    } else {
      Log.v(
          TAG,
          "Creating FlutterFragment with new engine:\n"
              + "Background transparency mode: "
              + backgroundMode
              + "\n"
              + "Dart entrypoint: "
              + getDartEntrypointFunctionName()
              + "\n"
              + "Dart entrypoint library uri: "
              + (getDartEntrypointLibraryUri() != null ? getDartEntrypointLibraryUri() : "\"\"")
              + "\n"
              + "Initial route: "
              + getInitialRoute()
              + "\n"
              + "App bundle path: "
              + getAppBundlePath()
              + "\n"
              + "Will attach FlutterEngine to Activity: "
              + shouldAttachEngineToActivity());

      return FlutterFragment.withNewEngine()
          .dartEntrypoint(getDartEntrypointFunctionName())
          .dartLibraryUri(getDartEntrypointLibraryUri())
          .dartEntrypointArgs(getDartEntrypointArgs())
          .initialRoute(getInitialRoute())
          .appBundlePath(getAppBundlePath())
          .flutterShellArgs(FlutterShellArgs.fromIntent(getIntent()))
          .handleDeeplinking(shouldHandleDeeplinking())
          .renderMode(renderMode)
          .transparencyMode(transparencyMode)
          .shouldAttachEngineToActivity(shouldAttachEngineToActivity())
          .shouldDelayFirstAndroidViewDraw(shouldDelayFirstAndroidViewDraw)
          .build();
    }
  }

太长不想看的话直接看结论:

其实就是通过判断getCachedEngineId(缓存的id)是否有缓存的id

然后来创建Fragment

如果有id,withCachedEngine方法会创建一个CachedEngineFragmentBuilder

否则就是withNewEngine创建一个NewEngineFragmentBuilder

两个FragmentBuilder的build方法其实都是利用反射去创建了FlutterFragment

并且在createArgs方法内进行了传参

如下:

dart 复制代码
    @NonNull
    public <T extends FlutterFragment> T build() {
      try {
        @SuppressWarnings("unchecked")
        T frag = (T) fragmentClass.getDeclaredConstructor().newInstance();
        if (frag == null) {
          throw new RuntimeException(
              "The FlutterFragment subclass sent in the constructor ("
                  + fragmentClass.getCanonicalName()
                  + ") does not match the expected return type.");
        }

        Bundle args = createArgs();
        frag.setArguments(args);

        return frag;
      } catch (Exception e) {
        throw new RuntimeException(
            "Could not instantiate FlutterFragment subclass (" + fragmentClass.getName() + ")", e);
      }
    }

等下,这种创建Fragment的方式和我们上面写的fragment显示Flutter页面的例子不是一样吗?
对!

我们上面其实就是自己写了个简单的FlutterFragmentActivity

我们自己创建了FlutterFragment然后显示了出来

而FlutterFragmentActivity默认帮我们创建了,并且默认入口是:main()方法

查看上面代码

发现如果找不到getCachedEngineId

走的是:

dart 复制代码
FlutterFragment.withNewEngine()

所以我们再来看FlutterFragment创建的三种方式:

dart 复制代码
FlutterFragment.withNewEngine().build<FlutterFragment>()  重新创建一个Engine,指定main方法作为Flutter程序入口
FlutterFragment.createDefault()  使用默认的,指定main方法作为Flutter程序入口
FlutterFragment.withCachedEngine("engine_id")  根据engine_id找到Engine,然后Engine可以配置自己指定的程序入口

其实第二种内部调用的就是第一种,二者是一样的

dart 复制代码
  @NonNull
  public static CachedEngineFragmentBuilder withCachedEngine(@NonNull String engineId) {
    return new CachedEngineFragmentBuilder(engineId);
  }
  
  @NonNull
  public static FlutterFragment createDefault() {
    return new NewEngineFragmentBuilder().build();
  }
  
  //可以看到是一样的
  @NonNull
  public static NewEngineFragmentBuilder withNewEngine() {
    return new NewEngineFragmentBuilder();
  }

那么,NewEngineFragmentBuilder和CachedEngineFragmentBuilder有什么区别呢?

FragmentBuilder

刚刚已经分析了,通过判断getCachedEngineId(缓存的id)是否有缓存的id

有就通过CachedEngineFragmentBuilder创建Fragment

否则通过NewEngineFragmentBuilder创建Fragment

先看CachedEngineFragmentBuilder

它拿到缓存的engineId后通过Bundle 传给了创建的FlutterFragment

dart 复制代码
Bundle args = new Bundle();
args.putString(ARG_CACHED_ENGINE_ID, engineId);

FlutterFragment通过getCachedEngineId方法得到了engineId

dart 复制代码
  @Nullable
  @Override
  public String getCachedEngineId() {
    return getArguments().getString(ARG_CACHED_ENGINE_ID, null);
  }

那么getCachedEngineId是什么时候调用的呢?

会发现这个方法是来自于FlutterActivityAndFragmentDelegate.Host接口

FlutterFragment刚好实现了这个接口

然后FlutterActivityAndFragmentDelegate的setupFlutterEngine方法中会调用getCachedEngineId

先得到缓存的cachedEngineId

然后用单例类FlutterEngineCache根据cachedEngineId就得到了FlutterEngine

dart 复制代码
 String cachedEngineId = host.getCachedEngineId();
    if (cachedEngineId != null) {
      flutterEngine = FlutterEngineCache.getInstance().get(cachedEngineId);
      isFlutterEngineFromHost = true;
      if (flutterEngine == null) {
        throw new IllegalStateException(
            "The requested cached FlutterEngine did not exist in the FlutterEngineCache: '"
                + cachedEngineId
                + "'");
      }
      return;
    }

而setupFlutterEngine方法是被FlutterActivityAndFragmentDelegate的onAttach调用

FlutterActivityAndFragmentDelegate的onAttach方法最终又被FlutterFragment的onAttach方法调用

如下代码:

dart 复制代码
  @Override
  public void onAttach(@NonNull Context context) {
    super.onAttach(context);
    delegate = delegateFactory.createDelegate(this);
    delegate.onAttach(context);
    if (getArguments().getBoolean(ARG_SHOULD_AUTOMATICALLY_HANDLE_ON_BACK_PRESSED, false)) {
      requireActivity().getOnBackPressedDispatcher().addCallback(this, onBackPressedCallback);
    }
    context.registerComponentCallbacks(this);
  }

这时候我们就清楚了,在FlutterFragment调用onAttach生命周期方法的时候

就根据传递的cachedEngineId得到了缓存的FlutterEngine

那么如果用的是NewEngineFragmentBuilder,

这时候没有cachedEngineId会怎么办呢?其实就会直接创建一个FlutterEngine

所以我们大概了解了

两个FragmentBuilder的区别主要在于创建FlutterFragment是否有缓存的Engineid

然后根据这种不同来决定是否使用缓存的FlutterEngine还是直接创建新的

那么FlutterEngine又有什么作用呢?

FlutterEngine

顾名思义,FlutterEngine是Flutter的引擎和发动机

我们还是看两个NewEngineFragmentBuilder

发现FlutterFragment.withNewEngine()创建了NewEngineFragmentBuilder之后

马上调用了dartEntrypoint(getDartEntrypointFunctionName())方法

里面调用的getDartEntrypointFunctionName方法源码如下

dart 复制代码
  @NonNull
  public String getDartEntrypointFunctionName() {
    try {
      Bundle metaData = getMetaData();
      String desiredDartEntrypoint =
          metaData != null ? metaData.getString(DART_ENTRYPOINT_META_DATA_KEY) : null;
      return desiredDartEntrypoint != null ? desiredDartEntrypoint : DEFAULT_DART_ENTRYPOINT;
    } catch (PackageManager.NameNotFoundException e) {
      return DEFAULT_DART_ENTRYPOINT;
    }
  }

可以看到,是根据key来取一个字符串

取不到这返回默认的DEFAULT_DART_ENTRYPOINT

而这个默认的值为

dart 复制代码
static final String DEFAULT_DART_ENTRYPOINT = "main";

这下我们终于看到了,就是main方法

getDartEntrypointFunctionName得到的字符串

会赋值给NewEngineFragmentBuilder的dartEntrypoint

并最终通过Bundle传递给FlutterFragment

dart 复制代码
args.putString(ARG_DART_ENTRYPOINT, dartEntrypoint);

FlutterFragment在getDartEntrypointFunctionName方法中得到这个参数

可以看到,得不到的时候默认取main

dart 复制代码
  @Override
  @NonNull
  public String getDartEntrypointFunctionName() {
    return getArguments().getString(ARG_DART_ENTRYPOINT, "main");
  }

现在我们可以做一个初步的总结:
FlutterFragmentActivity创建了Fragment用于显示Flutter页面,
然后通过创建NewEngineFragmentBuilder并调用NewEngineFragmentBuilder的dartEntrypoint方法
从而设置了Flutter的程序入口

那么具体是怎么设置的呢?

其实getDartEntrypointFunctionName方法也是来自于FlutterActivityAndFragmentDelegate.Host接口

并且被FlutterActivityAndFragmentDelegate的doInitialFlutterViewRun方法调用

doInitialFlutterViewRun方法又在FlutterActivityAndFragmentDelegate的onStart方法中被调用

FlutterActivityAndFragmentDelegate的onStart方法,被FlutterFragment的onStart方法调用

这时候我们就知道了,归根结底还是FlutterFragment的生命周期

然后我们继续看doInitialFlutterViewRun方法在得到这个字符串后会做什么

重点来了:

dart 复制代码
    DartExecutor.DartEntrypoint entrypoint =
        libraryUri == null
            ? new DartExecutor.DartEntrypoint(
                appBundlePathOverride, host.getDartEntrypointFunctionName())
            : new DartExecutor.DartEntrypoint(
                appBundlePathOverride, libraryUri, host.getDartEntrypointFunctionName());
    flutterEngine.getDartExecutor().executeDartEntrypoint(entrypoint, host.getDartEntrypointArgs());

可以看到,根据getDartEntrypointFunctionName返回的程序入口

从而创建了DartExecutor.DartEntrypoint类

并且调用flutterEngine.getDartExecutor().executeDartEntrypoint(entrypoint, host.getDartEntrypointArgs());

从而完成了入口的设置

这时候我们就清楚了,
在FlutterFragment调用onAttach生命周期方法的时候
就根据传递的cachedEngineId得到了缓存的FlutterEngine
没有缓存则创建新的FlutterEngine
然后,FlutterFragment调用onStart生命周期方法的时候
会触发FlutterActivityAndFragmentDelegate的onStart方法里面的doInitialFlutterViewRun方法
方法内部调用getDartEntrypointFunctionName从而得到程序入口
并且把这个入口配置给到了FlutterEngine

那么,下一个问题

NewEngineFragmentBuilder配置的入口可以改吗?

当然!

我们也可以通过调用flutterEngine.getDartExecutor().executeDartEntrypoint(entrypoint, host.getDartEntrypointArgs());

完成入口的设置

文章后面就会讲具体怎么设置

回到上面两个FragmentBuilder

我们也可以知道
不管是缓存的,还是新创建的FragmentBuilder
归根结底都要得到一个FlutterEngine
而FlutterEngine才是真正设置入口的类
他的executeDartEntrypoint方法需要传入一个DartEntrypoint类
DartEntrypoint类的dartEntrypointFunctionName属性用来配置入口方法的名称

最后看下executeDartEntrypoint方法吧

内部利用flutterJNI去寻找入口,这块我们就不继续看下去了

dart 复制代码
  public void executeDartEntrypoint(
      @NonNull DartEntrypoint dartEntrypoint, @Nullable List<String> dartEntrypointArgs) {
    if (isApplicationRunning) {
      Log.w(TAG, "Attempted to run a DartExecutor that is already running.");
      return;
    }

    TraceSection.begin("DartExecutor#executeDartEntrypoint");
    try {
      Log.v(TAG, "Executing Dart entrypoint: " + dartEntrypoint);
      flutterJNI.runBundleAndSnapshotFromLibrary(
          dartEntrypoint.pathToBundle,
          dartEntrypoint.dartEntrypointFunctionName,
          dartEntrypoint.dartEntrypointLibrary,
          assetManager,
          dartEntrypointArgs);

      isApplicationRunning = true;
    } finally {
      TraceSection.end();
    }
  }

知道了这一块,我们做个最终总结:
1:FlutterFragmentActivity根据Intent是否传递过来缓存的engineid决定采用不同方式创建FlutterFragment
有缓存,则用CachedEngineFragmentBuilder
无缓存,则用NewEngineFragmentBuilder
二者都是利用反射创建了FlutterFragment
并且将engineid传递给了FlutterFragment
2:FlutterFragment根据是否有engineid,来得到一个FlutterEngine
有engineid,通过单例类FlutterEngineCache的Map得到缓存的FlutterEngine
无engineid,创建新的FlutterEngine
这一步在FlutterFragment的onAttach方法执行
3:FlutterFragment的onStart方法判断是否有ARG_DART_ENTRYPOINT参数
没有就默认返回main作为程序入口
ARG_DART_ENTRYPOINT参数的值赋值给了创建的DartExecutor.DartEntrypoint类
并最终被FlutterEngine的executeDartEntrypoint使用了这个类
从而完成入口的配置

这是关于FlutterFragmentActivity的整体逻辑

继承的是FragmentActivity

其实还有另外一个FlutterActivity类

继承的是Activity

并实现FlutterActivityAndFragmentDelegate.Host接口

FlutterActivity类也是可以显示Flutter页面的Activity

和FlutterFragmentActivity有一些区别

这块我没有细看了

貌似他是用FlutterActivityAndFragmentDelegate创建不同的flutterView来显示Flutter页面的

这块感兴趣的可以看下,目前我基本都是用FlutterFragmentActivity

了解了这么多,我们跳转到一个FlutterActivity其实就很简单了

跳转到一个FlutterActivity

和上面讲的NewEngineFragmentBuilder、CachedEngineFragmentBuilder一样

Flutter提供了两个IntentBuilder方便我们跳转

NewEngineIntentBuilder和CachedEngineIntentBuilder

区别其实就是是否有缓存的engineid

下面介绍具体跳转方式

NewEngineIntentBuilder

这个就比较简单了,首先在我们的目标Activity里面创建NewEngineIntentBuilder

注意目标Activity要继承FlutterFragmentActivity

dart 复制代码
  companion object {
    fun NewEngineIntentBuilder(): NewEngineIntentBuilder {
      return NewEngineIntentBuilder(MainActivity3::class.java)
    }
  }

然后跳转代码为:

dart 复制代码
      startActivity(MainActivity3
        .NewEngineIntentBuilder()
        .build(this@MainActivity))

可以看到,创建了NewEngineIntentBuilder并调用它的build方法即可

build方法其实就是返回了一个intent

dart 复制代码
    @NonNull
    public Intent build(@NonNull Context context) {
      Intent intent =
          new Intent(context, activityClass)
              .putExtra(EXTRA_INITIAL_ROUTE, initialRoute)
              .putExtra(EXTRA_BACKGROUND_MODE, backgroundMode)
              .putExtra(EXTRA_DESTROY_ENGINE_WITH_ACTIVITY, true);
      if (dartEntrypointArgs != null) {
        intent.putExtra(EXTRA_DART_ENTRYPOINT_ARGS, new ArrayList(dartEntrypointArgs));
      }
      return intent;
    }

通过这种方式,最终目标Activity创建Fragment的时候

用的将会是NewEngineFragmentBuilder

从而创建新的FlutterEngine

而这种跳转页面的方式,只能跳转到Flutter的main方法

也就是不能决定Flutter的程序入口

要改变入口,还是需要FlutterEngine

CachedEngineIntentBuilder

使用CachedEngineIntentBuilder跳转

一样在目标Activity里创建CachedEngineIntentBuilder

dart 复制代码
  companion object {
    fun withCachedEngine(cachedEngineId: String): CachedEngineIntentBuilder {
      return CachedEngineIntentBuilder(MainActivity3::class.java, cachedEngineId)
    }
  }

跳转的代码这样写:

dart 复制代码
      startActivity(MainActivity3
        .withCachedEngine(App.your_engine_id)
        .build(this@MainActivity).apply {
          putExtra("method", "showtestpage")
          putExtra("params", "参数params")
        })

其实也是创建了CachedEngineIntentBuilder并调用它的build方法即可

build方法其实也是返回了一个intent

dart 复制代码
    @NonNull
    public Intent build(@NonNull Context context) {
      return new Intent(context, activityClass)
          .putExtra(EXTRA_CACHED_ENGINE_ID, cachedEngineId)
          .putExtra(EXTRA_DESTROY_ENGINE_WITH_ACTIVITY, destroyEngineWithActivity)
          .putExtra(EXTRA_BACKGROUND_MODE, backgroundMode);
    }

那么区别在哪呢?

就在于withCachedEngine方法内传递的cachedEngineId

这个cachedEngineId需要我们定义好

我这里是定义在Application里

定义好之后,我们再去创建FlutterEngine

dart 复制代码
  private val flutterEngine by lazy {
    //显示默认的页面,会找flutter的main方法
    FlutterEngine(this).apply {
      dartExecutor.executeDartEntrypoint(DartExecutor.DartEntrypoint.createDefault())
    }
  }

然后把创建的FlutterEngine存入到单例类FlutterEngineCache中

dart 复制代码
FlutterEngineCache.getInstance().put(your_engine_id, flutterEngine)

这里your_engine_id就是key

要和withCachedEngine方法内传递的cachedEngineId保持一致才可以找到对应的FlutterEngine

通过这种方式,最终目标Activity创建Fragment的时候

用的将会是CachedEngineFragmentBuilder

从而找到缓存的FlutterEngine

而这种跳转页面的方式,

可以通过创建DartExecutor.DartEntrypoint类

并且调用flutterEngine.getDartExecutor().executeDartEntrypoint(entrypoint, host.getDartEntrypointArgs());

便完成了入口的设置

入口和传参

那么具体怎么设置呢?

其实就在于我们创建FlutterEngine的方式

其实创建FlutterEngine的方式和创建FlutterFragment创建的方式差不多:

FlutterFragment提供这三种方式创建(第一种和第二种其实一样):

dart 复制代码
FlutterFragment.withNewEngine().build<FlutterFragment>()  重新创建一个Engine,指定main方法作为Flutter程序入口
FlutterFragment.createDefault()  使用默认的,指定main方法作为Flutter程序入口
FlutterFragment.withCachedEngine("engine_id")  根据engine_id找到Engine,然后Engine可以配置自己指定的程序入口

FlutterEngine则是提供三种方式创建(第一种和第二种其实一样):

dart 复制代码
FlutterEngine(this).apply {
  dartExecutor.executeDartEntrypoint(DartExecutor.DartEntrypoint.createDefault())
}

//createDefault内部其实就是这样写的
FlutterEngine(this).apply {
  var entrypoint=DartEntrypoint(FlutterMain.findAppBundlePath(), "main")
  dartExecutor.executeDartEntrypoint(entrypoint)
}

FlutterEngine(this).apply {
  var entrypoint = DartExecutor.DartEntrypoint(
    FlutterMain.findAppBundlePath(), "testMethod")
  dartExecutor.executeDartEntrypoint(entrypoint)
}

这里testMethod就是我们定义的程序入口了

这样在跳转到我们目标Activity后

Flutter就会加载main.dart文件里的testMethod()方法作为程序入口了
注意:
testMethod()必须写在main.dart文件里

这块我暂时也没找到其他方法

页面跳转有了,那么传参呢?

可以看到我刚刚跳转的时候传递了两个参数给Intent

dart 复制代码
          putExtra("method", "showtestpage")
          putExtra("params", "参数params")

那么在目标Activity的configureFlutterEngine方法里我们可以这样处理:

dart 复制代码
  override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
    super.configureFlutterEngine(flutterEngine)
    var   channel = MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "paramsChannel")
    intent?.apply {
      val path = getStringExtra("method") ?: ""
      val params = getStringExtra("params") ?: ""
      Log.d("MainActivity3", "path是:"+path)
      Log.d("MainActivity3", "params是:"+params)
      channel.invokeMethod(path, params)
    }
  }

会发现其实还是用MethodChannel进行通信

然后来到Flutter端的代码

定义MethodChannel

dart 复制代码
  var commonNativeChannel = MethodChannel('paramsChannel');

在initState里面:

dart 复制代码
  @override
  void initState() {
    commonNativeChannel.setMethodCallHandler((MethodCall call) async {
      print('拿到参数: = ${call.method}');
      switch (call.method) {
        case 'showtestpage':
          print('拿到参数: = ${call.arguments}');
          //这里可以根据参数设置跳转不同page,我这里刷新一下显示,不做跳转处理
          setState(() {
            params = call.arguments.toString();
          });
          break;
        default:
          print('Unknowm method ${call.method}');
          //触发Android端的notImplemented方法
          throw MissingPluginException();
      }
    });
    super.initState();
  }

这样,指定跳转Flutter页面和传参就完成了

Flutter跳转原生界面

Flutter跳转指定原生页面需要用到MethodChannel进行通信

对MethodChannel不了解的可以看我的这篇博客:
Flutter与Native通信的方式:MethodChannel

下面展示具体的用法:

首先是在Flutter端定义好MethodChannel的字段和方法

这里用两个按钮的点击事件来触发跳转

分别调用安卓端的jumpActivity和finish方法

当然也可以传参,具体传参可以看上面的MethodChannel博客

dart 复制代码
class _MyjumpAndroidPageState extends State<MyjumpAndroidPage> {
  var commonNativeChannel = MethodChannel('ForNativePlugin');
  @override
  void initState() {
    super.initState();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            ElevatedButton(onPressed: () {
              commonNativeChannel.invokeMethod("jumpActivity");
            }, child: Text("点击跳转到android页面")),
            ElevatedButton(onPressed: () {
              commonNativeChannel.invokeMethod("finish");
            }, child: Text("点击关闭当前Flutter页面"))
          ],
        ),
      ),
    );
  }
}

然后来到我们安卓端

继承FlutterFragmentActivity类

照样创建MethodChannel

在configureFlutterEngine方法中

对这些被调用的方法进行处理即可

我这边只是打印了下日志

正常情况下StartActivity即可

dart 复制代码
class MainActivity4 : FlutterFragmentActivity() {
  private lateinit var flutterMethodChannel: MethodChannel

  companion object {
    fun withCachedEngine(cachedEngineId: String): CachedEngineIntentBuilder {
      return CachedEngineIntentBuilder(MainActivity4::class.java, cachedEngineId)
    }
  }

  override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
    super.configureFlutterEngine(flutterEngine)
    flutterMethodChannel = MethodChannel(flutterEngine.dartExecutor, "ForNativePlugin")
    flutterMethodChannel.setMethodCallHandler { methodCall, result ->
      when (methodCall.method) {
        "finish" -> {
          Toast.makeText(this@MainActivity4, "关闭页面", Toast.LENGTH_SHORT).show()
          finish()
        }
        "jumpActivity" -> {
          Toast.makeText(this@MainActivity4, "跳转页面", Toast.LENGTH_SHORT).show()
        }
        else -> {
          // 表明没有对应实现
          result.notImplemented()
        }
      }
    }
  }
}

源码

关于Flutter与Native页面互相跳转大体上就是这么多内容了

下面分享下这篇文章涉及到的源码地址:
new_gradlesetting_native_jump_flutter

相关推荐
运维Z叔2 小时前
云安全 | AWS S3存储桶安全设计缺陷分析
android·网络·网络协议·tcp/ip·安全·云计算·aws
Reese_Cool3 小时前
【C语言二级考试】循环结构设计
android·java·c语言·开发语言
平凡シンプル4 小时前
安卓 uniapp跨端开发
android·uni-app
elina80134 小时前
安卓实现导入Excel文件
android·excel
严文文-Chris4 小时前
【设计模式-享元】
android·java·设计模式
趋势大仙4 小时前
SQLiteDatabase insert or replace数据不生效
android·数据库
DS小龙哥4 小时前
QT For Android开发-打开PPT文件
android·qt·powerpoint
试行5 小时前
Android实现自定义下拉列表绑定数据
android·java
Dingdangr10 小时前
Android中的Intent的作用
android
技术无疆10 小时前
快速开发与维护:探索 AndroidAnnotations
android·java·android studio·android-studio·androidx·代码注入