Flutter-Android初始化流程

继承 SurfaceView，它的外部有两个线程即主线程和渲染线程，应用渲染线程中向屏幕上绘图能够防止主线程阻塞，从而进步了程序的反应速度。应用了双缓冲机制。
实现 BinaryMesaenger 接口，这个接口定义了 Android 代码和 Flutter 代码间接通信的形式，此接口还有 2 个外部接口。FlutterView 实现了这个接口，领有了和 flutter 通信的的能力
实现 TextureRegistry 接口，这个接口次要是创立一个 SurfaceTexture 对象，应用 SurfaceTextureEntry 包装起来，领有惟一的 ID。
实现 onAccessibilityChanged 接口，次要用来监听系统 accessibility 状态变动的。

创立一大堆 Channel 用于 Android 和 flutter 通信

    navigationChannel = new NavigationChannel(dartExecutor);
    keyEventChannel = new KeyEventChannel(dartExecutor);
    lifecycleChannel = new LifecycleChannel(dartExecutor);
    localizationChannel = new LocalizationChannel(dartExecutor);
    platformChannel = new PlatformChannel(dartExecutor);
    systemChannel = new SystemChannel(dartExecutor);
    settingsChannel = new SettingsChannel(dartExecutor);

创立 FlutterNativeView

 // 初始化
 mNativeView = new FlutterNativeView(activity.getApplicationContext());
 OnAccessibilityChangeListener
 AccessibilityStateChangeListener

创立一堆成员变量

mIsSoftwareRenderingEnabled 硬件加速渲染相干的

dartExecutor = mNativeView.getDartExecutor();
    flutterRenderer = new FlutterRenderer(mNativeView.getFlutterJNI());
    mIsSoftwareRenderingEnabled = mNativeView.getFlutterJNI().nativeGetIsSoftwareRenderingEnabled();
    mMetrics = new ViewportMetrics();
    mMetrics.devicePixelRatio = context.getResources().getDisplayMetrics().density;
    setFocusable(true);
    setFocusableInTouchMode(true);
        //attach 到以后 Activity
    mNativeView.attachViewAndActivity(this, activity);

    mSurfaceCallback =
        new SurfaceHolder.Callback() {
          @Override
          public void surfaceCreated(SurfaceHolder holder) {assertAttached();
            mNativeView.getFlutterJNI().onSurfaceCreated(holder.getSurface());
          }

          @Override
          public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {assertAttached();
            mNativeView.getFlutterJNI().onSurfaceChanged(width, height);
          }

          @Override
          public void surfaceDestroyed(SurfaceHolder holder) {assertAttached();
            mNativeView.getFlutterJNI().onSurfaceDestroyed();
          }
        };

创立

if (nativeView == null) {mNativeView = new FlutterNativeView(activity.getApplicationContext());
    } else {mNativeView = nativeView;}


  public FlutterNativeView(@NonNull Context context, boolean isBackgroundView) {
    mContext = context;
    mPluginRegistry = new FlutterPluginRegistry(this, context);
    mFlutterJNI = new FlutterJNI();
    mFlutterJNI.addIsDisplayingFlutterUiListener(flutterUiDisplayListener);
    this.dartExecutor = new DartExecutor(mFlutterJNI, context.getAssets());
    mFlutterJNI.addEngineLifecycleListener(new EngineLifecycleListenerImpl());
    attach(this, isBackgroundView);
    assertAttached();}

FlutterPluginRegistry 是 actitiy 和 flutterView 绑定关系操作类，而 FlutterJNI 创立时，将绑定绘制、跨平台通信、生命周期的监听办法。
mFlutterJNI，Engine 层 c ++ 办法的一个封装类。所有 Flutter JNI 的调用都汇合在这个类中。一个 FlutterJNI 对象是和一个 Platform View 相关联，所以蕴含一个 nativePlatformViewId 来标识

 attach(this, isBackgroundView);


  private void attach(FlutterNativeView view, boolean isBackgroundView) {mFlutterJNI.attachToNative(isBackgroundView);
    dartExecutor.onAttachedToJNI();}
 
 public void attachToNative(boolean isBackgroundView) {ensureRunningOnMainThread();
    ensureNotAttachedToNative();
    nativePlatformViewId = nativeAttach(this, isBackgroundView);
  }

总结

FlutterView 提供了 SurfaceView 来绘制 Flutter 的 UI
同时把 Android 的生命周期、点击事件等信息发送给 Flutter。
FlutterView 并不负责间接和 Flutter Engine 通信，具体的通信性能在 FlutterNativeView
FlutterNativeView 外部有一个 FlutterJNI，它负责调用 Flutter Engine 的 C ++ 代码。

public void attachToNative(boolean isBackgroundView) {ensureRunningOnMainThread();
    ensureNotAttachedToNative();
    nativePlatformViewId = nativeAttach(this, isBackgroundView);
  }

