| // 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. |
| |
| #ifndef GARNET_LIB_UI_GFX_ENGINE_SESSION_MANAGER_H_ |
| #define GARNET_LIB_UI_GFX_ENGINE_SESSION_MANAGER_H_ |
| |
| #include <set> |
| #include <unordered_map> |
| |
| #include "garnet/lib/ui/gfx/engine/session.h" |
| #include "garnet/lib/ui/scenic/command_dispatcher.h" |
| #include "lib/escher/renderer/batch_gpu_uploader.h" |
| |
| namespace scenic_impl { |
| class EventReporter; |
| class ErrorReporter; |
| } // namespace scenic_impl |
| |
| namespace scenic_impl { |
| namespace gfx { |
| |
| using SessionId = ::scenic_impl::SessionId; |
| using PresentationTime = uint64_t; |
| |
| class SessionHandler; |
| class Engine; |
| class UpdateScheduler; |
| |
| // Graphical context for a set of session updates. |
| // The CommandContext is only valid during RenderFrame() and should not be |
| // accessed outside of that. |
| class CommandContext { |
| public: |
| CommandContext(std::unique_ptr<escher::BatchGpuUploader> uploader); |
| |
| escher::BatchGpuUploader* batch_gpu_uploader() const { |
| return batch_gpu_uploader_.get(); |
| } |
| |
| // Flush any work accumulated during command processing. |
| void Flush(); |
| |
| private: |
| std::unique_ptr<escher::BatchGpuUploader> batch_gpu_uploader_; |
| }; |
| |
| // Manages a collection of SessionHandlers. |
| // Tracks future updates requested by Sessions, and executes updates for a |
| // particular presentation time. |
| class SessionManager { |
| public: |
| SessionManager() = default; |
| |
| virtual ~SessionManager() = default; |
| |
| // Finds the session handler corresponding to the given id. |
| SessionHandler* FindSessionHandler(SessionId id); |
| |
| size_t GetSessionCount() { return session_count_; } |
| |
| // Returns a SessionHandler, which is casted as a CommandDispatcher. Used by |
| // ScenicSystem. |
| std::unique_ptr<CommandDispatcher> CreateCommandDispatcher( |
| CommandDispatcherContext context, Engine* engine); |
| |
| // Tell the UpdateScheduler to schedule a frame, and remember the Session so |
| // that we can tell it to apply updates in ApplyScheduledSessionUpdates(). |
| void ScheduleUpdateForSession( |
| UpdateScheduler* update_scheduler, uint64_t presentation_time, |
| fxl::WeakPtr<scenic_impl::gfx::Session> session); |
| |
| // Executes updates that are schedule up to and including a given presentation |
| // time. Returns true if rendering is needed. |
| bool ApplyScheduledSessionUpdates(CommandContext* command_context, |
| uint64_t presentation_time, |
| uint64_t presentation_interval); |
| |
| protected: |
| // Protected for testing subclass |
| void InsertSessionHandler(SessionId session_id, |
| SessionHandler* session_handler); |
| |
| private: |
| friend class SessionHandler; |
| |
| // Used to compare presentation times so that the priority_queue acts as a min |
| // heap, placing the earliest PresentationTime at the top |
| class UpdatableSessionsComparator { |
| public: |
| bool operator()( |
| std::pair<PresentationTime, fxl::WeakPtr<Session>> updatable_session1, |
| std::pair<PresentationTime, fxl::WeakPtr<Session>> updatable_session2) { |
| return updatable_session1.first > updatable_session2.first; |
| } |
| }; |
| |
| // Removes the SessionHandler from the session_handlers_ map. We assume that |
| // the SessionHandler has already taken care of itself and its Session. |
| void RemoveSessionHandler(SessionId id); |
| |
| virtual std::unique_ptr<SessionHandler> CreateSessionHandler( |
| CommandDispatcherContext context, Engine* engine, SessionId session_id, |
| EventReporter* event_reporter, ErrorReporter* error_reporter) const; |
| |
| // Map of all the sessions. |
| std::unordered_map<SessionId, SessionHandler*> session_handlers_; |
| size_t session_count_ = 0; |
| SessionId next_session_id_ = 1; |
| |
| // Lists all Session that have updates to apply, sorted by the earliest |
| // requested presentation time of each update. |
| std::priority_queue< |
| std::pair<PresentationTime, fxl::WeakPtr<Session>>, |
| std::vector<std::pair<PresentationTime, fxl::WeakPtr<Session>>>, |
| UpdatableSessionsComparator> |
| updatable_sessions_; |
| }; |
| |
| } // namespace gfx |
| } // namespace scenic_impl |
| |
| #endif // GARNET_LIB_UI_GFX_ENGINE_SESSION_MANAGER_H_ |