Lines Matching refs:std

42 const std::string CONTROLLER_THREAD_ID = "AbstractScreenControllerThread";

47 AbstractScreenController::AbstractScreenController(std::recursive_mutex& mutex)

51     controllerHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);

77 std::vector<ScreenId> AbstractScreenController::GetAllScreenIds() const

79     std::lock_guard<std::recursive_mutex> lock(mutex_);

80     std::vector<ScreenId> res;

87 std::vector<ScreenId> AbstractScreenController::GetAllValidScreenIds(const std::vector<ScreenId>& screenIds) const

89     std::lock_guard<std::recursive_mutex> lock(mutex_);

90     std::vector<ScreenId> validScreenIds;

92         auto screenIdIter = std::find(validScreenIds.begin(), validScreenIds.end(), screenId);

104 const std::shared_ptr<RSDisplayNode>& AbstractScreenController::GetRSDisplayNodeByScreenId(ScreenId dmsScreenId) const

106     static std::shared_ptr<RSDisplayNode> notFound = nullptr;

122     std::shared_ptr<RSSurfaceNode>& surfaceNode, bool isAdd, bool isMultiDisplay)

146     std::shared_ptr<RSSurfaceNode>& surfaceNode, bool onTop)

157     std::shared_ptr<RSSurfaceNode>& surfaceNode)

170     std::lock_guard<std::recursive_mutex> lock(mutex_);

181     std::lock_guard<std::recursive_mutex> lock(mutex_);

199     std::lock_guard<std::recursive_mutex> lock(mutex_);

212     std::lock_guard<std::recursive_mutex> lock(mutex_);

218     std::lock_guard<std::recursive_mutex> lock(mutex_);

224     std::lock_guard<std::recursive_mutex> lock(mutex_);

258     std::lock_guard<std::recursive_mutex> lock(mutex_);

305     std::lock_guard<std::recursive_mutex> lock(mutex_);

330                 std::swap(w, h);

361         new(std::nothrow) AbstractScreen(this, screenCapability.GetName(), dmsScreenId, rsScreenId);

375     dmsScreenMap_.insert(std::make_pair(dmsScreenId, absScreen));

382     std::lock_guard<std::recursive_mutex> lock(mutex_);

410             std::vector<ScreenId> screens;

424     std::vector<RSScreenModeInfo> allModes = rsInterface_.GetScreenSupportedModes(absScreen->rsId_);

430         sptr<SupportedScreenModes> info = new(std::nothrow) SupportedScreenModes();

445     if (static_cast<std::size_t>(activeModeId) >= allModes.size()) {

468     std::lock_guard<std::recursive_mutex> lock(mutex_);

491     std::lock_guard<std::recursive_mutex> lock(mutex_);

519         std::lock_guard<std::recursive_mutex> lock(mutex_);

528     std::lock_guard<std::recursive_mutex> lock(mutex_);

542     std::ostringstream buffer;

544     std::string name = buffer.str();

549         screenGroup = new(std::nothrow) AbstractScreenGroup(this, dmsGroupScreenId,

552         screenGroup = new(std::nothrow) AbstractScreenGroup(this, dmsGroupScreenId,

572     dmsScreenGroupMap_.insert(std::make_pair(dmsGroupScreenId, screenGroup));

573     dmsScreenMap_.insert(std::make_pair(dmsGroupScreenId, screenGroup));

622     std::lock_guard<std::recursive_mutex> lock(mutex_);

631         dmsScreenMap_.insert(std::make_pair(dmsScreenId, absScreen));

651     sptr<AbstractScreen> absScreen = new(std::nothrow) AbstractScreen(this, option.name_, dmsScreenId, rsId);

652     sptr<SupportedScreenModes> info = new(std::nothrow) SupportedScreenModes();

675     std::lock_guard<std::recursive_mutex> lock(mutex_);

714     std::lock_guard<std::recursive_mutex> lock(mutex_);

802     std::sort(screens.begin(), screens.end(), [](const auto &a, const auto &b) {

843         std::swap(srect.w, srect.h);

847     const std::shared_ptr<RSDisplayNode>& displayNode = GetRSDisplayNodeByScreenId(screenId);

862         std::weak_ptr<RSDisplayNode> weakNode = GetRSDisplayNodeByScreenId(screenId);

891     const std::shared_ptr<RSDisplayNode>& displayNode, struct ScreenRect srect)

953     std::vector<ScreenColorGamut>& colorGamuts)

1016         std::lock_guard<std::recursive_mutex> lock(mutex_);

1049         std::lock_guard<std::recursive_mutex> lock(mutex_);

1079 DMError AbstractScreenController::MakeMirror(ScreenId screenId, std::vector<ScreenId> screens)

1090         std::lock_guard<std::recursive_mutex> lock(mutex_);

1103     std::vector<Point> startPoints;

1113 DMError AbstractScreenController::StopScreens(const std::vector<ScreenId>& screenIds, ScreenCombination stopCombination)

1115     std::lock_guard<std::recursive_mutex> lock(mutex_);

1154 void AbstractScreenController::ChangeScreenGroup(sptr<AbstractScreenGroup> group, const std::vector<ScreenId>& screens,

1155     const std::vector<Point>& startPoints, bool filterScreen, ScreenCombination combination)

1157     std::map<ScreenId, bool> removeChildResMap;

1158     std::vector<ScreenId> addScreens;

1159     std::vector<Point> addChildPos;

1160     std::lock_guard<std::recursive_mutex> lock(mutex_);

1186     const std::vector<ScreenId>& addScreens, const std::vector<Point>& addChildPos,

1187     std::map<ScreenId, bool>& removeChildResMap)

1189     std::vector<sptr<ScreenInfo>> addToGroup;

1190     std::vector<sptr<ScreenInfo>> removeFromGroup;

1191     std::vector<sptr<ScreenInfo>> changeGroup;

1224 bool AbstractScreenController::MakeExpand(std::vector<ScreenId> screenIds, std::vector<Point> startPoints)

1242 void AbstractScreenController::RemoveVirtualScreenFromGroup(std::vector<ScreenId> screens)

1247     std::vector<sptr<ScreenInfo>> removeFromGroup;

1274     std::lock_guard<std::recursive_mutex> lock(mutex_);

1405     std::string trigger = SysCapUtil::GetClientName();

1414     const std::vector<sptr<ScreenInfo>>& screenInfo, ScreenGroupChangeEvent event) const

1419     std::string trigger = SysCapUtil::GetClientName();

1488             std::lock_guard<std::recursive_mutex> lock(mutex_);

1497         std::this_thread::sleep_for(std::chrono::milliseconds(RETRY_WAIT_MS));