| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/ui/scenic/bin/app.h" |
| |
| #include <fuchsia/hardware/display/cpp/fidl.h> |
| #include <fuchsia/vulkan/loader/cpp/fidl.h> |
| #include <lib/component/incoming/cpp/protocol.h> |
| #include <lib/syslog/cpp/macros.h> |
| |
| #include <cstdint> |
| #include <memory> |
| #include <optional> |
| |
| #include "rapidjson/document.h" |
| #include "src/graphics/display/lib/coordinator-getter/client.h" |
| #include "src/lib/files/file.h" |
| #include "src/lib/fxl/functional/cancelable_callback.h" |
| #include "src/ui/lib/escher/vk/pipeline_builder.h" |
| #include "src/ui/scenic/lib/display/color_converter.h" |
| #include "src/ui/scenic/lib/display/display_manager.h" |
| #include "src/ui/scenic/lib/display/display_power_manager.h" |
| #include "src/ui/scenic/lib/flatland/engine/engine.h" |
| #include "src/ui/scenic/lib/flatland/engine/engine_types.h" |
| #include "src/ui/scenic/lib/flatland/renderer/cpu_renderer.h" |
| #include "src/ui/scenic/lib/flatland/renderer/null_renderer.h" |
| #include "src/ui/scenic/lib/flatland/renderer/vk_renderer.h" |
| #include "src/ui/scenic/lib/scheduling/frame_metrics_registry.cb.h" |
| #include "src/ui/scenic/lib/scheduling/windowed_frame_predictor.h" |
| #include "src/ui/scenic/lib/screen_capture/screen_capture.h" |
| #include "src/ui/scenic/lib/screen_capture/screen_capture_buffer_collection_importer.h" |
| #include "src/ui/scenic/lib/screenshot/screenshot_manager.h" |
| #include "src/ui/scenic/lib/utils/escher_provider.h" |
| #include "src/ui/scenic/lib/utils/helpers.h" |
| #include "src/ui/scenic/lib/utils/metrics_impl.h" |
| #include "src/ui/scenic/lib/utils/range_inclusive.h" |
| #include "src/ui/scenic/lib/view_tree/snapshot_dump.h" |
| #include "src/ui/scenic/scenic_structured_config.h" |
| |
| namespace { |
| |
| using scenic_impl::RendererType; |
| |
| // App installs the loader manifest FS at this path so it can use |
| // fsl::DeviceWatcher on it. |
| static const char* kDependencyPath = "/gpu-manifest-fs"; |
| |
| static constexpr zx::duration kShutdownTimeout = zx::sec(1); |
| |
| // NOTE: If this value changes, you should also change the corresponding kCleanupDelay inside |
| // escher/profiling/timestamp_profiler.cc. |
| static constexpr zx::duration kEscherCleanupRetryInterval{1'000'000}; // 1 millisecond |
| |
| std::optional<fuchsia::hardware::display::types::DisplayId> GetDisplayId( |
| const scenic_structured_config::Config& values) { |
| if (values.i_can_haz_display_id() < 0) { |
| return std::nullopt; |
| } |
| return std::make_optional<fuchsia::hardware::display::types::DisplayId>( |
| {.value = static_cast<uint64_t>(values.i_can_haz_display_id())}); |
| } |
| |
| std::optional<uint64_t> GetDisplayMode(const scenic_structured_config::Config& values) { |
| if (values.i_can_haz_display_mode() < 0) { |
| return std::nullopt; |
| } |
| return values.i_can_haz_display_mode(); |
| } |
| |
| utils::RangeInclusive<int> CreateRangeFromStructuredConfigValues(int left, int right) { |
| if (left >= 0 && right >= 0) { |
| ZX_DEBUG_ASSERT(left <= right); |
| return utils::RangeInclusive<int>(left, right); |
| } |
| if (left >= 0) { |
| return utils::RangeInclusive<int>(left, utils::PositiveInfinity{}); |
| } |
| if (right >= 0) { |
| return utils::RangeInclusive<int>(utils::NegativeInfinity{}, right); |
| } |
| return utils::RangeInclusive<int>(); |
| } |
| |
| scenic_impl::display::DisplayModeConstraints GetDisplayModeConstraints( |
| const scenic_structured_config::Config& values) { |
| return { |
| .width_px_range = |
| CreateRangeFromStructuredConfigValues(values.min_display_horizontal_resolution_px(), |
| values.max_display_horizontal_resolution_px()), |
| .height_px_range = CreateRangeFromStructuredConfigValues( |
| values.min_display_vertical_resolution_px(), values.max_display_vertical_resolution_px()), |
| .refresh_rate_millihertz_range = |
| CreateRangeFromStructuredConfigValues(values.min_display_refresh_rate_millihertz(), |
| values.max_display_refresh_rate_millihertz()), |
| }; |
| } |
| |
| std::string ToString(RendererType type) { |
| switch (type) { |
| case RendererType::CPU_RENDERER: |
| return "cpu"; |
| case RendererType::NULL_RENDERER: |
| return "null"; |
| case RendererType::VULKAN: |
| return "vulkan"; |
| } |
| } |
| |
| RendererType GetRendererType(const scenic_structured_config::Config& values) { |
| if (ToString(RendererType::CPU_RENDERER).compare(values.renderer()) == 0) |
| return RendererType::CPU_RENDERER; |
| if (ToString(RendererType::NULL_RENDERER).compare(values.renderer()) == 0) |
| return RendererType::NULL_RENDERER; |
| if (ToString(RendererType::VULKAN).compare(values.renderer()) == 0) |
| return RendererType::VULKAN; |
| FX_LOGS(WARNING) << "Unknown renderer type: " << values.renderer() << ". Falling back to vulkan"; |
| return RendererType::VULKAN; |
| } |
| |
| uint64_t GetDisplayRotation(scenic_structured_config::Config values) { |
| uint64_t rotation = values.display_rotation(); |
| if (rotation >= 0) { |
| FX_CHECK(rotation < 360) << "Rotation should be less than 360 degrees."; |
| return rotation; |
| } |
| FX_LOGS(WARNING) << "Invalid value for display_rotation. Falling back to the default value 0."; |
| return 0; |
| } |
| |
| // Gets Scenic's structured config values and logs them. |
| scenic_structured_config::Config GetConfig() { |
| // Retrieve structured configuration |
| auto values = scenic_structured_config::Config::TakeFromStartupHandle(); |
| |
| FX_LOGS(INFO) << "Scenic renderer: " << ToString(GetRendererType(values)); |
| FX_LOGS(INFO) << "Scenic min_predicted_frame_duration(us): " |
| << values.frame_scheduler_min_predicted_frame_duration_in_us(); |
| FX_LOGS(INFO) << "Scenic pointer auto focus: " << values.pointer_auto_focus(); |
| FX_LOGS(INFO) << "display_composition: " << values.display_composition(); |
| FX_LOGS(INFO) << "Scenic i_can_haz_display_id: " |
| << GetDisplayId(values) |
| .value_or(fuchsia::hardware::display::types::DisplayId{ |
| .value = fuchsia::hardware::display::types::INVALID_DISP_ID}) |
| .value; |
| FX_LOGS(INFO) << "Scenic i_can_haz_display_mode: " << GetDisplayMode(values).value_or(0); |
| FX_LOGS(INFO) << "Scenic display_rotation: " << GetDisplayRotation(values); |
| |
| return values; |
| } |
| |
| #ifdef NDEBUG |
| // TODO(https://fxbug.dev/42125470): Scenic sometimes gets stuck for consecutive 60 seconds. |
| // Here we set up a Watchdog polling Scenic status every 15 seconds. |
| constexpr uint32_t kWatchdogWarningIntervalMs = 15000u; |
| // On some devices, the time to start up Scenic may exceed 15 seconds. |
| // In that case we should only send a warning, and we should only crash |
| // Scenic if the main thread is blocked for longer time. |
| constexpr uint32_t kWatchdogTimeoutMs = 45000u; |
| #else // !defined(NDEBUG) |
| // We set a higher warning interval and timeout length for debug builds, |
| // since these builds could be slower than the default release ones. |
| constexpr uint32_t kWatchdogWarningIntervalMs = 30000u; |
| constexpr uint32_t kWatchdogTimeoutMs = 90000u; |
| #endif // NDEBUG |
| |
| // Interval at which we log that Scenic is waiting for Vulkan or display. |
| static constexpr zx::duration kWaitWarningInterval = zx::sec(5); |
| |
| void PostDelayedTaskUntilCancelled(fit::closure cb, zx::duration delay, bool first_run = true) { |
| if (!cb) |
| return; |
| if (!first_run) |
| cb(); |
| async::PostDelayedTask( |
| async_get_default_dispatcher(), |
| [cb = std::move(cb), delay]() mutable { |
| PostDelayedTaskUntilCancelled(std::move(cb), delay, false); |
| }, |
| delay); |
| } |
| |
| } // namespace |
| |
| namespace scenic_impl { |
| |
| DisplayInfoDelegate::DisplayInfoDelegate(std::shared_ptr<display::Display> display_) |
| : display_(display_) { |
| FX_CHECK(display_); |
| } |
| |
| void DisplayInfoDelegate::GetDisplayInfo( |
| fuchsia::ui::scenic::Scenic::GetDisplayInfoCallback callback) { |
| auto info = ::fuchsia::ui::gfx::DisplayInfo(); |
| info.width_in_px = display_->width_in_px(); |
| info.height_in_px = display_->height_in_px(); |
| |
| callback(std::move(info)); |
| } |
| |
| fuchsia::math::SizeU DisplayInfoDelegate::GetDisplayDimensions() { |
| return {display_->width_in_px(), display_->height_in_px()}; |
| } |
| |
| void DisplayInfoDelegate::GetDisplayOwnershipEvent( |
| fuchsia::ui::scenic::Scenic::GetDisplayOwnershipEventCallback callback) { |
| // These constants are defined as raw hex in the FIDL file, so we confirm here that they are the |
| // same values as the expected constants in the ZX headers. |
| static_assert(fuchsia::ui::scenic::displayNotOwnedSignal == ZX_USER_SIGNAL_0, "Bad constant"); |
| static_assert(fuchsia::ui::scenic::displayOwnedSignal == ZX_USER_SIGNAL_1, "Bad constant"); |
| |
| zx::event dup; |
| if (display_->ownership_event().duplicate(ZX_RIGHTS_BASIC, &dup) != ZX_OK) { |
| FX_LOGS(ERROR) << "Display ownership event duplication error."; |
| callback(zx::event()); |
| } else { |
| callback(std::move(dup)); |
| } |
| } |
| |
| App::App(std::unique_ptr<sys::ComponentContext> app_context, inspect::Node inspect_node, |
| fpromise::promise<::display::CoordinatorClientEnd, zx_status_t> dc_handles_promise, |
| fit::closure quit_callback) |
| : executor_(async_get_default_dispatcher()), |
| app_context_(std::move(app_context)), |
| config_values_(GetConfig()), |
| // TODO(https://fxbug.dev/42117030): subsystems requiring graceful shutdown *on a loop* should |
| // register themselves. It is preferable to cleanly shutdown using destructors only, if |
| // possible. |
| shutdown_manager_( |
| ShutdownManager::New(async_get_default_dispatcher(), std::move(quit_callback))), |
| metrics_logger_( |
| async_get_default_dispatcher(), |
| fidl::ClientEnd<fuchsia_io::Directory>(component::OpenServiceRoot()->TakeChannel())), |
| inspect_node_(std::move(inspect_node)), |
| frame_scheduler_( |
| std::make_unique<scheduling::WindowedFramePredictor>( |
| zx::usec(config_values_.frame_scheduler_min_predicted_frame_duration_in_us()), |
| scheduling::DefaultFrameScheduler::kInitialRenderDuration, |
| scheduling::DefaultFrameScheduler::kInitialUpdateDuration), |
| inspect_node_.CreateChild("FrameScheduler"), &metrics_logger_), |
| renderer_type_(GetRendererType(config_values_)), |
| scenic_(app_context_.get()), |
| uber_struct_system_(std::make_shared<flatland::UberStructSystem>()), |
| link_system_( |
| std::make_shared<flatland::LinkSystem>(uber_struct_system_->GetNextInstanceId())), |
| flatland_presenter_(std::make_shared<flatland::FlatlandPresenterImpl>( |
| async_get_default_dispatcher(), frame_scheduler_)), |
| color_converter_( |
| app_context_.get(), |
| /*set_color_conversion_values*/ |
| display::SetColorConversionFunc([this](const auto& coefficients, const auto& preoffsets, |
| const auto& postoffsets) { |
| FX_DCHECK(flatland_compositor_); |
| flatland_compositor_->SetColorConversionValues(coefficients, preoffsets, postoffsets); |
| }), |
| /*set_minimum_rgb*/ |
| display::SetMinimumRgbFunc([this](const uint8_t minimum_rgb) { |
| FX_DCHECK(flatland_compositor_); |
| return flatland_compositor_->SetMinimumRgb(minimum_rgb); |
| })), |
| geometry_provider_(), |
| observer_registry_(geometry_provider_), |
| scoped_observer_registry_(geometry_provider_), |
| watchdog_("Scenic main thread", kWatchdogWarningIntervalMs, kWatchdogTimeoutMs, |
| async_get_default_dispatcher()) { |
| fpromise::bridge<escher::EscherUniquePtr> escher_bridge; |
| fpromise::bridge<std::shared_ptr<display::Display>> display_bridge; |
| |
| auto vulkan_loader = app_context_->svc()->Connect<fuchsia::vulkan::loader::Loader>(); |
| fidl::InterfaceHandle<fuchsia::io::Directory> dir; |
| vulkan_loader->ConnectToManifestFs(fuchsia::vulkan::loader::ConnectToManifestOptions{}, |
| dir.NewRequest().TakeChannel()); |
| |
| fdio_ns_t* ns; |
| FX_CHECK(fdio_ns_get_installed(&ns) == ZX_OK); |
| FX_CHECK(fdio_ns_bind(ns, kDependencyPath, dir.TakeChannel().release()) == ZX_OK); |
| |
| // Publish all protocols that are ready. |
| view_ref_installed_impl_.Publish(app_context_.get()); |
| observer_registry_.Publish(app_context_.get()); |
| scoped_observer_registry_.Publish(app_context_.get()); |
| focus_manager_.Publish(*app_context_); |
| |
| auto vulkan_wait_log = std::make_unique<fxl::CancelableClosure>( |
| [] { FX_LOGS(WARNING) << "SCENIC IS WAITING FOR VULKAN TO BE AVAILABLE..."; }); |
| PostDelayedTaskUntilCancelled(vulkan_wait_log->callback(), kWaitWarningInterval); |
| |
| if (renderer_type_ == RendererType::VULKAN) { |
| // Wait for a Vulkan ICD to become advertised before trying to launch escher. |
| FX_DCHECK(!device_watcher_); |
| device_watcher_ = fsl::DeviceWatcher::Create( |
| kDependencyPath, [this, vulkan_loader = std::move(vulkan_loader), |
| completer = std::move(escher_bridge.completer), |
| vulkan_wait_log = std::move(vulkan_wait_log)]( |
| const fidl::ClientEnd<fuchsia_io::Directory>& dir, |
| const std::string& filename) mutable { |
| auto escher = utils::CreateEscher(app_context_.get()); |
| if (!escher) { |
| FX_LOGS(WARNING) << "Escher creation failed."; |
| // This should almost never happen, but might if the device was removed quickly after it |
| // was added or if the Vulkan driver doesn't actually work on this hardware. Retry when |
| // a new device is added. |
| return; |
| } |
| completer.complete_ok(std::move(escher)); |
| device_watcher_.reset(); |
| }); |
| FX_DCHECK(device_watcher_); |
| } else { |
| // Immediately complete promise if we aren't using vulkan renderer. |
| escher_bridge.completer.complete_ok(nullptr); |
| } |
| |
| auto display_wait_log = std::make_unique<fxl::CancelableClosure>( |
| [] { FX_LOGS(WARNING) << "SCENIC IS WAITING FOR DISPLAY TO BE AVAILABLE..."; }); |
| PostDelayedTaskUntilCancelled(display_wait_log->callback(), kWaitWarningInterval); |
| |
| // Instantiate DisplayManager and schedule a task to inject the display coordinator into it, once |
| // it becomes available. |
| display_manager_.emplace(GetDisplayId(config_values_), GetDisplayMode(config_values_), |
| GetDisplayModeConstraints(config_values_), |
| [this, completer = std::move(display_bridge.completer), |
| display_wait_log = std::move(display_wait_log)]() mutable { |
| completer.complete_ok(display_manager_->default_display_shared()); |
| }); |
| executor_.schedule_task(dc_handles_promise.then( |
| [this](fpromise::result<::display::CoordinatorClientEnd, zx_status_t>& handles) { |
| FX_CHECK(handles.is_ok()) << "Failed to get display coordinator:" |
| << zx_status_get_string(handles.error()); |
| display_manager_->BindDefaultDisplayCoordinator(std::move(handles.value())); |
| })); |
| |
| // Schedule a task to finish initialization once all promises have been completed. |
| // This closure is placed on |executor_|, which is owned by App, so it is safe to use |this|. |
| { |
| auto p = |
| fpromise::join_promises(escher_bridge.consumer.promise(), display_bridge.consumer.promise()) |
| .and_then( |
| [this](std::tuple<fpromise::result<escher::EscherUniquePtr>, |
| fpromise::result<std::shared_ptr<display::Display>>>& results) { |
| InitializeServices(std::move(std::get<0>(results).value()), |
| std::move(std::get<1>(results).value())); |
| // Should be run after all outgoing services are published. |
| app_context_->outgoing()->ServeFromStartupInfo(); |
| }); |
| |
| executor_.schedule_task(std::move(p)); |
| } |
| } |
| |
| void App::InitializeServices(escher::EscherUniquePtr escher, |
| std::shared_ptr<display::Display> display) { |
| TRACE_DURATION("gfx", "App::InitializeServices"); |
| |
| if (!display) { |
| FX_LOGS(ERROR) << "No default display, Graphics system exiting"; |
| shutdown_manager_->Shutdown(kShutdownTimeout); |
| return; |
| } |
| |
| if (renderer_type_ == RendererType::VULKAN) { |
| if (!escher || !escher->device()) { |
| FX_LOGS(ERROR) << "No Vulkan on device, Graphics system exiting."; |
| shutdown_manager_->Shutdown(kShutdownTimeout); |
| return; |
| } |
| |
| escher_ = std::move(escher); |
| escher_cleanup_ = std::make_shared<utils::CleanupUntilDone>(kEscherCleanupRetryInterval, |
| [escher = escher_->GetWeakPtr()]() { |
| if (!escher) { |
| // Escher is destroyed, so there |
| // is no cleanup to be done. |
| return true; |
| } |
| return escher->Cleanup(); |
| }); |
| } |
| |
| InitializeGraphics(display); |
| InitializeInput(); |
| InitializeHeartbeat(*display); |
| } |
| |
| App::~App() { |
| fdio_ns_t* ns; |
| FX_CHECK(fdio_ns_get_installed(&ns) == ZX_OK); |
| FX_CHECK(fdio_ns_unbind(ns, kDependencyPath) == ZX_OK); |
| } |
| |
| void App::InitializeGraphics(std::shared_ptr<display::Display> display) { |
| TRACE_DURATION("gfx", "App::InitializeGraphics"); |
| FX_LOGS(INFO) << "App::InitializeGraphics() " << display->width_in_px() << "x" |
| << display->height_in_px() << "px " << display->width_in_mm() << "x" |
| << display->height_in_mm() << "mm"; |
| |
| // Replace Escher's default pipeline builder with one which will log to Cobalt upon each |
| // unexpected lazy pipeline creation. This allows us to detect when this slips through our |
| // testing and occurs in the wild. In order to detect problems ASAP during development, debug |
| // builds CHECK instead of logging to Cobalt. |
| if (renderer_type_ == RendererType::VULKAN) { |
| auto pipeline_builder = std::make_unique<escher::PipelineBuilder>(escher_->vk_device()); |
| pipeline_builder->set_log_pipeline_creation_callback( |
| [metrics_logger = &metrics_logger_](const vk::GraphicsPipelineCreateInfo* graphics_info, |
| const vk::ComputePipelineCreateInfo* compute_info) { |
| // TODO(https://fxbug.dev/42126999): pre-warm compute pipelines in addition to graphics |
| // pipelines. |
| if (compute_info) { |
| FX_LOGS(WARNING) << "Unexpected lazy creation of Vulkan compute pipeline."; |
| return; |
| } |
| |
| #if !defined(NDEBUG) |
| FX_CHECK(false) // debug builds should crash for early detection |
| #else |
| FX_LOGS(WARNING) // release builds should log to Cobalt, see below. |
| #endif |
| << "Unexpected lazy creation of Vulkan pipeline."; |
| |
| metrics_logger->LogRareEvent( |
| cobalt_registry::ScenicRareEventMigratedMetricDimensionEvent::LazyPipelineCreation); |
| }); |
| escher_->set_pipeline_builder(std::move(pipeline_builder)); |
| } |
| |
| { |
| singleton_display_service_.emplace(display); |
| singleton_display_service_->AddPublicService(scenic_.app_context()->outgoing().get()); |
| display_info_delegate_.emplace(display); |
| } |
| |
| std::shared_ptr<flatland::Renderer> flatland_renderer; |
| switch (renderer_type_) { |
| case RendererType::CPU_RENDERER: |
| flatland_renderer = std::make_shared<flatland::CpuRenderer>(); |
| break; |
| case RendererType::NULL_RENDERER: |
| flatland_renderer = std::make_shared<flatland::NullRenderer>(); |
| break; |
| case RendererType::VULKAN: |
| flatland_renderer = std::make_shared<flatland::VkRenderer>(escher_->GetWeakPtr()); |
| break; |
| } |
| // TODO(https://fxbug.dev/42158284): flatland::VkRenderer hardcodes the framebuffer pixel format. |
| // Eventually we won't, instead choosing one from the list of acceptable formats advertised by |
| // each plugged-in display. This will raise the issue of where to do pipeline cache warming: it |
| // will be too early to do it here, since we're not yet aware of any displays nor the formats they |
| // support. It will probably be OK to warm the cache when a new display is plugged in, because |
| // users don't expect plugging in a display to be completely jank-free. |
| |
| flatland_renderer->WarmPipelineCache(); |
| |
| // TODO(https://fxbug.dev/42073146) Support camera image in shader pre-warmup. |
| // Disabling this line allows any shaders that weren't warmed up to be lazily created later. |
| // flatland_renderer->set_disable_lazy_pipeline_creation(true); |
| |
| // Flatland compositor must be made first; it is needed by the manager and the engine. |
| { |
| TRACE_DURATION("gfx", "App::InitializeServices[flatland_display_compositor]"); |
| |
| flatland_compositor_ = std::make_shared<flatland::DisplayCompositor>( |
| async_get_default_dispatcher(), display_manager_->default_display_coordinator(), |
| flatland_renderer, utils::CreateSysmemAllocatorSyncPtr("flatland::DisplayCompositor"), |
| config_values_.display_composition(), /*max_display_layers=*/1); |
| } |
| |
| // Flatland manager depends on compositor, and is required by engine. |
| { |
| TRACE_DURATION("gfx", "App::InitializeServices[flatland_manager]"); |
| |
| std::vector<std::shared_ptr<allocation::BufferCollectionImporter>> importers{ |
| flatland_compositor_}; |
| |
| flatland_manager_ = std::make_shared<flatland::FlatlandManager>( |
| async_get_default_dispatcher(), flatland_presenter_, uber_struct_system_, link_system_, |
| display, std::move(importers), |
| /*register_view_focuser*/ |
| [this](fidl::InterfaceRequest<fuchsia::ui::views::Focuser> focuser, |
| zx_koid_t view_ref_koid) { |
| focus_manager_.RegisterViewFocuser(view_ref_koid, std::move(focuser)); |
| }, |
| /*register_view_ref_focused*/ |
| [this](fidl::InterfaceRequest<fuchsia::ui::views::ViewRefFocused> vrf, |
| zx_koid_t view_ref_koid) { |
| focus_manager_.RegisterViewRefFocused(view_ref_koid, std::move(vrf)); |
| }, |
| /*register_touch_source*/ |
| [this](fidl::InterfaceRequest<fuchsia::ui::pointer::TouchSource> touch_source, |
| zx_koid_t view_ref_koid) { |
| input_->RegisterTouchSource(std::move(touch_source), view_ref_koid); |
| }, |
| /*register_mouse_source*/ |
| [this](fidl::InterfaceRequest<fuchsia::ui::pointer::MouseSource> mouse_source, |
| zx_koid_t view_ref_koid) { |
| input_->RegisterMouseSource(std::move(mouse_source), view_ref_koid); |
| }); |
| |
| // TODO(https://fxbug.dev/42146099): these should be moved into FlatlandManager. |
| { |
| // Note: can't use `fit::bind_member()` here, because `CreateFlatland()` returns non-void. |
| fit::function<void(fidl::InterfaceRequest<fuchsia::ui::composition::Flatland>)> handler = |
| [flatland_manager = flatland_manager_.get()]( |
| fidl::InterfaceRequest<fuchsia::ui::composition::Flatland> request) { |
| flatland_manager->CreateFlatland(std::move(request)); |
| }; |
| FX_CHECK(app_context_->outgoing()->AddPublicService(std::move(handler)) == ZX_OK); |
| } |
| { |
| fit::function<void(fidl::InterfaceRequest<fuchsia::ui::composition::FlatlandDisplay>)> |
| handler = fit::bind_member(flatland_manager_.get(), |
| &flatland::FlatlandManager::CreateFlatlandDisplay); |
| FX_CHECK(app_context_->outgoing()->AddPublicService(std::move(handler)) == ZX_OK); |
| } |
| } |
| |
| const auto screen_capture_buffer_collection_importer = |
| std::make_shared<screen_capture::ScreenCaptureBufferCollectionImporter>( |
| utils::CreateSysmemAllocatorSyncPtr("ScreenCaptureBufferCollectionImporter"), |
| flatland_renderer); |
| |
| // Allocator service needs Flatland DisplayCompositor to act as a BufferCollectionImporter. |
| { |
| std::vector<std::shared_ptr<allocation::BufferCollectionImporter>> screen_capture_importers; |
| screen_capture_importers.push_back(screen_capture_buffer_collection_importer); |
| |
| std::vector<std::shared_ptr<allocation::BufferCollectionImporter>> default_importers; |
| default_importers.push_back(flatland_compositor_); |
| |
| allocator_ = std::make_shared<allocation::Allocator>( |
| app_context_.get(), default_importers, screen_capture_importers, |
| utils::CreateSysmemAllocatorSyncPtr("ScenicAllocator")); |
| } |
| |
| // Flatland engine requires FlatlandManager and DisplayCompositor to be constructed first. |
| { |
| TRACE_DURATION("gfx", "App::InitializeServices[flatland_engine]"); |
| |
| flatland_engine_ = std::make_shared<flatland::Engine>( |
| flatland_compositor_, flatland_presenter_, uber_struct_system_, link_system_, |
| inspect_node_.CreateChild("FlatlandEngine"), [this] { |
| FX_DCHECK(flatland_manager_); |
| const auto display = flatland_manager_->GetPrimaryFlatlandDisplayForRendering(); |
| return display ? std::optional<flatland::TransformHandle>(display->root_transform()) |
| : std::nullopt; |
| }); |
| } |
| |
| // Make ScreenCaptureManager. |
| { |
| TRACE_DURATION("gfx", "App::InitializeServices[screen_capture_manager]"); |
| |
| std::vector<std::shared_ptr<allocation::BufferCollectionImporter>> screen_capture_importers; |
| screen_capture_importers.push_back(screen_capture_buffer_collection_importer); |
| |
| // Capture flatland_manager since the primary display may not have been initialized yet. |
| screen_capture_manager_.emplace(flatland_engine_, flatland_renderer, flatland_manager_, |
| std::move(screen_capture_importers)); |
| |
| fit::function<void(fidl::InterfaceRequest<fuchsia::ui::composition::ScreenCapture>)> handler = |
| fit::bind_member(&screen_capture_manager_.value(), |
| &screen_capture::ScreenCaptureManager::CreateClient); |
| FX_CHECK(app_context_->outgoing()->AddPublicService(std::move(handler)) == ZX_OK); |
| } |
| |
| // Make ScreenCapture2Manager. |
| { |
| TRACE_DURATION("gfx", "App::InitializeServices[screen_capture2_manager]"); |
| |
| // Capture flatland_manager since the primary display may not have been initialized yet. |
| screen_capture2_manager_.emplace( |
| flatland_renderer, screen_capture_buffer_collection_importer, [this]() { |
| FX_DCHECK(flatland_manager_); |
| FX_DCHECK(flatland_engine_); |
| |
| auto display = flatland_manager_->GetPrimaryFlatlandDisplayForRendering(); |
| if (!display) { |
| FX_LOGS(WARNING) |
| << "No FlatlandDisplay attached at root. Returning an empty screenshot."; |
| return flatland::Renderables(); |
| } |
| |
| return flatland_engine_->GetRenderables(*display); |
| }); |
| |
| fit::function<void(fidl::InterfaceRequest<fuchsia::ui::composition::internal::ScreenCapture>)> |
| handler = fit::bind_member(&screen_capture2_manager_.value(), |
| &screen_capture2::ScreenCapture2Manager::CreateClient); |
| FX_CHECK(app_context_->outgoing()->AddPublicService(std::move(handler)) == ZX_OK); |
| } |
| |
| // Make ScreenshotManager for the client-friendly screenshot protocol. |
| { |
| TRACE_DURATION("gfx", "App::InitializeServices[screenshot_manager]"); |
| |
| std::vector<std::shared_ptr<allocation::BufferCollectionImporter>> screen_capture_importers; |
| screen_capture_importers.push_back(screen_capture_buffer_collection_importer); |
| |
| // Capture flatland_manager since the primary display may not have been initialized yet. |
| screenshot_manager_.emplace( |
| allocator_, flatland_renderer, |
| [this]() { |
| FX_DCHECK(flatland_manager_); |
| FX_DCHECK(flatland_engine_); |
| |
| auto display = flatland_manager_->GetPrimaryFlatlandDisplayForRendering(); |
| if (!display) { |
| FX_LOGS(WARNING) |
| << "No FlatlandDisplay attached at root. Returning an empty screenshot."; |
| return flatland::Renderables(); |
| } |
| |
| return flatland_engine_->GetRenderables(*display); |
| }, |
| std::move(screen_capture_importers), display_info_delegate_->GetDisplayDimensions(), |
| GetDisplayRotation(config_values_)); |
| |
| fit::function<void(fidl::InterfaceRequest<fuchsia::ui::composition::Screenshot>)> handler = |
| fit::bind_member(&screenshot_manager_.value(), |
| &screenshot::ScreenshotManager::CreateBinding); |
| FX_CHECK(app_context_->outgoing()->AddPublicService(std::move(handler)) == ZX_OK); |
| } |
| |
| { |
| TRACE_DURATION("gfx", "App::InitializeServices[display_power]"); |
| display_power_manager_.emplace(display_manager_.value()); |
| FX_CHECK(app_context_->outgoing()->AddPublicService(display_power_manager_->GetHandler()) == |
| ZX_OK); |
| } |
| } |
| |
| void App::InitializeInput() { |
| TRACE_DURATION("gfx", "App::InitializeInput"); |
| input_.emplace(app_context_.get(), inspect_node_, |
| /*request_focus*/ |
| [this, use_auto_focus = config_values_.pointer_auto_focus()](zx_koid_t koid) { |
| if (!use_auto_focus) |
| return; |
| |
| const auto& focus_chain = focus_manager_.focus_chain(); |
| if (!focus_chain.empty()) { |
| const zx_koid_t requestor = focus_chain[0]; |
| const zx_koid_t request = koid != ZX_KOID_INVALID ? koid : requestor; |
| focus_manager_.RequestFocus(requestor, request); |
| } |
| }); |
| } |
| |
| void App::InitializeHeartbeat(display::Display& display) { |
| TRACE_DURATION("gfx", "App::InitializeHeartbeat"); |
| { // Initialize ViewTreeSnapshotter |
| |
| // These callbacks are be called once per frame (at the end of OnCpuWorkDone()) and the results |
| // used to build the ViewTreeSnapshot. |
| // We create one per compositor. |
| std::vector<view_tree::SubtreeSnapshotGenerator> subtrees_generator_callbacks; |
| subtrees_generator_callbacks.emplace_back([this] { |
| if (auto display = flatland_manager_->GetPrimaryFlatlandDisplayForRendering()) { |
| return flatland_engine_->GenerateViewTreeSnapshot(display->root_transform()); |
| } else { |
| return view_tree::SubtreeSnapshot{}; // Empty snapshot. |
| } |
| }); |
| |
| // All subscriber callbacks get called with the new snapshot every time one is generated (once |
| // per frame). |
| std::vector<view_tree::ViewTreeSnapshotter::Subscriber> subscribers; |
| subscribers.push_back( |
| {.on_new_view_tree = |
| [this](auto snapshot) { input_->OnNewViewTreeSnapshot(std::move(snapshot)); }, |
| .dispatcher = async_get_default_dispatcher()}); |
| |
| subscribers.push_back( |
| {.on_new_view_tree = |
| [this](auto snapshot) { focus_manager_.OnNewViewTreeSnapshot(std::move(snapshot)); }, |
| .dispatcher = async_get_default_dispatcher()}); |
| |
| subscribers.push_back({.on_new_view_tree = |
| [this](auto snapshot) { |
| view_ref_installed_impl_.OnNewViewTreeSnapshot( |
| std::move(snapshot)); |
| }, |
| .dispatcher = async_get_default_dispatcher()}); |
| |
| subscribers.push_back({.on_new_view_tree = |
| [this](auto snapshot) { |
| geometry_provider_.OnNewViewTreeSnapshot(std::move(snapshot)); |
| }, |
| .dispatcher = async_get_default_dispatcher()}); |
| |
| if (enable_snapshot_dump_) { |
| subscribers.push_back({.on_new_view_tree = |
| [](auto snapshot) { |
| view_tree::SnapshotDump::OnNewViewTreeSnapshot( |
| std::move(snapshot)); |
| }, |
| .dispatcher = async_get_default_dispatcher()}); |
| } |
| |
| view_tree_snapshotter_.emplace(std::move(subtrees_generator_callbacks), std::move(subscribers)); |
| } |
| |
| // Set up what to do each time a FrameScheduler event fires. |
| frame_scheduler_.Initialize( |
| display.vsync_timing(), |
| /*update_sessions*/ |
| [this](auto& sessions_to_update, auto trace_id, auto fences_from_previous_presents) { |
| TRACE_DURATION("gfx", "App update_sessions"); |
| |
| // Flatland doesn't pass release fences into the FrameScheduler. Instead, they are stored |
| // in the FlatlandPresenter and pulled out by the flatland::Engine during rendering. |
| FX_CHECK(fences_from_previous_presents.empty()) |
| << "Flatland fences should not be handled by FrameScheduler."; |
| |
| flatland_manager_->UpdateInstances(sessions_to_update); |
| flatland_presenter_->AccumulateReleaseFences(sessions_to_update); |
| }, |
| /*on_cpu_work_done*/ |
| [this] { |
| TRACE_DURATION("gfx", "App on_cpu_work_done"); |
| flatland_manager_->SendHintsToStartRendering(); |
| screen_capture2_manager_->RenderPendingScreenCaptures(); |
| view_tree_snapshotter_->UpdateSnapshot(); |
| // Always defer the first cleanup attempt, because the first try is almost guaranteed to |
| // fail, and checking the status of a `VkFence` is fairly expensive. |
| if (escher_cleanup_) |
| escher_cleanup_->Cleanup(/*ok_to_run_immediately=*/false); |
| }, |
| /*on_frame_presented*/ |
| [this](auto latched_times, auto present_times) { |
| TRACE_DURATION("gfx", "App on_frame_presented"); |
| flatland_manager_->OnFramePresented(latched_times, present_times); |
| }, |
| /*render_scheduled_frame*/ |
| [this](auto frame_number, auto presentation_time, auto callback) { |
| TRACE_DURATION("gfx", "App render_scheduled_frame"); |
| FX_CHECK(flatland_frame_count_ + skipped_frame_count_ == frame_number - 1); |
| if (auto display = flatland_manager_->GetPrimaryFlatlandDisplayForRendering()) { |
| flatland_engine_->RenderScheduledFrame(frame_number, presentation_time, *display, |
| std::move(callback)); |
| ++flatland_frame_count_; |
| } else { |
| FX_LOGS(INFO) << "No FlatlandDisplay; skipping render scheduled frame."; |
| skipped_frame_count_++; |
| flatland_engine_->SkipRender(std::move(callback)); |
| } |
| }); |
| } |
| |
| } // namespace scenic_impl |
