Flutter在Android平台上启动时，Native层做了哪些工作(android,flutter,native,移动开发)

FlutterLoader

在flutterLoader中的这个startInitialization()方法中：

publicvoidstartInitialization(@NonNullContextapplicationContext,@NonNullFlutterLoader.Settingssettings){if(this.settings==null){if(Looper.myLooper()!=Looper.getMainLooper()){thrownewIllegalStateException("startInitializationmustbecalledonthemainthread");}else{....Callable<FlutterLoader.InitResult>initTask=newCallable<FlutterLoader.InitResult>(){publicFlutterLoader.InitResultcall(){....///这里是在子线程执行的System.loadLibrary("flutter");....returnnewFlutterLoader.InitResult(PathUtils.getFilesDir(appContext),PathUtils.getCacheDirectory(appContext),PathUtils.getDataDirectory(appContext));}};this.initResultFuture=Executors.newSingleThreadExecutor().submit(initTask);}}}

System.loadLibrary("flutter");并不是简单地加载flutter框架代码，它最终会进入native中的JNI_OnLoad方法：

//ThisiscalledbytheVMwhenthesharedlibraryisfirstloaded.JNIEXPORTjintJNI_OnLoad(JavaVM*vm,void*reserved){//初始化JVM（只是将虚拟机进行一个保存）//之后关联到当前线程上fml::jni::InitJavaVM(vm);JNIEnv*env=fml::jni::AttachCurrentThread();boolresult=false;//注册FlutterMain.result=flutter::FlutterMain::Register(env);FML_CHECK(result);//注册PlatformView//这里会注册大量的方法，使c++和java可以互相调用result=flutter::PlatformViewAndroid::Register(env);FML_CHECK(result);//注册VSyncWaiter.//这里将java的VSyncWaiter类中的方法与//native中的VsyncWaiterAndroid的映射，便可以互相调用result=flutter::VsyncWaiterAndroid::Register(env);FML_CHECK(result);returnJNI_VERSION_1_4;}

tip:PlatformViewAndroid路径为：engine/shell/platform/android

有兴趣的话，可以看看

整体来看，这里主要是保存了jvm，同时对c++和java的方法进行了映射以便双方可以互相调用。

至此FlutterApplication中所拉起的native代码就简单概括完了，我们接着FlutterActivity中所调用native代码。

FlutterActivity & onCreate

这里需要提一下，目前你搜索FlutterActivity这个类，会发现有两个：

android/FlutterActivity这个是最新的app/FlutterActivity已过期

经过一系列调用，具体见这篇文章： Flutter——在Android平台上的启动流程浅析,

会初始化flutterEngine，构造函数如下：

//很长，但是其中初始化的东西还是比较有用的//所以我觉得有必要贴一下/**Fullyconfigurable{@codeFlutterEngine}constructor.*/publicFlutterEngine(@NonNullContextcontext,@NonNullFlutterLoaderflutterLoader,@NonNullFlutterJNIflutterJNI,@NonNullPlatformViewsControllerplatformViewsController,@NullableString[]dartVmArgs,booleanautomaticallyRegisterPlugins,booleanwaitForRestorationData){this.dartExecutor=newDartExecutor(flutterJNI,context.getAssets());this.dartExecutor.onAttachedToJNI();accessibilityChannel=newAccessibilityChannel(dartExecutor,flutterJNI);keyEventChannel=newKeyEventChannel(dartExecutor);lifecycleChannel=newLifecycleChannel(dartExecutor);localizationChannel=newLocalizationChannel(dartExecutor);mouseCursorChannel=newMouseCursorChannel(dartExecutor);navigationChannel=newNavigationChannel(dartExecutor);platformChannel=newPlatformChannel(dartExecutor);restorationChannel=newRestorationChannel(dartExecutor,waitForRestorationData);settingsChannel=newSettingsChannel(dartExecutor);systemChannel=newSystemChannel(dartExecutor);textInputChannel=newTextInputChannel(dartExecutor);this.localizationPlugin=newLocalizationPlugin(context,localizationChannel);this.flutterJNI=flutterJNI;flutterLoader.startInitialization(context.getApplicationContext());///注意这里flutterLoader.ensureInitializationComplete(context,dartVmArgs);flutterJNI.addEngineLifecycleListener(engineLifecycleListener);flutterJNI.setPlatformViewsController(platformViewsController);flutterJNI.setLocalizationPlugin(localizationPlugin);attachToJni();//TODO(mattcarroll):FlutterRendereristemporallycoupledtoattach().Removethatcouplingif//possible.this.renderer=newFlutterRenderer(flutterJNI);this.platformViewsController=platformViewsController;this.platformViewsController.onAttachedToJNI();this.pluginRegistry=newFlutterEnginePluginRegistry(context.getApplicationContext(),this,flutterLoader);if(automaticallyRegisterPlugins){registerPlugins();}}

整个构造函数会初始化大量channel，同时进行一些native方法注册，其中：

flutterLoader.ensureInitializationComplete(context,dartVmArgs);

会转到native，详细代码如下:

///此方法会阻塞，直到native系统工作执行完毕publicvoidensureInitializationComplete(@NonNullContextapplicationContext,@NullableString[]args){if(initialized){return;}if(Looper.myLooper()!=Looper.getMainLooper()){thrownewIllegalStateException("ensureInitializationCompletemustbecalledonthemainthread");}if(settings==null){thrownewIllegalStateException("ensureInitializationCompletemustbecalledafterstartInitialization");}///收集各种文件路径try{InitResultresult=initResultFuture.get();List<String>shellArgs=newArrayList<>();shellArgs.add("--icu-symbol-prefix=_binary_icudtl_dat");ApplicationInfoapplicationInfo=getApplicationInfo(applicationContext);shellArgs.add("--icu-native-lib-path="+applicationInfo.nativeLibraryDir+File.separator+DEFAULT_LIBRARY);if(args!=null){Collections.addAll(shellArgs,args);}StringkernelPath=null;if(BuildConfig.DEBUG||BuildConfig.JIT_RELEASE){StringsnapshotAssetPath=result.dataDirPath+File.separator+flutterAssetsDir;kernelPath=snapshotAssetPath+File.separator+DEFAULT_KERNEL_BLOB;shellArgs.add("--"+SNAPSHOT_ASSET_PATH_KEY+"="+snapshotAssetPath);shellArgs.add("--"+VM_SNAPSHOT_DATA_KEY+"="+vmSnapshotData);shellArgs.add("--"+ISOLATE_SNAPSHOT_DATA_KEY+"="+isolateSnapshotData);}else{shellArgs.add("--"+AOT_SHARED_LIBRARY_NAME+"="+aotSharedLibraryName);//MostdevicescanloadtheAOTsharedlibrarybasedonthelibraryname//withnodirectorypath.Provideafullyqualifiedpathtothelibrary//asaworkaroundfordeviceswherethatfails.shellArgs.add("--"+AOT_SHARED_LIBRARY_NAME+"="+applicationInfo.nativeLibraryDir+File.separator+aotSharedLibraryName);}shellArgs.add("--cache-dir-path="+result.engineCachesPath);if(settings.getLogTag()!=null){shellArgs.add("--log-tag="+settings.getLogTag());}longinitTimeMillis=SystemClock.uptimeMillis()-initStartTimestampMillis;//TODO(cyanlaz):Removethiswhendynamicthreadmergingisdone.//https://github.com/flutter/flutter/issues/59930Bundlebundle=applicationInfo.metaData;if(bundle!=null){booleanuse_embedded_view=bundle.getBoolean("io.flutter.embedded_views_preview");if(use_embedded_view){shellArgs.add("--use-embedded-view");}}///拉起nativeFlutterJNI.nativeInit(applicationContext,shellArgs.toArray(newString[0]),kernelPath,result.appStoragePath,result.engineCachesPath,initTimeMillis);initialized=true;}catch(Exceptione){Log.e(TAG,"Flutterinitializationfailed.",e);thrownewRuntimeException(e);}}

这里会将相关的信息通过FlutterJNI.nativeInit，即：

///native方法publicstaticnativevoidnativeInit(@NonNullContextcontext,@NonNullString[]args,@NullableStringbundlePath,@NonNullStringappStoragePath,@NonNullStringengineCachesPath,longinitTimeMillis);

传递到native层,还记得上部分我们注册的flutterMain方法吗?

FlutterMain::Register

boolFlutterMain::Register(JNIEnv*env){staticconstJNINativeMethodmethods[]={{///看这里name是方法名的意思.name="nativeInit",.signature="(Landroid/content/Context;[Ljava/lang/String;Ljava/""lang/String;Ljava/lang/String;Ljava/lang/String;J)V",///方法&Init的地址被保存在了fnPtr上.fnPtr=reinterpret_cast<void*>(&Init),},{.name="nativePrefetchDefaultFontManager",.signature="()V",.fnPtr=reinterpret_cast<void*>(&PrefetchDefaultFontManager),},};jclassclazz=env->FindClass("io/flutter/embedding/engine/FlutterJNI");if(clazz==nullptr){returnfalse;}returnenv->RegisterNatives(clazz,methods,fml::size(methods))==0;}

通过指针.fnPtr = reinterpret_cast(&Init),便会拉起它的FlutterMain::Init方法。

voidFlutterMain::Init(JNIEnv*env,jclassclazz,jobjectcontext,jobjectArrayjargs,jstringkernelPath,jstringappStoragePath,jstringengineCachesPath,jlonginitTimeMillis){std::vector<std::string>args;///tagargs.push_back("flutter");///将上面我们收集的那些路径信息保存到args中///以&lsquo;j&rsquo;表示java传过来的。for(auto&arg:fml::jni::StringArrayToVector(env,jargs)){args.push_back(std::move(arg));}autocommand_line=fml::CommandLineFromIterators(args.begin(),args.end());autosettings=SettingsFromCommandLine(command_line);///engine启动时间int64_tinit_time_micros=initTimeMillis*1000;settings.engine_start_timestamp=std::chrono::microseconds(Dart_TimelineGetMicros()-init_time_micros);//Restorethecallbackcache.//TODO(chinmaygarde):RouteallcachefileaccessthroughFMLandremovethis//setter.flutter::DartCallbackCache::SetCachePath(fml::jni::JavaStringToString(env,appStoragePath));///初始化缓存路径fml::paths::InitializeAndroidCachesPath(fml::jni::JavaStringToString(env,engineCachesPath));///加载缓存flutter::DartCallbackCache::LoadCacheFromDisk();if(!flutter::DartVM::IsRunningPrecompiledCode()&&kernelPath){//Checktoseeiftheappropriatekernelfilesarepresentandconfigure//settingsaccordingly.autoapplication_kernel_path=fml::jni::JavaStringToString(env,kernelPath);if(fml::IsFile(application_kernel_path)){settings.application_kernel_asset=application_kernel_path;}}settings.task_observer_add=[](intptr_tkey,fml::closurecallback){fml::MessageLoop::GetCurrent().AddTaskObserver(key,std::move(callback));};settings.task_observer_remove=[](intptr_tkey){fml::MessageLoop::GetCurrent().RemoveTaskObserver(key);};#ifFLUTTER_RUNTIME_MODE==FLUTTER_RUNTIME_MODE_DEBUG//Therearenoownershipconcernshereasallmappingsareownedbythe//embedderandnottheengine.automake_mapping_callback=[](constuint8_t*mapping,size_tsize){return[mapping,size](){returnstd::make_unique<fml::NonOwnedMapping>(mapping,size);};};settings.dart_library_sources_kernel=make_mapping_callback(kPlatformStrongDill,kPlatformStrongDillSize);#endif//FLUTTER_RUNTIME_MODE==FLUTTER_RUNTIME_MODE_DEBUG//Notthreadsafe.WillberemovedwhenFlutterMainisrefactoredtono//longerbeasingleton.g_flutter_main.reset(newFlutterMain(std::move(settings)));g_flutter_main->SetupObservatoryUriCallback(env);}

以上主要是对java传过来的数据进行保存，至此由flutterLoader.ensureInitializationComplete所引起的native执行完毕，在其后面会执行attachToJni()。

FlutterActivity& attachToJni()

attachToJni()最终会调用flutterJNI.attachToNative(false)：

///这步完成后，android便可以与engine通信了@UiThreadpublicvoidattachToNative(booleanisBackgroundView){ensureRunningOnMainThread();ensureNotAttachedToNative();nativePlatformViewId=nativeAttach(this,isBackgroundView);}privatenativelongnativeAttach(@NonNullFlutterJNIflutterJNI,booleanisBackgroundView);

此方法会调用native的：

staticjlongAttachJNI(JNIEnv*env,jclassclazz,jobjectflutterJNI,jbooleanis_background_view){fml::jni::JavaObjectWeakGlobalRefjava_object(env,flutterJNI);std::shared_ptr<PlatformViewAndroidJNI>jni_facade=std::make_shared<PlatformViewAndroidJNIImpl>(java_object);///主要就是初始化一个shellholderautoshell_holder=std::make_unique<AndroidShellHolder>(FlutterMain::Get().GetSettings(),jni_facade,is_background_view);if(shell_holder->IsValid()){returnreinterpret_cast<jlong>(shell_holder.release());}else{return0;}}

我们来看一下AndroidShellHolder.cc的实现

AndroidShellHolder & gpu/ui/io线程的创建

它有一个100多行的构造函数:

AndroidShellHolder::AndroidShellHolder(flutter::Settingssettings,std::shared_ptr<PlatformViewAndroidJNI>jni_facade,boolis_background_view):settings_(std::move(settings)),jni_facade_(jni_facade){staticsize_tshell_count=1;autothread_label=std::to_string(shell_count++);FML_CHECK(pthread_key_create(&thread_destruct_key_,ThreadDestructCallback)==0);///这里我们传递的是falseif(is_background_view){thread_host_={thread_label,ThreadHost::Type::UI};}else{///会创建三个线程分别是UI\GPU\IOthread_host_={thread_label,ThreadHost::Type::UI|ThreadHost::Type::GPU|ThreadHost::Type::IO};}//DetachfromJNIwhentheUIandrasterthreadsexit.//UI和raster线程退出时，与JNI分离//raster就是gpu线程，它将我们的绘制指令转为gpu指令autojni_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;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){...走下面}else{///初始化了一个PlatformViewAndroidplatform_view_android=std::make_unique<PlatformViewAndroid>(shell,//delegateshell.GetTaskRunners(),//taskrunnersjni_facade,//JNIinteropshell.GetSettings().enable_software_rendering//usesoftwarerendering);}weak_platform_view=platform_view_android->GetWeakPtr();shell.OnDisplayUpdates(DisplayUpdateType::kStartup,{Display(jni_facade->GetDisplayRefreshRate())});returnplatform_view_android;};Shell::CreateCallback<Rasterizer>on_create_rasterizer=[](Shell&shell){returnstd::make_unique<Rasterizer>(shell);};//Thecurrentthreadwillbeusedastheplatformthread.Ensurethatthe//messageloopisinitialized.//初始化native的messageloop//gpu/ui/io它们也有各自的msgloopfml::MessageLoop::EnsureInitializedForCurrentThread();///初始化对应线程的taskrunner///这样我们便可以向指定线程post任务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){autosingle_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::TaskRunnerstask_runners(thread_label,//labelplatform_runner,//platformgpu_runner,//rasterui_runner,//uiio_runner//io);///提高ui和gpu线程等级///线程值越小等级越高task_runners.GetRasterTaskRunner()->PostTask([](){//Androiddescribes-8as"mostimportantdisplaythreads,for//compositingthescreenandretrievinginputevents".Conservatively//settherasterthreadtoslightlylowerprioritythanit.if(::setpriority(PRIO_PROCESS,gettid(),-5)!=0){//Defensivefallback.DependingontheOEM,itmaynotbepossible//tosetpriorityto-5.if(::setpriority(PRIO_PROCESS,gettid(),-2)!=0){FML_LOG(ERROR)<<"FailedtosetGPUtaskrunnerpriority";}}});task_runners.GetUITaskRunner()->PostTask([](){if(::setpriority(PRIO_PROCESS,gettid(),-1)!=0){FML_LOG(ERROR)<<"FailedtosetUItaskrunnerpriority";}});///创建shellshell_=Shell::Create(task_runners,//taskrunnersGetDefaultPlatformData(),//windowdatasettings_,//settingson_create_platform_view,//platformviewcreatecallbackon_create_rasterizer//rasterizercreatecallback);platform_view_=weak_platform_view;FML_DCHECK(platform_view_);is_valid_=shell_!=nullptr;}

Shell

我们接着看一下 shell_的创建:

std::unique_ptr<Shell>Shell::Create(TaskRunnerstask_runners,constPlatformDataplatform_data,Settingssettings,Shell::CreateCallback<PlatformView>on_create_platform_view,Shell::CreateCallback<Rasterizer>on_create_rasterizer){PerformInitializationTasks(settings);PersistentCache::SetCacheSkSL(settings.cache_sksl);TRACE_EVENT0("flutter","Shell::Create");///创建虚拟机autovm=DartVMRef::Create(settings);FML_CHECK(vm)<<"MustbeabletoinitializetheVM.";autovm_data=vm->GetVMData();returnShell::Create(std::move(task_runners),//std::move(platform_data),//std::move(settings),//vm_data->GetIsolateSnapshot(),//isolatesnapshoton_create_platform_view,//on_create_rasterizer,//std::move(vm)//);}

DartVMRef::Create

DartVMRefDartVMRef::Create(Settingssettings,fml::RefPtr<DartSnapshot>vm_snapshot,fml::RefPtr<DartSnapshot>isolate_snapshot){std::scoped_locklifecycle_lock(gVMMutex);...删除一些代码//这里对已有的虚拟机进行复用if(autovm=gVM.lock()){FML_DLOG(WARNING)<<"AttemptedtocreateaVMinaprocesswhereonewas""alreadyrunning.IgnoringargumentsforcurrentVM""createcallandreusingtheoldVM.";//TherewasalreadyarunningVMintheprocess,returnDartVMRef{std::move(vm)};}...删除一些代码//如果没有，就重新创建一个虚拟机autoisolate_name_server=std::make_shared<IsolateNameServer>();autovm=DartVM::Create(std::move(settings),//std::move(vm_snapshot),//std::move(isolate_snapshot),//isolate_name_server//);...删除一些代码returnDartVMRef{std::move(vm)};}

我们继续看shell的创建，最终会调用CreateShellOnPlatformThread。

Shell & CreateShellOnPlatformThread

std::unique_ptr<Shell>Shell::CreateShellOnPlatformThread(DartVMRefvm,TaskRunnerstask_runners,constPlatformDataplatform_data,Settingssettings,fml::RefPtr<constDartSnapshot>isolate_snapshot,constShell::CreateCallback<PlatformView>&on_create_platform_view,constShell::CreateCallback<Rasterizer>&on_create_rasterizer){...///创建对象autoshell=std::unique_ptr<Shell>(newShell(std::move(vm),task_runners,settings));//创建rasterizer:工作在gpu线程//这里要说一下，gpu线程还是在cpu上的，只是这个线程叫gpu而已std::promise<std::unique_ptr<Rasterizer>>rasterizer_promise;autorasterizer_future=rasterizer_promise.get_future();std::promise<fml::WeakPtr<SnapshotDelegate>>snapshot_delegate_promise;autosnapshot_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));});//在当前线程（platformthread）创建platformview.autoplatform_view=on_create_platform_view(*shell.get());if(!platform_view||!platform_view->GetWeakPtr()){returnnullptr;}//Asktheplatformviewforthevsyncwaiter.Thiswillbeusedbytheengine//tocreatetheanimator.autovsync_waiter=platform_view->CreateVSyncWaiter();if(!vsync_waiter){returnnullptr;}...删除部分代码...///通过向io线程posttask来创建iomanagerfml::TaskRunner::RunNowOrPostTask(io_task_runner,[&io_manager_promise,//&weak_io_manager_promise,//&unref_queue_promise,//platform_view=platform_view->GetWeakPtr(),//io_task_runner,//is_backgrounded_sync_switch=shell->GetIsGpuDisabledSyncSwitch()//](){TRACE_EVENT0("flutter","ShellSetupIOSubsystem");autoio_manager=std::make_unique<ShellIOManager>(platform_view.getUnsafe()->CreateResourceContext(),is_backgrounded_sync_switch,io_task_runner);weak_io_manager_promise.set_value(io_manager->GetWeakPtr());unref_queue_promise.set_value(io_manager->GetSkiaUnrefQueue());io_manager_promise.set_value(std::move(io_manager));});//Senddispatcher_makertotheengineconstructorbecauseshellwon'thave//platform_viewsetuntilShell::Setupiscalledlater.autodispatcher_maker=platform_view->GetDispatcherMaker();//在ui线程创建engine//这里的engine指针被跨线程使用std::promise<std::unique_ptr<Engine>>engine_promise;autoengine_future=engine_promise.get_future();fml::TaskRunner::RunNowOrPostTask(shell->GetTaskRunners().GetUITaskRunner(),fml::MakeCopyable([&engine_promise,//shell=shell.get(),//&dispatcher_maker,//&platform_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");constauto&task_runners=shell->GetTaskRunners();//创建animator（ui线程）autoanimator=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,//platform_data,//shell->GetSettings(),//std::move(animator),//weak_io_manager_future.get(),//unref_queue_future.get(),//snapshot_delegate_future.get()//));}));if(!shell->Setup(std::move(platform_view),//engine_future.get(),//rasterizer_future.get(),//io_manager_future.get())//){returnnullptr;}returnshell;}

由于代码太长，这里再汇总一下：

shell初始化之后，还有分别在io/ui/gpu/platform线程创建以下对象：

• rasterizer 在gpu线程工作，负责将绘制指令转为gpu指令

• platform view 在当前线程(platform thread)

• engine 和 animator 在ui线程工作

flutter最终会通过animator向platformView 申请VSync信号

接下来我们再看一下上面代码中对engine的初始化。

Engine

代码相对较少，但是连接的东西非常多：

Engine::Engine(Delegate&delegate,constPointerDataDispatcherMaker&dispatcher_maker,DartVM&vm,fml::RefPtr<constDartSnapshot>isolate_snapshot,TaskRunnerstask_runners,constPlatformDataplatform_data,Settingssettings,std::unique_ptr<Animator>animator,fml::WeakPtr<IOManager>io_manager,fml::RefPtr<SkiaUnrefQueue>unref_queue,fml::WeakPtr<SnapshotDelegate>snapshot_delegate):Engine(delegate,dispatcher_maker,vm.GetConcurrentWorkerTaskRunner(),task_runners,settings,std::move(animator),io_manager,nullptr){runtime_controller_=std::make_unique<RuntimeController>(*this,//runtimedelegate&vm,//VMstd::move(isolate_snapshot),//isolatesnapshottask_runners_,//taskrunnersstd::move(snapshot_delegate),//snapshotdelegateGetWeakPtr(),//hintfreeddelegatestd::move(io_manager),//iomanagerstd::move(unref_queue),//Skiaunrefqueueimage_decoder_.GetWeakPtr(),//imagedecodersettings_.advisory_script_uri,//advisoryscripturisettings_.advisory_script_entrypoint,//advisoryscriptentrypointsettings_.idle_notification_callback,//idlenotificationcallbackplatform_data,//platformdatasettings_.isolate_create_callback,//isolatecreatecallbacksettings_.isolate_shutdown_callback,//isolateshutdowncallbacksettings_.persistent_isolate_data//persistentisolatedata);}

就是创建了一个runtime_controller_ ,你可以将runtime controller 看做native、platform和flutter的一个纽带。

小结

经过上面一系列的代码，可能有点晕，概括来讲Flutter Activity在注册flutterMain过程中会创建初始化shell，而在这个初始化的过程中，我们分别会创建三个线程，算上当前线程的话，就是4个：

• platform 线程(当前线程)

• ui 线程

• gpu 线程

• io 线程

并初始化一系列重要对象。

好的，我们再回到主线，onCreate()已经过了，下面我们可以看一下onStart()生命周期：

FlutterActivity & onStart

此方法会调用 delegate.onStart(); 并最终调用FlutterJNI的native方法：

privatenativevoidnativeRunBundleAndSnapshotFromLibrary(longnativePlatformViewId,@NonNullStringbundlePath,@NullableStringentrypointFunctionName,@NullableStringpathToEntrypointFunction,@NonNullAssetManagermanager);

从这里开始，其终点就是执行dart的代码。

Launch

接着我们看一下native方法：

(位置在platform_view_android_jni_impl.cc)

staticvoidRunBundleAndSnapshotFromLibrary(JNIEnv*env,jobjectjcaller,jlongshell_holder,jstringjBundlePath,jstringjEntrypoint,jstringjLibraryUrl,jobjectjAssetManager){...删除部分代码///这里主要是根据参数，生成一个config并用于启动///我们的默认启动入口'main()'就在这个config里ANDROID_SHELL_HOLDER->Launch(std::move(config));}

我们接着看Launch(std::move(config));方法:

voidAndroidShellHolder::Launch(RunConfigurationconfig){if(!IsValid()){return;}shell_->RunEngine(std::move(config));}

又调用了 run engine 方法:

voidShell::RunEngine(RunConfigurationrun_configuration,conststd::function<void(Engine::RunStatus)>&result_callback){...删除一些代码///向ui线程post了一个任务fml::TaskRunner::RunNowOrPostTask(task_runners_.GetUITaskRunner(),fml::MakeCopyable([run_configuration=std::move(run_configuration),weak_engine=weak_engine_,result]()mutable{if(!weak_engine){FML_LOG(ERROR)<<"Couldnotlaunchenginewithconfiguration-noengine.";result(Engine::RunStatus::Failure);return;}///调用engine的run方法autorun_result=weak_engine->Run(std::move(run_configuration));if(run_result==flutter::Engine::RunStatus::Failure){FML_LOG(ERROR)<<"Couldnotlaunchenginewithconfiguration.";}result(run_result);}));}

Engin.run()

Engine::RunStatusEngine::Run(RunConfigurationconfiguration){if(!configuration.IsValid()){FML_LOG(ERROR)<<"Enginerunconfigurationwasinvalid.";returnRunStatus::Failure;}///获取要执行的dart代码入口点///这里就是main方法frommian.dartlast_entry_point_=configuration.GetEntrypoint();last_entry_point_library_=configuration.GetEntrypointLibrary();....///调用了LaunchRootIsolate方法if(!runtime_controller_->LaunchRootIsolate(settings_,//configuration.GetEntrypoint(),//configuration.GetEntrypointLibrary(),//configuration.TakeIsolateConfiguration())//){returnRunStatus::Failure;}...删除部分代码returnEngine::RunStatus::Success;}

LaunchRootIsolate

boolRuntimeController::LaunchRootIsolate(constSettings&settings,std::optional<std::string>dart_entrypoint,std::optional<std::string>dart_entrypoint_library,std::unique_ptr<IsolateConfiguration>isolate_configuration){if(root_isolate_.lock()){FML_LOG(ERROR)<<"Rootisolatewasalreadyrunning.";returnfalse;}///创建一个&lsquo;运行&rsquo;的rootisolateautostrong_root_isolate=DartIsolate::CreateRunningRootIsolate(settings,//配置isolate_snapshot_,//快照task_runners_,//std::make_unique<PlatformConfiguration>(this),//平台配置snapshot_delegate_,//hint_freed_delegate_,//io_manager_,//io管理运行在Io线程unref_queue_,//image_decoder_,//图片解码advisory_script_uri_,//advisory_script_entrypoint_,//DartIsolate::Flags{},//isolate_create_callback_,//isolate_shutdown_callback_,//dart_entrypoint,//入口方法(main.dart)dart_entrypoint_library,//入口库std::move(isolate_configuration)//).lock();...删除部分代码returntrue;}

我们看一下DartIsolate的CreateRunningRootIsolate方法

DartIsolate::CreateRunningRootIsolate

std::weak_ptr<DartIsolate>DartIsolate::CreateRunningRootIsolate(constSettings&settings,fml::RefPtr<constDartSnapshot>isolate_snapshot,TaskRunnerstask_runners,std::unique_ptr<PlatformConfiguration>platform_configuration,fml::WeakPtr<SnapshotDelegate>snapshot_delegate,fml::WeakPtr<HintFreedDelegate>hint_freed_delegate,fml::WeakPtr<IOManager>io_manager,fml::RefPtr<SkiaUnrefQueue>skia_unref_queue,fml::WeakPtr<ImageDecoder>image_decoder,std::stringadvisory_script_uri,std::stringadvisory_script_entrypoint,Flagsisolate_flags,constfml::closure&isolate_create_callback,constfml::closure&isolate_shutdown_callback,std::optional<std::string>dart_entrypoint,std::optional<std::string>dart_entrypoint_library,std::unique_ptr<IsolateConfiguration>isolate_configration){...删除代码///这里创建了一个isolate但是非运行的autoisolate=CreateRootIsolate(settings,//isolate_snapshot,//task_runners,//std::move(platform_configuration),//snapshot_delegate,//hint_freed_delegate,//io_manager,//skia_unref_queue,//image_decoder,//advisory_script_uri,//advisory_script_entrypoint,//isolate_flags,//isolate_create_callback,//isolate_shutdown_callback//).lock();...删除部分代码（主要是对isolate的状态检查）//注意这个方法if(!isolate->RunFromLibrary(dart_entrypoint_library,//dart_entrypoint,//settings.dart_entrypoint_args//)){FML_LOG(ERROR)<<"CouldnotruntherunmainDartentrypoint.";return{};}if(settings.root_isolate_shutdown_callback){isolate->AddIsolateShutdownCallback(settings.root_isolate_shutdown_callback);}shutdown_on_error.Release();returnisolate;}

创建isolate后，进一步调用RunFromLibrary 这个方法:

tip:注意这个过程携带的参数。

boolDartIsolate::RunFromLibrary(std::optional<std::string>library_name,std::optional<std::string>entrypoint,conststd::vector<std::string>&args){TRACE_EVENT0("flutter","DartIsolate::RunFromLibrary");///isolate非准备状态，直接退出if(phase_!=Phase::Ready){returnfalse;}tonic::DartState::Scopescope(this);...删除部分代码///这里进一步调用了InvokeMainEntrypoint方法if(!InvokeMainEntrypoint(user_entrypoint_function,entrypoint_args)){returnfalse;}///设置isolate为运行状态phase_=Phase::Running;returntrue;}

InvokeMainEntrypoint:

[[nodiscard]]staticboolInvokeMainEntrypoint(Dart_Handleuser_entrypoint_function,Dart_Handleargs){...删除部分代码///这里，会通过DartInvokeField///拉起我们的main.dart中的main()方法并开始flutter的运行///PS:这个入口点也可以自定义，不过很少用到if(tonic::LogIfError(tonic::DartInvokeField(Dart_LookupLibrary(tonic::ToDart("dart:ui")),"_runMainZoned",{start_main_isolate_function,user_entrypoint_function,args}))){FML_LOG(ERROR)<<"Couldnotinvokethemainentrypoint.";returnfalse;}returntrue;}