io.flutter.embedding.android.FlutterActivity（如无特殊说明，下文中的FlutterActivity单指此包下的类。）重写了android.app.Activity中的onCreate方法：
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
//...
setContentView(createFlutterView());
//...
}
再来看一下方法createFlutterView()的源码：
@NonNull
private View createFlutterView() {
return delegate.onCreateView(null,null,null,FLUTTER_VIEW_ID,getRenderMode() == RenderMode.surface);
}
可以看到，这里调用了一个delegate的onCreateView(…)方法。这个变量delegate是什么东西？在哪里被设值了？可以变更吗？它是FlutterActivity中的一个变量：
protected FlutterActivityAndFragmentDelegate delegate;
它在onCreate方法中被初始化了：
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
//...
delegate = new FlutterActivityAndFragmentDelegate(this);
//...
setContentView(createFlutterView());
//...
}
接着看一下这个delegate的onCreateView(…)方法的源码：
@NonNull
View onCreateView(
LayoutInflater inflater,
@Nullable ViewGroup container,
@Nullable Bundle savedInstanceState,
int flutterViewId,
boolean shouldDelayFirstAndroidViewDraw) {
//...
flutterView.attachToFlutterEngine(flutterEngine);
//...
}
大致意思就是把flutterView attach到FlutterEngine（Flutter引擎）上去，并且提供了一个引擎对象flutterEngine。FlutterEngine是什么？简单地说，它使得在Android Application中执行Dart成为可能。再简单点说，它就是一个黑盒子，里面在执行Dart代码。至于它到底还干了什么别的，具体怎么干的？我也不知道。
接下来找找看这个引擎对象是如何被初始化的。
class FlutterActivityAndFragmentDelegate implements ... {
@Nullable private FlutterEngine flutterEngine;
void setupFlutterEngine() {
//...
// First, check if the host wants to use a cached FlutterEngine.
//...
// Second, defer to subclasses for a custom FlutterEngine.
//...
// Our host did not provide a custom FlutterEngine. Create a FlutterEngine to back our
// FlutterView.
//...
}
}
源码注释的大致意思应该是：第一步，缓存的引擎用不用？用就返回。第二步，子类有没有提供自己的引擎？有就返回。第三步，创建一个，并返回。这里暂且不管它的引擎缓存机制是如何实现的，也不管它的子类提供引擎的机制是什么，先看一下它是如何被创建出来的。
void setupFlutterEngine() {
//...
flutterEngine = new FlutterEngine(
host.getContext(),
host.getFlutterShellArgs().toArray(),
false,
host.shouldRestoreAndSaveState());
//...
}
只是调了一个构造而已嘛！没什么大不了的。当我们仔细地观察会发现，所有构造器最后都指向同一个构造器，即
public FlutterEngine(
@NonNull Context context,
@Nullable FlutterLoader flutterLoader,
@NonNull FlutterJNI flutterJNI,
@NonNull PlatformViewsController platformViewsController,
@Nullable String[] dartVmArgs,
boolean automaticallyRegisterPlugins,
boolean waitForRestorationData)
此处，我们暂且不关注该构造器的具体实现，只看该方法的最后几行代码，如下所示：
//...
if (automaticallyRegisterPlugins && flutterLoader.automaticallyRegisterPlugins()) {
GeneratedPluginRegister.registerGeneratedPlugins(this);
}
public static void registerGeneratedPlugins(@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.e(
TAG,
"Tried to automatically register plugins with FlutterEngine ("
+ flutterEngine
+ ") but could not find or invoke the GeneratedPluginRegistrant.");
Log.e(TAG, "Received exception while registering", e);
}
}
这是一段极为普通的反射代码，它执行了类io.flutter.plugins.GeneratedPluginRegistrant的方法registerWith，是不是非常眼熟了？在我们的Flutter APP中android文件夹下就有一个自动生成的类与之同名，即
public final class GeneratedPluginRegistrant {
private static final String TAG = "GeneratedPluginRegistrant";
public static void registerWith(@NonNull FlutterEngine flutterEngine) {
//...
}
}
现在我们知道了，当引擎被构造时，就会去注册插件。那么除了这一时机之外，还会有其它时机注册插件吗？
FlutterActivity类有代码如下所示：
@Override
public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
//...
GeneratedPluginRegister.registerGeneratedPlugins(flutterEngine);
}
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
//...
delegate = new FlutterActivityAndFragmentDelegate(this);
delegate.onAttach(this);
//...
setContentView(createFlutterView());
//...
}
FlutterFragmentActivity类有代码如下所示：
@Override
public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
//...
GeneratedPluginRegister.registerGeneratedPlugins(flutterEngine);
}
FlutterActivityAndFragmentDelegate类有代码如下所示：
void onAttach(@NonNull Context context) {
//...
if (flutterEngine == null) {
setupFlutterEngine();
}
//...
host.configureFlutterEngine(flutterEngine);
isAttached = true;
}
FlutterFragment类有代码如下所示：
@Override
public void configureFlutterEngine(@NonNull FlutterEngine flutterEngine) {
FragmentActivity attachedActivity = getActivity();
if (attachedActivity instanceof FlutterEngineConfigurator) {
((FlutterEngineConfigurator) attachedActivity).configureFlutterEngine(flutterEngine);
}
}
@Override
public void onAttach(@NonNull Context context) {
super.onAttach(context);
delegate = new FlutterActivityAndFragmentDelegate(this);
delegate.onAttach(context);
//...
}
综上，上面的问题也就迎刃而解了。
接下来先看一下引擎这个类的大致格局：
public class FlutterEngine {
//...
@NonNull private final FlutterJNI flutterJNI;
@NonNull private final FlutterRenderer renderer;
@NonNull private final DartExecutor dartExecutor;
@NonNull private final FlutterEngineConnectionRegistry pluginRegistry;
@NonNull private final LocalizationPlugin localizationPlugin;
// System channels.
@NonNull private final AccessibilityChannel accessibilityChannel;
@NonNull private final DeferredComponentChannel deferredComponentChannel;
@NonNull private final KeyEventChannel keyEventChannel;
@NonNull private final LifecycleChannel lifecycleChannel;
@NonNull private final LocalizationChannel localizationChannel;
@NonNull private final MouseCursorChannel mouseCursorChannel;
@NonNull private final NavigationChannel navigationChannel;
@NonNull private final RestorationChannel restorationChannel;
@NonNull private final PlatformChannel platformChannel;
@NonNull private final SettingsChannel settingsChannel;
@NonNull private final SystemChannel systemChannel;
@NonNull private final TextInputChannel textInputChannel;
// Platform Views.
@NonNull private final PlatformViewsController platformViewsController;
// Engine Lifecycle.
@NonNull private final Set<EngineLifecycleListener> engineLifecycleListeners = new HashSet<>();
@NonNull
private final EngineLifecycleListener engineLifecycleListener =...;
//...
}
所有域都是非空final的，这给源码阅读带来好处，因为设值的地方肯定只有一处。此类除了这些域之外，还有各种构造、各种通道、插件注册和引擎生命周期相关的方法。
先看引擎生命周期。
public void addEngineLifecycleListener(@NonNull EngineLifecycleListener listener){//...}
public void removeEngineLifecycleListener(@NonNull EngineLifecycleListener listener){//...}
public interface EngineLifecycleListener {
void onPreEngineRestart();
void onEngineWillDestroy();
}
可以看到引擎提供了一个引擎生命周期监听器接口、两个方法，分别是添加、删除引擎生命周期监听器。源码看到此处，免不得要实践一下，试试这个接口中的两个方法是否会回调。
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
final FlutterEngine fe = getFlutterEngine();
if (fe != null) {
fe.addEngineLifecycleListener(new FlutterEngine.EngineLifecycleListener() {
@Override
public void onPreEngineRestart() {
Log.d("Harry", "onPreEngineRestart");
}
@Override
public void onEngineWillDestroy() {
Log.d("Harry", "onEngineWillDestroy");
}
});
}
}
在FlutterActivity的子类MainActivity中重写onCreate方法，然后添加一个监听器即可。然后在命令行中使用flutter run启动Flutter应用程序，待应用程序启动完毕后，在终端输入大写的R，即Hot restart，然后按返回键退出应用程序，在日志中便可以看到日志如下所示：
2022-04-23 18:35:12.578 ... D/Harry: onPreEngineRestart
2022-04-23 18:45:10.733 ... D/Harry: onEngineWillDestroy
在FlutterEngine类中，第一个非空final域就是变量flutterJNI，那么就进去走马观花一下。进去一看，才发现这个类1000多行代码，这得看到猴年马月去！算了，不看了，不看了。
既来之，则安之。随便看看何妨？又不是进来寻找武林至尊秘籍的，看着不爽咱就撤。
闲言少叙，开始走马观花。
public void loadLibrary() {
//...
System.loadLibrary("flutter");
//...
}
这段代码应该很熟悉哦？就是加载libflutter.so库。
private static native void nativeInit(
@NonNull Context context,
@NonNull String[] args,
@Nullable String bundlePath,
@NonNull String appStoragePath,
@NonNull String engineCachesPath,
long initTimeMillis);
public void init(
@NonNull Context context,
@NonNull String[] args,
@Nullable String bundlePath,
@NonNull String appStoragePath,
@NonNull String engineCachesPath,
long initTimeMillis) {
//...
FlutterJNI.nativeInit(context, args, bundlePath, appStoragePath, engineCachesPath, initTimeMillis);
//...
}
看样子，这里就是初始化FlutterJNI的地方了，只是它调用了一个native方法，换言之，真正初始化的代码在底层，是用C/C++完成的。咦！这好像一个小黑洞，洞外山丘高耸、丛林密布，站在洞外往里看，深不可测，甚是神秘。它太吸引人了，咱不妨动动手指往里探探？你能忍住不这么做？
在shell/platform/android目录下，有个flutter_main.h头文件。
//...
class FlutterMain {
public:
//...
private:
//...
static void Init(JNIEnv* env,
jclass clazz,
jobject context,
jobjectArray jargs,
jstring kernelPath,
jstring appStoragePath,
jstring engineCachesPath,
jlong initTimeMillis);
//..
};
看来是用C++写的。此处的static void Init(...)函数和前面提到的private static native void nativeInit(...)方法的参数是不是甚为相似？在Init(...)函数形参中，前两个参数env和clazz分别代表jni执行环境（参看Java与C/C++交互相关内容）和FlutterJNI类对象（因为nativeInit(...)方法是用static修饰的）。这里是头文件，只是声明了该函数的签名，该函数的具体实现还得看源文件，接下来打开flutter_main.cc源文件，这个文件篇幅还可以，200多行代码。
咱先找找看，是什么把上面提到的一个函数和一个方法进行关联起来的。
bool FlutterMain::Register(JNIEnv* env) {
static const JNINativeMethod methods[] = {
{
.name = "nativeInit",
.signature = "(Landroid/content/Context;[Ljava/lang/String;Ljava/"
"lang/String;Ljava/lang/String;Ljava/lang/String;J)V",
.fnPtr = reinterpret_cast<void*>(&Init),
},
//...
};
jclass clazz = env->FindClass("io/flutter/embedding/engine/FlutterJNI");
//...
}
这段代码可以证明上面所说的是正确的。况且这段代码不难理解：方法有名字、签名、函数指针，分别对应代码中的name、signature、fnPtr，其中函数指针就是上面头文件里声明的Init(...)函数，至于reinterpret_cast到底啥意思也不必深究，说白了就是强制转换，然后用jni找到FlutterJNI类对象。咱知道这些就够了，毕竟是走马观花嘛！哦对了，咱的马还栓在洞外呢！这个洞里是不是很爽？冬暖夏凉。哎呀！哪里来的水流淋在咱头上了？
好，回到正题上，再探探FlutterJNI底层初始化是怎么做的？
void FlutterMain::Init(JNIEnv* env,
jclass clazz,
jobject context,
jobjectArray jargs,
jstring kernelPath,
jstring appStoragePath,
jstring engineCachesPath,
jlong initTimeMillis) {
std::vector<std::string> args;
args.push_back("flutter");
for (auto& arg : fml::jni::StringArrayToVector(env, jargs)) {
args.push_back(std::move(arg));
}
auto command_line = fml::CommandLineFromIterators(args.begin(), args.end());
auto settings = SettingsFromCommandLine(command_line);
//...
g_flutter_main.reset(new FlutterMain(std::move(settings)));
//...
}
大致意思就是，定义一个向量，相当于数组，然后往里塞字符串"flutter"，再往里塞其它必要的参数，之后生成命令行，根据命令行生成settings，最后构造一个FlutterMain的对象。知道了这些，好像没啥用哦。
你挑上担，他牵上马，我继续观花。
@Nullable private PlatformMessageHandler platformMessageHandler;
刚走不久，这个变量引起了我的注意，表面意思是平台消息Handler，干嘛用的呢？先猜猜看，这里所说的platform可能是跨平台的平台，相当于Android、iOS等。猜错了也没关系嘛。既然是平台消息，那多多少少跟Flutter与这些平台之间的消息交互挂点钩。
/** Handler that receives messages from Dart code. */
public interface PlatformMessageHandler {
void handleMessageFromDart(
@NonNull final String channel,
@Nullable ByteBuffer message,
final int replyId,
long messageData);
void handlePlatformMessageResponse(int replyId, @Nullable ByteBuffer reply);
}
没打开这个类之前，原以为这个类会相当庞大，没想到就这么几行而已。这个类的注释写着：这是一个Handler，用来接收从Dart那儿发过来的消息。Dart发给谁的消息要它接收呀？引擎本身，还是Android？既然Dart会有消息发过来，那么这边肯定可以发消息给Dart。既然如此，那又是怎么做到的呢？咱继续看。
private native void nativeDispatchEmptyPlatformMessage(
long nativeShellHolderId, @NonNull String channel, int responseId);
这是FlutterJNI对象可以调用的本地方法，用来发送一条空平台消息给Dart。不出意料，又是C/C++底层实现的。咱去找找看，到底是如何实现的。
在shell/platform/android目录下，有个platform_view_android_jni_impl.cc源文件。
{
.name = "nativeDispatchEmptyPlatformMessage",
.signature = "(JLjava/lang/String;I)V",
.fnPtr = reinterpret_cast<void*>(&DispatchEmptyPlatformMessage),
}
顺藤摸瓜。
void PlatformViewAndroid::DispatchEmptyPlatformMessage(JNIEnv* env,
std::string name,
jint response_id) {
fml::RefPtr<flutter::PlatformMessageResponse> response;
if (response_id) {
response = fml::MakeRefCounted<PlatformMessageResponseAndroid>(
response_id, jni_facade_, task_runners_.GetPlatformTaskRunner());
}
PlatformView::DispatchPlatformMessage(
std::make_unique<flutter::PlatformMessage>(std::move(name),
std::move(response)));
}
这是分发空平台消息的底层实现，什么意思呢？如果response_id非0，就给response指针赋一个值，连带name，交付给PlatformView::DispatchPlatformMessage(...)的。那么此函数又是如何实现的呢？
void PlatformView::DispatchPlatformMessage(
std::unique_ptr<PlatformMessage> message) {
delegate_.OnPlatformViewDispatchPlatformMessage(std::move(message));
}
不禁要问，这里的delegate_是什么，这个函数又做了什么？这里将它理解为一个平台视图的委托即可。
void Shell::OnPlatformViewDispatchPlatformMessage(
std::unique_ptr<PlatformMessage> message) {
//...
task_runners_.GetUITaskRunner()->PostTask(fml::MakeCopyable(
[engine = engine_->GetWeakPtr(), message = std::move(message)]() mutable {
if (engine) {
engine->DispatchPlatformMessage(std::move(message));
}
}));
}
原来是往任务队列里塞了一个任务，而这个任务就是发送消息。那么上面代码中的engine->DispatchPlatformMessage(std::move(message));又做了件什么事情呢？
void Engine::DispatchPlatformMessage(std::unique_ptr<PlatformMessage> message) {
std::string channel = message->channel();
if (channel == kLifecycleChannel) {
if (HandleLifecyclePlatformMessage(message.get())) {
return;
}
} else if (channel == kLocalizationChannel) {
if (HandleLocalizationPlatformMessage(message.get())) {
return;
}
} else if (channel == kSettingsChannel) {
HandleSettingsPlatformMessage(message.get());
return;
} else if (!runtime_controller_->IsRootIsolateRunning() &&
channel == kNavigationChannel) {
// If there's no runtime_, we may still need to set the initial route.
HandleNavigationPlatformMessage(std::move(message));
return;
}
if (runtime_controller_->IsRootIsolateRunning() &&
runtime_controller_->DispatchPlatformMessage(std::move(message))) {
return;
}
FML_DLOG(WARNING) << "Dropping platform message on channel: " << channel;
}
然后就是根据不同的通道进行消息分发。这里咱不看其它通道消息是如何分发的，单看最后一个运行时控制器是如何分发消息的。
bool RuntimeController::DispatchPlatformMessage(
std::unique_ptr<PlatformMessage> message) {
//...
platform_configuration->DispatchPlatformMessage(std::move(message));
//...
}
怎么调用还没完！我都快没耐心了！
void PlatformConfiguration::DispatchPlatformMessage(
std::unique_ptr<PlatformMessage> message) {
//...
tonic::CheckAndHandleError(
tonic::DartInvoke(dispatch_platform_message_.Get(),
{tonic::ToDart(message->channel()), data_handle,
tonic::ToDart(response_id)}));
}
好像有门儿！。
Dart_Handle DartInvoke(Dart_Handle closure,
std::initializer_list<Dart_Handle> args) {
int argc = args.size();
Dart_Handle* argv = const_cast<Dart_Handle*>(args.begin());
Dart_Handle handle = Dart_InvokeClosure(closure, argc, argv);
CheckAndHandleError(handle);
return handle;
}
函数参数是一个闭包和一个列表，实现是把列表大小给argc，argv指向列表头，然后传入参数执行闭包。这里的闭包实参应该就是上面的dispatch_platform_message_.Get()，列表实参应该就是上面的
{tonic::ToDart(message->channel()), data_handle,tonic::ToDart(response_id)}。
在FlutterEngine类中，第二个非空final域就是变量renderer，那么就进去走马观花一下。顾名思义，它是一个渲染器，用来在Android视图层次结构中把Flutter页面绘制出来。那么绘制在哪里呢？这不废话嘛！前一句不是刚说完嘛！这里说的是更直接的地方，它是一个Surface，是由RenderSurface提供的。那RenderSurface又是什么呢？
public interface RenderSurface {
@Nullable
FlutterRenderer getAttachedRenderer();
void attachToRenderer(@NonNull FlutterRenderer renderer);
void detachFromRenderer();
void pause();
}
以上便是它的所有代码了，可是它是如何提供Surface的呢？它只是一个接口，那么要从它的实现者入手了。
public class FlutterImageView extends View implements RenderSurface
public class FlutterSurfaceView extends SurfaceView implements RenderSurface
public class FlutterTextureView extends TextureView implements RenderSurface
从源码可以清晰地发现，它的实现者有三个，分别是：FlutterImageView、FlutterSurfaceView、FlutterTextureView。好了，到目前为止，已经知道了真正提供Surface的是谁了，至于它们仨又是如何实现的，此处不作赘述。
@NonNull private final FlutterJNI flutterJNI;
//...
private boolean isDisplayingFlutterUi = false;
private final FlutterUiDisplayListener flutterUiDisplayListener =
new FlutterUiDisplayListener() {
@Override
public void onFlutterUiDisplayed() {
isDisplayingFlutterUi = true;
}
@Override
public void onFlutterUiNoLongerDisplayed() {
isDisplayingFlutterUi = false;
}
};
public FlutterRenderer(@NonNull FlutterJNI flutterJNI) {
this.flutterJNI = flutterJNI;
this.flutterJNI.addIsDisplayingFlutterUiListener(flutterUiDisplayListener);
}
看，以上便是构造器的全貎了，设置了一个flutterJNI，添加了一个监听器。这个构造器在哪里被调用了呢？
FlutterEngine构造器中FlutterView构造器中
另外，这个监听器的回调是在何时发生的呢？
public void onFirstFrame() {
//...
for (FlutterUiDisplayListener listener : flutterUiDisplayListeners) {
listener.onFlutterUiDisplayed();
}
}
void onRenderingStopped() {
//...
for (FlutterUiDisplayListener listener : flutterUiDisplayListeners) {
listener.onFlutterUiNoLongerDisplayed();
}
}
以上两个实例方法是定义在FlutterJNI中的。根据其方法名可以窥见监听回调的发生时机。再深入的是这两个实例方法的调用时机，此处不作介绍。
public void startRenderingToSurface(@NonNull Surface surface, boolean keepCurrentSurface) {
//...
if (this.surface != null && !keepCurrentSurface) {
stopRenderingToSurface();
}
this.surface = surface;
flutterJNI.onSurfaceCreated(surface);
}
再来看渲染器如何启动渲染工作的。设置surface，然后通知flutterJNI有surface了。咱尝试着看一下flutterJNI是如何处理这一通知的。
public void onSurfaceCreated(@NonNull Surface surface) {
//...
nativeSurfaceCreated(nativeShellHolderId, surface);
}
private native void nativeSurfaceCreated(long nativeShellHolderId, @NonNull Surface surface);
static void SurfaceCreated(JNIEnv* env,
jobject jcaller,
jlong shell_holder,
jobject jsurface) {
// ...
auto window = fml::MakeRefCounted<AndroidNativeWindow>(
ANativeWindow_fromSurface(env, jsurface));
ANDROID_SHELL_HOLDER->GetPlatformView()->NotifyCreated(std::move(window));
}
void PlatformViewAndroid::NotifyCreated(
fml::RefPtr<AndroidNativeWindow> native_window) {
//...
PlatformView::NotifyCreated();
}
原来是通知了平台视图。那么之后又做了什么呢？咱先看一下这个函数的实现：
void PlatformView::NotifyCreated() {
std::unique_ptr<Surface> surface;
// Threading: We want to use the platform view on the non-platform thread.
// Using the weak pointer is illegal. But, we are going to introduce a latch
// so that the platform view is not collected till the surface is obtained.
auto* platform_view = this;
fml::ManualResetWaitableEvent latch;
fml::TaskRunner::RunNowOrPostTask(
task_runners_.GetRasterTaskRunner(), [platform_view, &surface, &latch]() {
surface = platform_view->CreateRenderingSurface();
if (surface && !surface->IsValid()) {
surface.reset();
}
latch.Signal();
});
latch.Wait();
if (!surface) {
FML_LOG(ERROR) << "Failed to create platform view rendering surface";
return;
}
delegate_.OnPlatformViewCreated(std::move(surface));
}
说真的，我也看不懂啥意思，但是没关系，我可以瞎猜嘛，猜错了也不用付费的。如果读者有自己的想法，甚至与我相悖，也没事。下面是我瞎猜的内容：有一个信号量latch，它一直在等待，直到surface被造出来，然后执行最后一句代码。那surface是如何被造出来的呢？
std::unique_ptr<Surface> PlatformViewAndroid::CreateRenderingSurface() {
if (!android_surface_) {
return nullptr;
}
return android_surface_->CreateGPUSurface(
android_context_->GetMainSkiaContext().get());
}
好了，到此处为止，可以知道它返回的是CreateGPUSurface函数的返回值。Flutter的渲染是直接由GPU处理的，而Skia是Google的图形渲染引擎。再详细的内容，这里不关心。不过，可以看一下这里的android_surface_是哪儿来的。
PlatformViewAndroid::PlatformViewAndroid(...) {
if (android_context_) {
//...
android_surface_ = surface_factory_->CreateSurface();
//...
}
}
std::unique_ptr<AndroidSurface> AndroidSurfaceFactoryImpl::CreateSurface() {
switch (android_context_->RenderingApi()) {
case AndroidRenderingAPI::kSoftware:
return std::make_unique<AndroidSurfaceSoftware>(android_context_,
jni_facade_);
case AndroidRenderingAPI::kOpenGLES:
return std::make_unique<AndroidSurfaceGL>(android_context_, jni_facade_);
default:
FML_DCHECK(false);
return nullptr;
}
}
enum class AndroidRenderingAPI {
kSoftware,
kOpenGLES,
};
好了，看清楚了，它是由工厂创建的，还分为两种方式进行创建，分别为kSoftware、kOpenGLES。
接下来还剩上文中的void PlatformView::NotifyCreated()定义中的最后一句代码没说了。
void Shell::OnPlatformViewCreated(std::unique_ptr<Surface> surface) {
//...
auto ui_task = [engine = engine_->GetWeakPtr()] {
if (engine) {
engine->ScheduleFrame();
}
};
//...
sk_sp<GrDirectContext> resource_context =
platform_view->CreateResourceContext();
//...
}
调度帧、创建资源上下文。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）