1 /* 2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef RS_MAIN_THREAD 17 #define RS_MAIN_THREAD 18 19 #include <event_handler.h> 20 #include <future> 21 #include <memory> 22 #include <mutex> 23 #include <queue> 24 #include <set> 25 #include <thread> 26 27 #include "refbase.h" 28 #include "rs_base_render_engine.h" 29 #include "rs_draw_frame.h" 30 #include "vsync_distributor.h" 31 #include "vsync_receiver.h" 32 33 #include "command/rs_command.h" 34 #include "common/rs_common_def.h" 35 #include "common/rs_thread_handler.h" 36 #include "common/rs_thread_looper.h" 37 #include "drawable/rs_render_node_drawable_adapter.h" 38 #include "ipc_callbacks/iapplication_agent.h" 39 #include "ipc_callbacks/rs_iocclusion_change_callback.h" 40 #include "ipc_callbacks/rs_isurface_occlusion_change_callback.h" 41 #include "ipc_callbacks/rs_iuiextension_callback.h" 42 #include "memory/rs_app_state_listener.h" 43 #include "memory/rs_memory_graphic.h" 44 #include "params/rs_render_thread_params.h" 45 #include "pipeline/rs_context.h" 46 #include "pipeline/rs_draw_frame.h" 47 #include "pipeline/rs_uni_render_judgement.h" 48 #include "platform/common/rs_event_manager.h" 49 #include "platform/drawing/rs_vsync_client.h" 50 #include "transaction/rs_transaction_data.h" 51 #include "transaction/rs_uiextension_data.h" 52 53 #ifdef RES_SCHED_ENABLE 54 #include "vsync_system_ability_listener.h" 55 #endif 56 57 namespace OHOS::Rosen { 58 #if defined(ACCESSIBILITY_ENABLE) 59 class AccessibilityObserver; 60 #endif 61 class HgmFrameRateManager; 62 class RSUniRenderVisitor; 63 struct FrameRateRangeData; 64 namespace Detail { 65 template<typename Task> 66 class ScheduledTask : public RefBase { 67 public: Create(Task && task)68 static auto Create(Task&& task) 69 { 70 sptr<ScheduledTask<Task>> t(new ScheduledTask(std::forward<Task&&>(task))); 71 return std::make_pair(t, t->task_.get_future()); 72 } 73 Run()74 void Run() 75 { 76 task_(); 77 } 78 79 private: ScheduledTask(Task && task)80 explicit ScheduledTask(Task&& task) : task_(std::move(task)) {} 81 ~ScheduledTask() override = default; 82 83 using Return = std::invoke_result_t<Task>; 84 std::packaged_task<Return()> task_; 85 }; 86 } // namespace Detail 87 88 class RSMainThread { 89 public: 90 static RSMainThread* Instance(); 91 92 void Init(); 93 void Start(); 94 bool IsNeedProcessBySingleFrameComposer(std::unique_ptr<RSTransactionData>& rsTransactionData); 95 void UpdateFocusNodeId(NodeId focusNodeId); 96 void UpdateNeedDrawFocusChange(NodeId id); 97 void ProcessDataBySingleFrameComposer(std::unique_ptr<RSTransactionData>& rsTransactionData); 98 void RecvAndProcessRSTransactionDataImmediately(std::unique_ptr<RSTransactionData>& rsTransactionData); 99 void RecvRSTransactionData(std::unique_ptr<RSTransactionData>& rsTransactionData); 100 void RequestNextVSync(const std::string& fromWhom = "unknown", int64_t lastVSyncTS = 0); 101 void PostTask(RSTaskMessage::RSTask task); 102 void PostTask(RSTaskMessage::RSTask task, const std::string& name, int64_t delayTime, 103 AppExecFwk::EventQueue::Priority priority = AppExecFwk::EventQueue::Priority::IDLE); 104 void RemoveTask(const std::string& name); 105 void PostSyncTask(RSTaskMessage::RSTask task); 106 bool IsIdle() const; 107 void RenderServiceTreeDump(std::string& dumpString, bool forceDumpSingleFrame = true); 108 void SendClientDumpNodeTreeCommands(uint32_t taskId); 109 void CollectClientNodeTreeResult(uint32_t taskId, std::string& dumpString, size_t timeout); 110 void RsEventParamDump(std::string& dumpString); 111 bool IsUIFirstOn() const; 112 void UpdateAnimateNodeFlag(); 113 void ResetAnimateNodeFlag(); 114 void GetAppMemoryInMB(float& cpuMemSize, float& gpuMemSize); 115 void ClearMemoryCache(ClearMemoryMoment moment, bool deeply = false, pid_t pid = -1); 116 static bool CheckIsHdrSurface(const RSSurfaceRenderNode& surfaceNode); 117 118 template<typename Task, typename Return = std::invoke_result_t<Task>> ScheduleTask(Task && task)119 std::future<Return> ScheduleTask(Task&& task) 120 { 121 auto [scheduledTask, taskFuture] = Detail::ScheduledTask<Task>::Create(std::forward<Task&&>(task)); 122 PostTask([t(std::move(scheduledTask))]() { t->Run(); }); 123 return std::move(taskFuture); 124 } 125 GetRenderEngine()126 const std::shared_ptr<RSBaseRenderEngine> GetRenderEngine() const 127 { 128 RS_LOGD("You'd better to call GetRenderEngine from RSUniRenderThread directly"); 129 return isUniRender_ ? std::move(RSUniRenderThread::Instance().GetRenderEngine()) : renderEngine_; 130 } 131 GetClearMemoryFinished()132 bool GetClearMemoryFinished() const 133 { 134 return clearMemoryFinished_; 135 } 136 GetContext()137 RSContext& GetContext() 138 { 139 return *context_; 140 } 141 Id()142 std::thread::id Id() const 143 { 144 return mainThreadId_; 145 } 146 CheckIsHardwareEnabledBufferUpdated()147 bool CheckIsHardwareEnabledBufferUpdated() const 148 { 149 return isHardwareEnabledBufferUpdated_; 150 } 151 SetGlobalDarkColorMode(bool isDark)152 void SetGlobalDarkColorMode(bool isDark) 153 { 154 isGlobalDarkColorMode_ = isDark; 155 } 156 GetGlobalDarkColorMode()157 bool GetGlobalDarkColorMode() const 158 { 159 return isGlobalDarkColorMode_; 160 } 161 162 /* Judge if rootnode has to be prepared based on it corresponding process is active 163 * If its pid is in activeProcessPids_ set, return true 164 */ 165 bool CheckNodeHasToBePreparedByPid(NodeId nodeId, bool isClassifyByRoot); 166 // check if active app has static drawing cache 167 bool IsDrawingGroupChanged(const RSRenderNode& cacheRootNode) const; 168 // check if active instance only move or scale it's main window surface without rearrangement 169 // instanceNodeId should be MainWindowType, or it cannot grep correct app's info 170 void CheckAndUpdateInstanceContentStaticStatus(std::shared_ptr<RSSurfaceRenderNode> instanceNode) const; 171 172 void RegisterApplicationAgent(uint32_t pid, sptr<IApplicationAgent> app); 173 void UnRegisterApplicationAgent(sptr<IApplicationAgent> app); 174 175 void RegisterOcclusionChangeCallback(pid_t pid, sptr<RSIOcclusionChangeCallback> callback); 176 void UnRegisterOcclusionChangeCallback(pid_t pid); 177 178 void RegisterSurfaceOcclusionChangeCallback( 179 NodeId id, pid_t pid, sptr<RSISurfaceOcclusionChangeCallback> callback, std::vector<float>& partitionPoints); 180 void UnRegisterSurfaceOcclusionChangeCallback(NodeId id); 181 void ClearSurfaceOcclusionChangeCallback(pid_t pid); 182 bool SurfaceOcclusionCallBackIfOnTreeStateChanged(); 183 184 void WaitUtilUniRenderFinished(); 185 void NotifyUniRenderFinish(); 186 187 bool WaitHardwareThreadTaskExecute(); 188 void NotifyHardwareThreadCanExecuteTask(); 189 190 void ClearTransactionDataPidInfo(pid_t remotePid); 191 void AddTransactionDataPidInfo(pid_t remotePid); 192 193 void SetFocusAppInfo( 194 int32_t pid, int32_t uid, const std::string& bundleName, const std::string& abilityName, uint64_t focusNodeId); 195 const std::unordered_map<NodeId, bool>& GetCacheCmdSkippedNodes() const; 196 197 sptr<VSyncDistributor> rsVSyncDistributor_; 198 sptr<VSyncController> rsVSyncController_; 199 sptr<VSyncController> appVSyncController_; 200 sptr<VSyncGenerator> vsyncGenerator_; 201 202 void ReleaseSurface(); 203 void AddToReleaseQueue(std::shared_ptr<Drawing::Surface>&& surface); 204 205 void AddUiCaptureTask(NodeId id, std::function<void()> task); 206 void ProcessUiCaptureTasks(); 207 208 void SetDirtyFlag(bool isDirty = true); 209 bool GetDirtyFlag(); 210 void SetNoNeedToPostTask(bool noNeedToPostTask); 211 void SetAccessibilityConfigChanged(); 212 void SetScreenPowerOnChanged(bool val); 213 bool GetScreenPowerOnChanged() const; 214 bool IsAccessibilityConfigChanged() const; 215 bool IsCurtainScreenUsingStatusChanged() const; 216 void ForceRefreshForUni(); 217 void TrimMem(std::unordered_set<std::u16string>& argSets, std::string& result); 218 void DumpMem(std::unordered_set<std::u16string>& argSets, std::string& result, std::string& type, pid_t pid = 0); 219 void CountMem(int pid, MemoryGraphic& mem); 220 void CountMem(std::vector<MemoryGraphic>& mems); 221 void SetAppWindowNum(uint32_t num); 222 bool SetSystemAnimatedScenes(SystemAnimatedScenes systemAnimatedScenes); 223 SystemAnimatedScenes GetSystemAnimatedScenes(); 224 void ShowWatermark(const std::shared_ptr<Media::PixelMap> &watermarkImg, bool flag); 225 void SetIsCachedSurfaceUpdated(bool isCachedSurfaceUpdated); 226 pid_t GetDesktopPidForRotationScene() const; SetForceUpdateUniRenderFlag(bool flag)227 void SetForceUpdateUniRenderFlag(bool flag) 228 { 229 forceUpdateUniRenderFlag_ = flag; 230 } SetIdleTimerExpiredFlag(bool flag)231 void SetIdleTimerExpiredFlag(bool flag) 232 { 233 idleTimerExpiredFlag_ = flag; 234 } SetRSIdleTimerExpiredFlag(bool flag)235 void SetRSIdleTimerExpiredFlag(bool flag) 236 { 237 rsIdleTimerExpiredFlag_ = flag; 238 } 239 std::shared_ptr<Drawing::Image> GetWatermarkImg(); 240 bool GetWatermarkFlag(); 241 IsWatermarkFlagChanged()242 bool IsWatermarkFlagChanged() const 243 { 244 return lastWatermarkFlag_ != watermarkFlag_; 245 } 246 GetFrameCount()247 uint64_t GetFrameCount() const 248 { 249 return frameCount_; 250 } GetDrawStatusVec()251 std::vector<NodeId>& GetDrawStatusVec() 252 { 253 return curDrawStatusVec_; 254 } SetAppVSyncDistributor(const sptr<VSyncDistributor> & appVSyncDistributor)255 void SetAppVSyncDistributor(const sptr<VSyncDistributor>& appVSyncDistributor) 256 { 257 appVSyncDistributor_ = appVSyncDistributor; 258 } 259 260 DeviceType GetDeviceType() const; 261 bool IsSingleDisplay(); 262 bool HasMirrorDisplay() const; 263 bool GetNoNeedToPostTask(); 264 uint64_t GetFocusNodeId() const; 265 uint64_t GetFocusLeashWindowId() const; GetClearMemDeeply()266 bool GetClearMemDeeply() const 267 { 268 return clearMemDeeply_; 269 } 270 GetClearMoment()271 ClearMemoryMoment GetClearMoment() const 272 { 273 if (!context_) { 274 return ClearMemoryMoment::NO_CLEAR; 275 } 276 return context_->clearMoment_; 277 } 278 SetClearMoment(ClearMemoryMoment moment)279 void SetClearMoment(ClearMemoryMoment moment) 280 { 281 if (!context_) { 282 return; 283 } 284 context_->clearMoment_ = moment; 285 } 286 IsPCThreeFingerScenesListScene()287 bool IsPCThreeFingerScenesListScene() const 288 { 289 return !threeFingerScenesList_.empty(); 290 } 291 292 void SurfaceOcclusionChangeCallback(VisibleData& dstCurVisVec); 293 void SurfaceOcclusionCallback(); 294 void SubscribeAppState(); 295 void HandleOnTrim(Memory::SystemMemoryLevel level); 296 void SetCurtainScreenUsingStatus(bool isCurtainScreenOn); 297 void SetLuminanceChangingStatus(bool isLuminanceChanged); 298 bool ExchangeLuminanceChangingStatus(); 299 bool IsCurtainScreenOn() const; 300 void NotifySurfaceCapProcFinish(); 301 void WaitUntilSurfaceCapProcFinished(); 302 void SetSurfaceCapProcFinished(bool flag); 303 304 bool GetParallelCompositionEnabled(); GetFrameRateMgr()305 std::shared_ptr<HgmFrameRateManager> GetFrameRateMgr() { return frameRateMgr_; }; 306 void SetFrameIsRender(bool isRender); 307 const std::vector<std::shared_ptr<RSSurfaceRenderNode>>& GetSelfDrawingNodes() const; 308 const std::vector<DrawableV2::RSRenderNodeDrawableAdapter::SharedPtr>& GetSelfDrawables() const; 309 IsOnVsync()310 bool IsOnVsync() const 311 { 312 return isOnVsync_.load(); 313 } 314 GetDiscardJankFrames()315 bool GetDiscardJankFrames() const 316 { 317 return discardJankFrames_.load(); 318 } 319 SetDiscardJankFrames(bool discardJankFrames)320 void SetDiscardJankFrames(bool discardJankFrames) 321 { 322 if (discardJankFrames_.load() != discardJankFrames) { 323 discardJankFrames_.store(discardJankFrames); 324 } 325 } 326 GetSkipJankAnimatorFrame()327 bool GetSkipJankAnimatorFrame() const 328 { 329 return skipJankAnimatorFrame_.load(); 330 } 331 SetSkipJankAnimatorFrame(bool skipJankAnimatorFrame)332 void SetSkipJankAnimatorFrame(bool skipJankAnimatorFrame) 333 { 334 skipJankAnimatorFrame_.store(skipJankAnimatorFrame); 335 } 336 337 bool IsRequestedNextVSync(); 338 GetNextDVsyncAnimateFlag()339 bool GetNextDVsyncAnimateFlag() const 340 { 341 return needRequestNextVsyncAnimate_; 342 } 343 IsFirstFrameOfPartialRender()344 bool IsFirstFrameOfPartialRender() const 345 { 346 return isFirstFrameOfPartialRender_; 347 } 348 349 bool IsHardwareEnabledNodesNeedSync(); 350 bool IsOcclusionNodesNeedSync(NodeId id, bool useCurWindow); 351 352 void CallbackDrawContextStatusToWMS(bool isUniRender = false); 353 void SetHardwareTaskNum(uint32_t num); 354 void RegisterUIExtensionCallback(pid_t pid, uint64_t userId, sptr<RSIUIExtensionCallback> callback); 355 void UnRegisterUIExtensionCallback(pid_t pid); 356 357 void SetAncoForceDoDirect(bool direct); 358 IsFirstFrameOfOverdrawSwitch()359 bool IsFirstFrameOfOverdrawSwitch() const 360 { 361 return isOverDrawEnabledOfCurFrame_ != isOverDrawEnabledOfLastFrame_; 362 } 363 364 private: 365 using TransactionDataIndexMap = std::unordered_map<pid_t, 366 std::pair<uint64_t, std::vector<std::unique_ptr<RSTransactionData>>>>; 367 368 RSMainThread(); 369 ~RSMainThread() noexcept; 370 RSMainThread(const RSMainThread&) = delete; 371 RSMainThread(const RSMainThread&&) = delete; 372 RSMainThread& operator=(const RSMainThread&) = delete; 373 RSMainThread& operator=(const RSMainThread&&) = delete; 374 375 void OnVsync(uint64_t timestamp, uint64_t frameCount, void* data); 376 void ProcessCommand(); 377 void Animate(uint64_t timestamp); 378 void ConsumeAndUpdateAllNodes(); 379 void CollectInfoForHardwareComposer(); 380 void ReleaseAllNodesBuffer(); 381 void Render(); 382 void OnUniRenderDraw(); 383 void SetDeviceType(); 384 void UniRender(std::shared_ptr<RSBaseRenderNode> rootNode); 385 bool CheckSurfaceNeedProcess(OcclusionRectISet& occlusionSurfaces, std::shared_ptr<RSSurfaceRenderNode> curSurface); 386 RSVisibleLevel CalcSurfaceNodeVisibleRegion(const std::shared_ptr<RSDisplayRenderNode>& displayNode, 387 const std::shared_ptr<RSSurfaceRenderNode>& surfaceNode, Occlusion::Region& accumulatedRegion, 388 Occlusion::Region& curRegion, Occlusion::Region& totalRegion); 389 void CalcOcclusionImplementation(const std::shared_ptr<RSDisplayRenderNode>& displayNode, 390 std::vector<RSBaseRenderNode::SharedPtr>& curAllSurfaces, VisibleData& dstCurVisVec, 391 std::map<NodeId, RSVisibleLevel>& dstPidVisMap); 392 void CalcOcclusion(); 393 bool CheckSurfaceVisChanged(std::map<NodeId, RSVisibleLevel>& pidVisMap, 394 std::vector<RSBaseRenderNode::SharedPtr>& curAllSurfaces); 395 void SetVSyncRateByVisibleLevel(std::map<NodeId, RSVisibleLevel>& pidVisMap, 396 std::vector<RSBaseRenderNode::SharedPtr>& curAllSurfaces); 397 void CallbackToWMS(VisibleData& curVisVec); 398 void SendCommands(); 399 void InitRSEventDetector(); 400 void RemoveRSEventDetector(); 401 void SetRSEventDetectorLoopStartTag(); 402 void SetRSEventDetectorLoopFinishTag(); 403 void CheckSystemSceneStatus(); 404 void UpdateUIFirstSwitch(); 405 // ROG: Resolution Online Government 406 void UpdateRogSizeIfNeeded(); 407 void UpdateDisplayNodeScreenId(); 408 uint32_t GetRefreshRate() const; 409 uint32_t GetDynamicRefreshRate() const; 410 void SkipCommandByNodeId(std::vector<std::unique_ptr<RSTransactionData>>& transactionVec, pid_t pid); 411 static void OnHideNotchStatusCallback(const char *key, const char *value, void *context); 412 413 bool DoParallelComposition(std::shared_ptr<RSBaseRenderNode> rootNode); 414 415 void ClassifyRSTransactionData(std::unique_ptr<RSTransactionData>& rsTransactionData); 416 void ProcessRSTransactionData(std::unique_ptr<RSTransactionData>& rsTransactionData, pid_t pid); 417 void ProcessSyncRSTransactionData(std::unique_ptr<RSTransactionData>& rsTransactionData, pid_t pid); 418 void ProcessSyncTransactionCount(std::unique_ptr<RSTransactionData>& rsTransactionData); 419 void StartSyncTransactionFallbackTask(std::unique_ptr<RSTransactionData>& rsTransactionData); 420 void ProcessAllSyncTransactionData(); 421 void ProcessCommandForDividedRender(); 422 void ProcessCommandForUniRender(); 423 void WaitUntilUnmarshallingTaskFinished(); 424 void MergeToEffectiveTransactionDataMap(TransactionDataMap& cachedTransactionDataMap); 425 426 void ClearDisplayBuffer(); 427 void PerfAfterAnim(bool needRequestNextVsync); 428 void PerfForBlurIfNeeded(); 429 void PerfMultiWindow(); 430 void RenderFrameStart(uint64_t timestamp); 431 void ResetHardwareEnabledState(bool isUniRender); 432 void CheckIfHardwareForcedDisabled(); 433 void CheckAndUpdateTransactionIndex( 434 std::shared_ptr<TransactionDataMap>& transactionDataEffective, std::string& transactionFlags); 435 436 bool IsResidentProcess(pid_t pid) const; 437 bool IsNeedSkip(NodeId instanceRootNodeId, pid_t pid); 438 void UpdateAceDebugBoundaryEnabled(); 439 440 // UIFirst 441 bool CheckParallelSubThreadNodesStatus(); 442 void CacheCommands(); 443 bool CheckSubThreadNodeStatusIsDoing(NodeId appNodeId) const; 444 445 // used for informing hgm the bundle name of SurfaceRenderNodes 446 void InformHgmNodeInfo(); 447 void CheckIfNodeIsBundle(std::shared_ptr<RSSurfaceRenderNode> node); 448 449 void SetFocusLeashWindowId(); 450 void ProcessHgmFrameRate(uint64_t timestamp); 451 bool IsLastFrameUIFirstEnabled(NodeId appNodeId) const; 452 RSVisibleLevel GetRegionVisibleLevel(const Occlusion::Region& curRegion, 453 const Occlusion::Region& visibleRegion); 454 void PrintCurrentStatus(); 455 void ProcessScreenHotPlugEvents(); 456 void WaitUntilUploadTextureTaskFinishedForGL(); 457 #ifdef RES_SCHED_ENABLE 458 void SubScribeSystemAbility(); 459 #endif 460 #if defined(RS_ENABLE_CHIPSET_VSYNC) 461 void ConnectChipsetVsyncSer(); 462 void SetVsyncInfo(uint64_t timestamp); 463 #endif 464 465 bool DoDirectComposition(std::shared_ptr<RSBaseRenderNode> rootNode, bool waitForRT); 466 467 void RSJankStatsOnVsyncStart(int64_t onVsyncStartTime, int64_t onVsyncStartTimeSteady, 468 float onVsyncStartTimeSteadyFloat); 469 void RSJankStatsOnVsyncEnd(int64_t onVsyncStartTime, int64_t onVsyncStartTimeSteady, 470 float onVsyncStartTimeSteadyFloat); 471 int64_t GetCurrentSystimeMs() const; 472 int64_t GetCurrentSteadyTimeMs() const; 473 float GetCurrentSteadyTimeMsFloat() const; 474 void RequestNextVsyncForCachedCommand(std::string& transactionFlags, pid_t pid, uint64_t curIndex); 475 void UpdateLuminance(); 476 void DvsyncCheckRequestNextVsync(); 477 478 void PrepareUiCaptureTasks(std::shared_ptr<RSUniRenderVisitor> uniVisitor); 479 void UIExtensionNodesTraverseAndCallback(); 480 bool CheckUIExtensionCallbackDataChanged() const; 481 482 void OnCommitDumpClientNodeTree(NodeId nodeId, pid_t pid, uint32_t taskId, const std::string& result); 483 484 std::shared_ptr<AppExecFwk::EventRunner> runner_ = nullptr; 485 std::shared_ptr<AppExecFwk::EventHandler> handler_ = nullptr; 486 RSTaskMessage::RSTask mainLoop_; 487 std::unique_ptr<RSVsyncClient> vsyncClient_ = nullptr; 488 std::unordered_map<NodeId, uint64_t> dividedRenderbufferTimestamps_; 489 490 std::mutex transitionDataMutex_; 491 std::unordered_map<NodeId, std::map<uint64_t, std::vector<std::unique_ptr<RSCommand>>>> cachedCommands_; 492 std::map<uint64_t, std::vector<std::unique_ptr<RSCommand>>> effectiveCommands_; 493 std::map<uint64_t, std::vector<std::unique_ptr<RSCommand>>> pendingEffectiveCommands_; 494 std::unordered_map<pid_t, std::vector<std::unique_ptr<RSTransactionData>>> syncTransactionData_; 495 std::unordered_map<int32_t, int32_t> subSyncTransactionCounts_; 496 497 TransactionDataMap cachedTransactionDataMap_; 498 TransactionDataIndexMap effectiveTransactionDataIndexMap_; 499 std::map<pid_t, std::vector<std::unique_ptr<RSTransactionData>>> cachedSkipTransactionDataMap_; 500 std::unordered_map<pid_t, uint64_t> transactionDataLastWaitTime_; 501 502 uint64_t curTime_ = 0; 503 uint64_t timestamp_ = 0; 504 uint64_t vsyncId_ = 0; 505 uint64_t lastAnimateTimestamp_ = 0; 506 uint64_t prePerfTimestamp_ = 0; 507 uint64_t lastCleanCacheTimestamp_ = 0; 508 pid_t lastCleanCachePid_ = -1; 509 int hardwareTid_ = -1; 510 std::string transactionFlags_ = ""; 511 std::unordered_map<uint32_t, sptr<IApplicationAgent>> applicationAgentMap_; 512 513 std::shared_ptr<RSContext> context_; 514 std::thread::id mainThreadId_; 515 std::shared_ptr<VSyncReceiver> receiver_ = nullptr; 516 std::map<pid_t, sptr<RSIOcclusionChangeCallback>> occlusionListeners_; 517 std::mutex occlusionMutex_; 518 519 bool isUniRender_ = RSUniRenderJudgement::IsUniRender(); 520 RSTaskMessage::RSTask unmarshalBarrierTask_; 521 std::condition_variable unmarshalTaskCond_; 522 std::mutex unmarshalMutex_; 523 int32_t unmarshalFinishedCount_ = 0; 524 bool needWaitUnmarshalFinished_ = true; 525 sptr<VSyncDistributor> appVSyncDistributor_ = nullptr; 526 527 std::condition_variable surfaceCapProcTaskCond_; 528 std::mutex surfaceCapProcMutex_; 529 bool surfaceCapProcFinished_ = true; 530 531 #if defined(RS_ENABLE_PARALLEL_UPLOAD) && defined(RS_ENABLE_GL) 532 RSTaskMessage::RSTask uploadTextureBarrierTask_; 533 std::condition_variable uploadTextureTaskCond_; 534 std::mutex uploadTextureMutex_; 535 int32_t uploadTextureFinishedCount_ = 0; 536 EGLSyncKHR uploadTextureFence; 537 #endif 538 539 mutable std::mutex uniRenderMutex_; 540 bool uniRenderFinished_ = false; 541 std::condition_variable uniRenderCond_; 542 543 bool clearMemoryFinished_ = true; 544 bool clearMemDeeply_ = false; 545 546 // Used to refresh the whole display when AccessibilityConfig is changed 547 bool isAccessibilityConfigChanged_ = false; 548 549 // Used to refresh the whole display when curtain screen status is changed 550 bool isCurtainScreenUsingStatusChanged_ = false; 551 552 // Used to refresh the whole display when luminance is changed 553 std::atomic<bool> isLuminanceChanged_ = false; 554 555 // used for blocking mainThread when hardwareThread has 2 and more task to Execute 556 mutable std::mutex hardwareThreadTaskMutex_; 557 std::condition_variable hardwareThreadTaskCond_; 558 559 std::map<NodeId, RSVisibleLevel> lastVisMapForVsyncRate_; 560 VisibleData lastVisVec_; 561 std::map<NodeId, uint64_t> lastDrawStatusMap_; 562 std::vector<NodeId> curDrawStatusVec_; 563 bool qosPidCal_ = false; 564 565 std::atomic<bool> isDirty_ = false; 566 std::atomic<bool> screenPowerOnChanged_ = false; 567 std::atomic_bool doWindowAnimate_ = false; 568 std::vector<NodeId> lastSurfaceIds_; 569 std::atomic<int32_t> focusAppPid_ = -1; 570 std::atomic<int32_t> focusAppUid_ = -1; 571 const uint8_t opacity_ = 255; 572 std::string focusAppBundleName_ = ""; 573 std::string focusAppAbilityName_ = ""; 574 std::atomic<uint64_t> focusNodeId_ = 0; 575 uint64_t focusLeashWindowId_ = 0; 576 uint64_t lastFocusNodeId_ = 0; 577 uint32_t appWindowNum_ = 0; 578 std::atomic<uint32_t> requestNextVsyncNum_ = 0; 579 bool lastFrameHasFilter_ = false; 580 bool vsyncControlEnabled_ = true; 581 bool systemAnimatedScenesEnabled_ = false; 582 bool isFoldScreenDevice_ = false; 583 std::atomic<bool> isGlobalDarkColorMode_ = false; 584 585 std::atomic_bool noNeedToPostTask_ = false; 586 587 bool isAceDebugBoundaryEnabledOfLastFrame_ = false; 588 bool hasPostUpdateAceDebugBoundaryTask_ = false; 589 590 std::shared_ptr<RSBaseRenderEngine> renderEngine_; 591 std::shared_ptr<RSBaseRenderEngine> uniRenderEngine_; 592 std::shared_ptr<RSBaseEventDetector> rsCompositionTimeoutDetector_; 593 RSEventManager rsEventManager_; 594 #if defined(ACCESSIBILITY_ENABLE) 595 std::shared_ptr<AccessibilityObserver> accessibilityObserver_; 596 #endif 597 598 // used for hardware enabled case 599 bool doDirectComposition_ = true; 600 bool needDrawFrame_ = true; 601 bool isLastFrameDirectComposition_ = false; 602 bool isNeedResetClearMemoryTask_ = false; 603 bool isHardwareEnabledBufferUpdated_ = false; 604 std::vector<std::shared_ptr<RSSurfaceRenderNode>> hardwareEnabledNodes_; 605 std::vector<std::shared_ptr<RSSurfaceRenderNode>> selfDrawingNodes_; 606 std::vector<DrawableV2::RSRenderNodeDrawableAdapter::SharedPtr> selfDrawables_; 607 bool isHardwareForcedDisabled_ = false; // if app node has shadow or filter, disable hardware composer for all 608 std::vector<DrawableV2::RSRenderNodeDrawableAdapter::SharedPtr> hardwareEnabledDrwawables_; 609 610 // for client node tree dump 611 struct NodeTreeDumpTask { 612 size_t count = 0; 613 size_t completionCount = 0; 614 std::map<pid_t, std::optional<std::string>> data; 615 }; 616 std::mutex nodeTreeDumpMutex_; 617 std::condition_variable nodeTreeDumpCondVar_; 618 std::unordered_map<uint32_t, NodeTreeDumpTask> nodeTreeDumpTasks_; 619 620 // used for watermark 621 std::mutex watermarkMutex_; 622 std::shared_ptr<Drawing::Image> watermarkImg_ = nullptr; 623 bool watermarkFlag_ = false; 624 bool lastWatermarkFlag_ = false; 625 bool doParallelComposition_ = false; 626 bool hasProtectedLayer_ = false; 627 628 std::shared_ptr<HgmFrameRateManager> frameRateMgr_ = nullptr; 629 std::shared_ptr<RSRenderFrameRateLinker> rsFrameRateLinker_ = nullptr; 630 pid_t desktopPidForRotationScene_ = 0; 631 FrameRateRange rsCurrRange_; 632 633 // UIFirst 634 std::list<std::shared_ptr<RSSurfaceRenderNode>> subThreadNodes_; 635 std::unordered_map<NodeId, bool> cacheCmdSkippedNodes_; 636 std::unordered_map<pid_t, std::pair<std::vector<NodeId>, bool>> cacheCmdSkippedInfo_; 637 std::atomic<uint64_t> frameCount_ = 0; 638 std::set<std::shared_ptr<RSBaseRenderNode>> oldDisplayChildren_; 639 DeviceType deviceType_ = DeviceType::PHONE; 640 bool isCachedSurfaceUpdated_ = false; 641 bool isUiFirstOn_ = false; 642 643 // used for informing hgm the bundle name of SurfaceRenderNodes 644 bool noBundle_ = false; 645 std::string currentBundleName_ = ""; 646 bool forceUpdateUniRenderFlag_ = false; 647 bool idleTimerExpiredFlag_ = false; 648 bool rsIdleTimerExpiredFlag_ = false; 649 // for ui first 650 std::mutex mutex_; 651 std::queue<std::shared_ptr<Drawing::Surface>> tmpSurfaces_; 652 653 // for surface occlusion change callback 654 std::mutex surfaceOcclusionMutex_; 655 std::vector<NodeId> lastRegisteredSurfaceOnTree_; 656 std::mutex systemAnimatedScenesMutex_; 657 std::list<std::pair<SystemAnimatedScenes, time_t>> systemAnimatedScenesList_; 658 std::list<std::pair<SystemAnimatedScenes, time_t>> threeFingerScenesList_; 659 bool isReduceVSyncBySystemAnimatedScenes_ = false; 660 std::unordered_map<NodeId, // map<node ID, <pid, callback, partition points vector, level>> 661 std::tuple<pid_t, sptr<RSISurfaceOcclusionChangeCallback>, 662 std::vector<float>, uint8_t>> surfaceOcclusionListeners_; 663 std::unordered_map<NodeId, // map<node ID, <surface node, app window node>> 664 std::pair<std::shared_ptr<RSSurfaceRenderNode>, std::shared_ptr<RSSurfaceRenderNode>>> savedAppWindowNode_; 665 666 std::shared_ptr<RSAppStateListener> rsAppStateListener_; 667 int32_t subscribeFailCount_ = 0; 668 SystemAnimatedScenes systemAnimatedScenes_ = SystemAnimatedScenes::OTHERS; 669 uint32_t leashWindowCount_ = 0; 670 671 // for ui captures 672 std::vector<std::tuple<NodeId, std::function<void()>>> pendingUiCaptureTasks_; 673 std::queue<std::tuple<NodeId, std::function<void()>>> uiCaptureTasks_; 674 675 // for dvsync (animate requestNextVSync after mark rsnotrendering) 676 bool needRequestNextVsyncAnimate_ = false; 677 678 bool forceUIFirstChanged_ = false; 679 680 // uiextension 681 std::mutex uiExtensionMutex_; 682 UIExtensionCallbackData uiExtensionCallbackData_; 683 bool lastFrameUIExtensionDataEmpty_ = false; 684 // <pid, <uid, callback>> 685 std::map<pid_t, std::pair<uint64_t, sptr<RSIUIExtensionCallback>>> uiExtensionListenners_ = {}; 686 687 // overDraw 688 bool isOverDrawEnabledOfCurFrame_ = false; 689 bool isOverDrawEnabledOfLastFrame_ = false; 690 691 #ifdef RS_PROFILER_ENABLED 692 friend class RSProfiler; 693 #endif 694 #if defined(RS_ENABLE_CHIPSET_VSYNC) 695 bool initVsyncServiceFlag_ = true; 696 #endif 697 pid_t exitedPid_ = -1; 698 std::set<pid_t> exitedPidSet_; 699 RSDrawFrame drawFrame_; 700 std::unique_ptr<RSRenderThreadParams> renderThreadParams_ = nullptr; // sync to render thread 701 RsParallelType rsParallelType_; 702 bool isCurtainScreenOn_ = false; 703 #ifdef RES_SCHED_ENABLE 704 sptr<VSyncSystemAbilityListener> saStatusChangeListener_ = nullptr; 705 #endif 706 // for statistic of jank frames 707 std::atomic_bool isOnVsync_ = false; 708 std::atomic_bool discardJankFrames_ = false; 709 std::atomic_bool skipJankAnimatorFrame_ = false; 710 ScreenId displayNodeScreenId_ = 0; 711 712 // partial render 713 bool isFirstFrameOfPartialRender_ = false; 714 bool isPartialRenderEnabledOfLastFrame_ = false; 715 bool isRegionDebugEnabledOfLastFrame_ = false; 716 }; 717 } // namespace OHOS::Rosen 718 #endif // RS_MAIN_THREAD 719