//nativeAttach 对应
bool RegisterApi(JNIEnv* env) {static const JNINativeMethod flutter_jni_methods[] = {
      // Start of methods from FlutterJNI
      {
          .name = "nativeAttach",
          .signature = "(Lio/flutter/embedding/engine/FlutterJNI;Z)J",
          .fnPtr = reinterpret_cast<void*>(&AttachJNI),
      },
    
// 对应到 AttachJNI
    static jlong AttachJNI(JNIEnv* env,
                       jclass clazz,
                       jobject flutterJNI,
                       jboolean is_background_view) {fml::jni::JavaObjectWeakGlobalRef java_object(env, flutterJNI);
  std::shared_ptr<PlatformViewAndroidJNI> jni_facade =
      std::make_shared<PlatformViewAndroidJNIImpl>(java_object);
  auto shell_holder = std::make_unique<AndroidShellHolder>(FlutterMain::Get().GetSettings(), jni_facade, is_background_view);
  if (shell_holder->IsValid()) {return reinterpret_cast<jlong>(shell_holder.release());
  } else {return 0;}
}
    
// 创立 auto shell_holder = std::make_unique<AndroidShellHolder>
// 对应 flutter/shell/platform/android/android_shell_holder.cc    
AndroidShellHolder::AndroidShellHolder 创建对象

AndroidShellHolder::AndroidShellHolder(
    flutter::Settings settings,
    std::shared_ptr<PlatformViewAndroidJNI> jni_facade,
    bool is_background_view)
    : settings_(std::move(settings)), jni_facade_(jni_facade) {
  static size_t shell_count = 1;
  auto thread_label = std::to_string(shell_count++);

  FML_CHECK(pthread_key_create(&thread_destruct_key_, ThreadDestructCallback) ==
            0);

  if (is_background_view) {thread_host_ = {thread_label, ThreadHost::Type::UI};
  } else {
    thread_host_ = {thread_label, ThreadHost::Type::UI | ThreadHost::Type::GPU |
                                      ThreadHost::Type::IO};
  }

  // Detach from JNI when the UI and raster threads exit.
  auto jni_exit_task([key = thread_destruct_key_]() {FML_CHECK(pthread_setspecific(key, reinterpret_cast<void*>(1)) == 0);
  });
  thread_host_.ui_thread->GetTaskRunner()->PostTask(jni_exit_task);
  if (!is_background_view) {thread_host_.raster_thread->GetTaskRunner()->PostTask(jni_exit_task);
  }

  fml::WeakPtr<PlatformViewAndroid> weak_platform_view;
  // 创立 PlatformViewAndroid
  // 创立 on_create_platform_view
  Shell::CreateCallback<PlatformView> on_create_platform_view =
      [is_background_view, &jni_facade, &weak_platform_view](Shell& shell) {
        std::unique_ptr<PlatformViewAndroid> platform_view_android;
        if (is_background_view) {
          platform_view_android = std::make_unique<PlatformViewAndroid>(
              shell,                   // delegate
              shell.GetTaskRunners(),  // task runners
              jni_facade               // JNI interop
          );
        } else {
          platform_view_android = std::make_unique<PlatformViewAndroid>(
              shell,                   // delegate
              shell.GetTaskRunners(),  // task runners
              jni_facade,              // JNI interop
              shell.GetSettings()
                  .enable_software_rendering  // use software rendering
          );
        }
        weak_platform_view = platform_view_android->GetWeakPtr();
        return platform_view_android;
      };

  Shell::CreateCallback<Rasterizer> on_create_rasterizer = [](Shell& shell) {return std::make_unique<Rasterizer>(shell, shell.GetTaskRunners(),
                                        shell.GetIsGpuDisabledSyncSwitch());
  };

  // 创立四个线程 并把以后线程设置 platform thread
  fml::MessageLoop::EnsureInitializedForCurrentThread();
  fml::RefPtr<fml::TaskRunner> gpu_runner;
  fml::RefPtr<fml::TaskRunner> ui_runner;
  fml::RefPtr<fml::TaskRunner> io_runner;
  fml::RefPtr<fml::TaskRunner> platform_runner =
      fml::MessageLoop::GetCurrent().GetTaskRunner();
  if (is_background_view) {auto single_task_runner = thread_host_.ui_thread->GetTaskRunner();
    gpu_runner = single_task_runner;
    ui_runner = single_task_runner;
    io_runner = single_task_runner;
  } else {gpu_runner = thread_host_.raster_thread->GetTaskRunner();
    ui_runner = thread_host_.ui_thread->GetTaskRunner();
    io_runner = thread_host_.io_thread->GetTaskRunner();}
  flutter::TaskRunners task_runners(thread_label,     // label
                                    platform_runner,  // platform
                                    gpu_runner,       // raster
                                    ui_runner,        // ui
                                    io_runner         // io
  );
//shell 创立
// 不论是 iOS，Android，linux，嵌入式平台，都有对应的 Shell::Create，差别最大的应该是 web 端，web 端的整体架构形式就齐全不同。//Create 的 时候传入 platform view create
  shell_ =
      Shell::Create(task_runners,             // task runners
                    GetDefaultWindowData(),   // window data
                    settings_,                // settings
                    on_create_platform_view,  // platform view create callback
                    on_create_rasterizer      // rasterizer create callback
      );

  platform_view_ = weak_platform_view;
  FML_DCHECK(platform_view_);

  is_valid_ = shell_ != nullptr;

  if (is_valid_) {task_runners.GetRasterTaskRunner()->PostTask([]() {
      // Android describes -8 as "most important display threads, for
      // compositing the screen and retrieving input events". Conservatively
      // set the raster thread to slightly lower priority than it.
      if (::setpriority(PRIO_PROCESS, gettid(), -5) != 0) {
        // Defensive fallback. Depending on the OEM, it may not be possible
        // to set priority to -5.
        if (::setpriority(PRIO_PROCESS, gettid(), -2) != 0) {FML_LOG(ERROR) << "Failed to set GPU task runner priority";
        }
      }
    });
    task_runners.GetUITaskRunner()->PostTask([]() {if (::setpriority(PRIO_PROCESS, gettid(), -1) != 0) {FML_LOG(ERROR) << "Failed to set UI task runner priority";
      }
    });
  }
}

Shell::Create 中调用 shell = CreateShellOnPlatformThread，而后回调 on_create_platform_view

std::unique_ptr<Shell> Shell::CreateShellOnPlatformThread 中过程

创立 shell

  auto shell =
      std::unique_ptr<Shell>(new Shell(std::move(vm), task_runners, settings));

创立 platform view

  auto platform_view = on_create_platform_view(*shell.get());
  if (!platform_view || !platform_view->GetWeakPtr()) {return nullptr;

创立 rasterizer

     std::promise<std::unique_ptr<Rasterizer>> rasterizer_promise;
     auto rasterizer_future = rasterizer_promise.get_future();
     std::promise<fml::WeakPtr<SnapshotDelegate>> snapshot_delegate_promise;
     auto snapshot_delegate_future = snapshot_delegate_promise.get_future();
     fml::TaskRunner::RunNowOrPostTask(task_runners.GetRasterTaskRunner(), [&rasterizer_promise,  //
                                              &snapshot_delegate_promise,
                                              on_create_rasterizer,  //
                                              shell = shell.get()    //]() {TRACE_EVENT0("flutter", "ShellSetupGPUSubsystem");
           std::unique_ptr<Rasterizer> rasterizer(on_create_rasterizer(*shell));
           snapshot_delegate_promise.set_value(rasterizer->GetSnapshotDelegate());
           rasterizer_promise.set_value(std::move(rasterizer));
         });

创立 IO manager

    std::promise<std::unique_ptr<ShellIOManager>> io_manager_promise;
    auto io_manager_future = io_manager_promise.get_future();
    std::promise<fml::WeakPtr<ShellIOManager>> weak_io_manager_promise;
    auto weak_io_manager_future = weak_io_manager_promise.get_future();
    std::promise<fml::RefPtr<SkiaUnrefQueue>> unref_queue_promise;
    auto unref_queue_future = unref_queue_promise.get_future();
    auto io_task_runner = shell->GetTaskRunners().GetIOTaskRunner();

创立 engine

    std::promise<std::unique_ptr<Engine>> engine_promise;
    auto engine_future = engine_promise.get_future();
    fml::TaskRunner::RunNowOrPostTask(shell->GetTaskRunners().GetUITaskRunner(),
        fml::MakeCopyable([&engine_promise,                                 //
                           shell = shell.get(),                             //
                           &dispatcher_maker,                               //
                           &window_data,                                    //
                           isolate_snapshot = std::move(isolate_snapshot),  //
                           vsync_waiter = std::move(vsync_waiter),          //
                           &weak_io_manager_future,                         //
                           &snapshot_delegate_future,                       //
                           &unref_queue_future                              //
    ]() mutable {TRACE_EVENT0("flutter", "ShellSetupUISubsystem");
          const auto& task_runners = shell->GetTaskRunners();
  
          // The animator is owned by the UI thread but it gets its vsync pulses
          // from the platform.
          auto animator = std::make_unique<Animator>(*shell, task_runners,
                                                     std::move(vsync_waiter));
  
          engine_promise.set_value(std::make_unique<Engine>(
              *shell,                         //
              dispatcher_maker,               //
              *shell->GetDartVM(),            //
              std::move(isolate_snapshot),    //
              task_runners,                   //
              window_data,                    //
              shell->GetSettings(),           //
              std::move(animator),            //
              weak_io_manager_future.get(),   //
              unref_queue_future.get(),       //
              snapshot_delegate_future.get()  //));
        }));

Flutter-Android初始化流程

FlutterView

FlutterNativeView

java 到 c ++ 调用

engine 初始化

Just My Socks（注册教程内含优惠码）

Flutter-Android初始化流程

FlutterView

FlutterNativeView

java 到 c ++ 调用

engine 初始化

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）