1/*
2 * Copyright (c) 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#include "window_manager_lite.h"
17
18#include <algorithm>
19#include <cinttypes>
20
21#include "marshalling_helper.h"
22#include "window_adapter_lite.h"
23#include "window_manager_agent_lite.h"
24#include "window_manager_hilog.h"
25#include "wm_common.h"
26
27namespace OHOS {
28namespace Rosen {
29namespace {
30constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_WINDOW, "WindowManagerLite"};
31}
32
33WM_IMPLEMENT_SINGLE_INSTANCE(WindowManagerLite)
34
35class WindowManagerLite::Impl {
36public:
37    explicit Impl(std::recursive_mutex& mutex) : mutex_(mutex) {}
38    void NotifyFocused(uint32_t windowId, const sptr<IRemoteObject>& abilityToken,
39        WindowType windowType, DisplayId displayId);
40    void NotifyUnfocused(uint32_t windowId, const sptr<IRemoteObject>& abilityToken,
41        WindowType windowType, DisplayId displayId);
42    void NotifyFocused(const sptr<FocusChangeInfo>& focusChangeInfo);
43    void NotifyUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo);
44    void NotifyWindowVisibilityInfoChanged(const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfos);
45    void NotifyWindowDrawingContentInfoChanged(const std::vector<sptr<WindowDrawingContentInfo>>&
46        windowDrawingContentInfos);
47    void NotifyWindowModeChange(WindowModeType type);
48    void UpdateCameraWindowStatus(uint32_t accessTokenId, bool isShowing);
49    void NotifyWMSConnected(int32_t userId, int32_t screenId);
50    void NotifyWMSDisconnected(int32_t userId, int32_t screenId);
51    void NotifyWindowStyleChange(WindowStyleType type);
52    void UpdatePiPWindowStateChanged(const std::string& bundleName, bool isForeground);
53    void NotifyAccessibilityWindowInfo(const std::vector<sptr<AccessibilityWindowInfo>>& infos,
54        WindowUpdateType type);
55
56    static inline SingletonDelegator<WindowManagerLite> delegator_;
57
58    std::recursive_mutex& mutex_;
59    std::vector<sptr<IFocusChangedListener>> focusChangedListeners_;
60    sptr<WindowManagerAgentLite> focusChangedListenerAgent_;
61    std::vector<sptr<IWindowUpdateListener>> windowUpdateListeners_;
62    sptr<WindowManagerAgentLite> windowUpdateListenerAgent_;
63    std::vector<sptr<IVisibilityChangedListener>> windowVisibilityListeners_;
64    sptr<WindowManagerAgentLite> windowVisibilityListenerAgent_;
65    std::vector<sptr<IDrawingContentChangedListener>> windowDrawingContentListeners_;
66    sptr<WindowManagerAgentLite> windowDrawingContentListenerAgent_;
67    std::vector<sptr<IWindowModeChangedListener>> windowModeListeners_;
68    sptr<WindowManagerAgentLite> windowModeListenerAgent_;
69    std::vector<sptr<ICameraWindowChangedListener>> cameraWindowChangedListeners_;
70    sptr<WindowManagerAgentLite> cameraWindowChangedListenerAgent_;
71    sptr<IWMSConnectionChangedListener> wmsConnectionChangedListener_;
72    std::vector<sptr<IWindowStyleChangedListener>> windowStyleListeners_;
73    sptr<WindowManagerAgentLite> windowStyleListenerAgent_;
74    std::vector<sptr<IPiPStateChangedListener>> pipStateChangedListeners_;
75    sptr<WindowManagerAgentLite> pipStateChangedListenerAgent_;
76};
77
78void WindowManagerLite::Impl::NotifyWMSConnected(int32_t userId, int32_t screenId)
79{
80    TLOGI(WmsLogTag::WMS_MULTI_USER, "WMS connected [userId:%{public}d; screenId:%{public}d]", userId, screenId);
81    sptr<IWMSConnectionChangedListener> wmsConnectionChangedListener;
82    {
83        std::lock_guard<std::recursive_mutex> lock(mutex_);
84        wmsConnectionChangedListener = wmsConnectionChangedListener_;
85    }
86    if (wmsConnectionChangedListener != nullptr) {
87        wmsConnectionChangedListener->OnConnected(userId, screenId);
88    }
89}
90
91void WindowManagerLite::Impl::NotifyWMSDisconnected(int32_t userId, int32_t screenId)
92{
93    TLOGI(WmsLogTag::WMS_MULTI_USER, "WMS disconnected [userId:%{public}d; screenId:%{public}d]", userId, screenId);
94    sptr<IWMSConnectionChangedListener> wmsConnectionChangedListener;
95    {
96        std::lock_guard<std::recursive_mutex> lock(mutex_);
97        wmsConnectionChangedListener = wmsConnectionChangedListener_;
98    }
99    if (wmsConnectionChangedListener != nullptr) {
100        wmsConnectionChangedListener->OnDisconnected(userId, screenId);
101    }
102}
103
104void WindowManagerLite::Impl::NotifyFocused(const sptr<FocusChangeInfo>& focusChangeInfo)
105{
106    if (focusChangeInfo == nullptr) {
107        return;
108    }
109    WLOGFD("[WMSFocus]NotifyFocused [%{public}u; %{public}" PRIu64"; %{public}d; %{public}d; %{public}u]",
110        focusChangeInfo->windowId_, focusChangeInfo->displayId_, focusChangeInfo->pid_, focusChangeInfo->uid_,
111        static_cast<uint32_t>(focusChangeInfo->windowType_));
112
113    std::vector<sptr<IFocusChangedListener>> focusChangeListeners;
114    {
115        std::lock_guard<std::recursive_mutex> lock(mutex_);
116        focusChangeListeners = focusChangedListeners_;
117    }
118    WLOGFD("NotifyFocused listeners: %{public}zu", focusChangeListeners.size());
119    for (auto& listener : focusChangeListeners) {
120        if (listener == nullptr) {
121            continue;
122        }
123        listener->OnFocused(focusChangeInfo);
124    }
125}
126
127void WindowManagerLite::Impl::NotifyUnfocused(const sptr<FocusChangeInfo>& focusChangeInfo)
128{
129    if (focusChangeInfo == nullptr) {
130        return;
131    }
132    WLOGFD("[WMSFocus]NotifyUnfocused [%{public}u; %{public}" PRIu64"; %{public}d; %{public}d; %{public}u]",
133        focusChangeInfo->windowId_, focusChangeInfo->displayId_, focusChangeInfo->pid_, focusChangeInfo->uid_,
134        static_cast<uint32_t>(focusChangeInfo->windowType_));
135
136    std::vector<sptr<IFocusChangedListener>> focusChangeListeners;
137    {
138        std::lock_guard<std::recursive_mutex> lock(mutex_);
139        focusChangeListeners = focusChangedListeners_;
140    }
141    WLOGFD("NotifyUnfocused listeners: %{public}zu", focusChangeListeners.size());
142    for (auto& listener : focusChangeListeners) {
143        if (listener == nullptr) {
144            continue;
145        }
146        listener->OnUnfocused(focusChangeInfo);
147    }
148}
149
150void WindowManagerLite::Impl::NotifyWindowVisibilityInfoChanged(
151    const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfos)
152{
153    std::vector<sptr<IVisibilityChangedListener>> visibilityChangeListeners;
154    {
155        std::lock_guard<std::recursive_mutex> lock(mutex_);
156        visibilityChangeListeners = windowVisibilityListeners_;
157    }
158    for (auto& listener : visibilityChangeListeners) {
159        if (listener == nullptr) {
160            continue;
161        }
162        listener->OnWindowVisibilityChanged(windowVisibilityInfos);
163    }
164}
165
166void WindowManagerLite::Impl::NotifyWindowDrawingContentInfoChanged(
167    const std::vector<sptr<WindowDrawingContentInfo>>& windowDrawingContentInfos)
168{
169    std::vector<sptr<IDrawingContentChangedListener>> windowDrawingContentChangeListeners;
170    {
171        std::lock_guard<std::recursive_mutex> lock(mutex_);
172        windowDrawingContentChangeListeners = windowDrawingContentListeners_;
173    }
174    for (auto& listener : windowDrawingContentChangeListeners) {
175        if (listener == nullptr) {
176            continue;
177        }
178        listener->OnWindowDrawingContentChanged(windowDrawingContentInfos);
179    }
180}
181
182void WindowManagerLite::Impl::NotifyWindowModeChange(WindowModeType type)
183{
184    TLOGI(WmsLogTag::WMS_MAIN, "WindowManager::Impl UpdateWindowModeTypeInfo type: %{public}d",
185          static_cast<uint8_t>(type));
186    std::vector<sptr<IWindowModeChangedListener>> windowModeListeners;
187    {
188        std::lock_guard<std::recursive_mutex> lock(mutex_);
189        windowModeListeners = windowModeListeners_;
190    }
191    for (auto &listener : windowModeListeners) {
192        listener->OnWindowModeUpdate(type);
193    }
194}
195
196void WindowManagerLite::Impl::NotifyAccessibilityWindowInfo(const std::vector<sptr<AccessibilityWindowInfo>>& infos,
197    WindowUpdateType type)
198{
199    if (infos.empty()) {
200        WLOGFE("infos is empty");
201        return;
202    }
203    for (auto& info : infos) {
204        if (info == nullptr) {
205            TLOGD(WmsLogTag::WMS_MAIN, "info is nullptr");
206            continue;
207        }
208        TLOGD(WmsLogTag::WMS_MAIN, "wid[%{public}u], innerWid[%{public}u], "
209            "uiNodeId[%{public}u], rect[%{public}d %{public}d %{public}d %{public}d], "
210            "isFocused[%{public}d], isDecorEnable[%{public}d], displayId[%{public}" PRIu64 "], layer[%{public}u], "
211            "mode[%{public}u], type[%{public}u, updateType[%{public}d], bundle[%{public}s]",
212            info->wid_, info->innerWid_, info->uiNodeId_, info->windowRect_.width_, info->windowRect_.height_,
213            info->windowRect_.posX_, info->windowRect_.posY_, info->focused_, info->isDecorEnable_, info->displayId_,
214            info->layer_, info->mode_, info->type_, type, info->bundleName_.c_str());
215        for (const auto& rect : info->touchHotAreas_) {
216            TLOGD(WmsLogTag::WMS_MAIN, "window touch hot areas rect[x=%{public}d, y=%{public}d, "
217            "w=%{public}d, h=%{public}d]", rect.posX_, rect.posY_, rect.width_, rect.height_);
218        }
219    }
220
221    std::vector<sptr<IWindowUpdateListener>> windowUpdateListeners;
222    {
223        std::lock_guard<std::recursive_mutex> lock(mutex_);
224        windowUpdateListeners = windowUpdateListeners_;
225    }
226    for (auto& listener : windowUpdateListeners) {
227        listener->OnWindowUpdate(infos, type);
228    }
229}
230
231void WindowManagerLite::Impl::UpdateCameraWindowStatus(uint32_t accessTokenId, bool isShowing)
232{
233    TLOGI(WmsLogTag::WMS_SYSTEM, "Camera window, accessTokenId = %{public}u, isShowing = %{public}u",
234        accessTokenId, isShowing);
235    std::vector<sptr<ICameraWindowChangedListener>> cameraWindowChangeListeners;
236    {
237        std::lock_guard<std::recursive_mutex> lock(mutex_);
238        cameraWindowChangeListeners = cameraWindowChangedListeners_;
239    }
240    for (auto& listener : cameraWindowChangeListeners) {
241        listener->OnCameraWindowChange(accessTokenId, isShowing);
242    }
243}
244
245void WindowManagerLite::Impl::NotifyWindowStyleChange(WindowStyleType type)
246{
247    TLOGI(WmsLogTag::WMS_MAIN, "WindowStyleChange: %{public}d",
248          static_cast<uint8_t>(type));
249    std::vector<sptr<IWindowStyleChangedListener>> windowStyleListeners;
250    {
251        std::lock_guard<std::recursive_mutex> lock(mutex_);
252        windowStyleListeners = windowStyleListeners_;
253    }
254    for (auto &listener : windowStyleListeners) {
255        TLOGI(WmsLogTag::WMS_MAIN, "real WindowStyleChange type: %{public}d",
256              static_cast<uint8_t>(type));
257        listener->OnWindowStyleUpdate(type);
258    }
259}
260
261void WindowManagerLite::Impl::UpdatePiPWindowStateChanged(const std::string& bundleName, bool isForeground)
262{
263    std::vector<sptr<IPiPStateChangedListener>> pipStateChangedListeners;
264    {
265        std::lock_guard<std::recursive_mutex> lock(mutex_);
266        pipStateChangedListeners = pipStateChangedListeners_;
267    }
268    for (auto& listener : pipStateChangedListeners) {
269        if (listener == nullptr) {
270            continue;
271        }
272        listener->OnPiPStateChanged(bundleName, isForeground);
273    }
274}
275
276WindowManagerLite::WindowManagerLite() : pImpl_(std::make_unique<Impl>(mutex_))
277{
278}
279
280WindowManagerLite::~WindowManagerLite()
281{
282    std::lock_guard<std::recursive_mutex> lock(mutex_);
283    destroyed_ = true;
284}
285
286WMError WindowManagerLite::RegisterFocusChangedListener(const sptr<IFocusChangedListener>& listener)
287{
288    if (listener == nullptr) {
289        WLOGFE("listener could not be null");
290        return WMError::WM_ERROR_NULLPTR;
291    }
292
293    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
294    WMError ret = WMError::WM_OK;
295    if (pImpl_->focusChangedListenerAgent_ == nullptr) {
296        pImpl_->focusChangedListenerAgent_ = new (std::nothrow) WindowManagerAgentLite();
297        ret = SingletonContainer::Get<WindowAdapterLite>().RegisterWindowManagerAgent(
298            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS, pImpl_->focusChangedListenerAgent_);
299    }
300    if (ret != WMError::WM_OK) {
301        WLOGFW("RegisterWindowManagerAgent failed !");
302        pImpl_->focusChangedListenerAgent_ = nullptr;
303    } else {
304        auto iter = std::find(pImpl_->focusChangedListeners_.begin(), pImpl_->focusChangedListeners_.end(), listener);
305        if (iter != pImpl_->focusChangedListeners_.end()) {
306            WLOGFW("Listener is already registered.");
307            return WMError::WM_OK;
308        }
309        pImpl_->focusChangedListeners_.push_back(listener);
310    }
311    return ret;
312}
313
314WMError WindowManagerLite::UnregisterFocusChangedListener(const sptr<IFocusChangedListener>& listener)
315{
316    if (listener == nullptr) {
317        WLOGFE("listener could not be null");
318        return WMError::WM_ERROR_NULLPTR;
319    }
320
321    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
322    auto iter = std::find(pImpl_->focusChangedListeners_.begin(), pImpl_->focusChangedListeners_.end(), listener);
323    if (iter == pImpl_->focusChangedListeners_.end()) {
324        WLOGFE("could not find this listener");
325        return WMError::WM_OK;
326    }
327    pImpl_->focusChangedListeners_.erase(iter);
328    WMError ret = WMError::WM_OK;
329    if (pImpl_->focusChangedListeners_.empty() && pImpl_->focusChangedListenerAgent_ != nullptr) {
330        ret = SingletonContainer::Get<WindowAdapterLite>().UnregisterWindowManagerAgent(
331            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS, pImpl_->focusChangedListenerAgent_);
332        if (ret == WMError::WM_OK) {
333            pImpl_->focusChangedListenerAgent_ = nullptr;
334        }
335    }
336    return ret;
337}
338
339WMError WindowManagerLite::RegisterVisibilityChangedListener(const sptr<IVisibilityChangedListener>& listener)
340{
341    if (listener == nullptr) {
342        WLOGFE("listener could not be null");
343        return WMError::WM_ERROR_NULLPTR;
344    }
345    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
346    WMError ret = WMError::WM_OK;
347    if (pImpl_->windowVisibilityListenerAgent_ == nullptr) {
348        pImpl_->windowVisibilityListenerAgent_ = new (std::nothrow) WindowManagerAgentLite();
349        ret = SingletonContainer::Get<WindowAdapterLite>().RegisterWindowManagerAgent(
350            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_WINDOW_VISIBILITY,
351            pImpl_->windowVisibilityListenerAgent_);
352    }
353    if (ret != WMError::WM_OK) {
354        WLOGFW("RegisterWindowManagerAgent failed !");
355        pImpl_->windowVisibilityListenerAgent_ = nullptr;
356    } else {
357        auto iter = std::find(pImpl_->windowVisibilityListeners_.begin(), pImpl_->windowVisibilityListeners_.end(),
358            listener);
359        if (iter != pImpl_->windowVisibilityListeners_.end()) {
360            WLOGFW("Listener is already registered.");
361            return WMError::WM_OK;
362        }
363        pImpl_->windowVisibilityListeners_.emplace_back(listener);
364    }
365    return ret;
366}
367
368WMError WindowManagerLite::UnregisterVisibilityChangedListener(const sptr<IVisibilityChangedListener>& listener)
369{
370    if (listener == nullptr) {
371        WLOGFE("listener could not be null");
372        return WMError::WM_ERROR_NULLPTR;
373    }
374    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
375    pImpl_->windowVisibilityListeners_.erase(std::remove_if(pImpl_->windowVisibilityListeners_.begin(),
376        pImpl_->windowVisibilityListeners_.end(), [listener](sptr<IVisibilityChangedListener> registeredListener) {
377            return registeredListener == listener;
378        }), pImpl_->windowVisibilityListeners_.end());
379
380    WMError ret = WMError::WM_OK;
381    if (pImpl_->windowVisibilityListeners_.empty() && pImpl_->windowVisibilityListenerAgent_ != nullptr) {
382        ret = SingletonContainer::Get<WindowAdapterLite>().UnregisterWindowManagerAgent(
383            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_WINDOW_VISIBILITY,
384            pImpl_->windowVisibilityListenerAgent_);
385        if (ret == WMError::WM_OK) {
386            pImpl_->windowVisibilityListenerAgent_ = nullptr;
387        }
388    }
389    return ret;
390}
391
392void WindowManagerLite::GetFocusWindowInfo(FocusChangeInfo& focusInfo)
393{
394    WLOGFD("In");
395    SingletonContainer::Get<WindowAdapterLite>().GetFocusWindowInfo(focusInfo);
396}
397
398void WindowManagerLite::UpdateFocusChangeInfo(const sptr<FocusChangeInfo>& focusChangeInfo, bool focused) const
399{
400    if (focusChangeInfo == nullptr) {
401        WLOGFE("focusChangeInfo is nullptr.");
402        return;
403    }
404    WLOGFD("[WMSFocus]window focus change: %{public}d, id: %{public}u", focused, focusChangeInfo->windowId_);
405    if (focused) {
406        pImpl_->NotifyFocused(focusChangeInfo);
407    } else {
408        pImpl_->NotifyUnfocused(focusChangeInfo);
409    }
410}
411
412void WindowManagerLite::UpdateWindowVisibilityInfo(
413    const std::vector<sptr<WindowVisibilityInfo>>& windowVisibilityInfos) const
414{
415    pImpl_->NotifyWindowVisibilityInfoChanged(windowVisibilityInfos);
416}
417
418WMError WindowManagerLite::GetVisibilityWindowInfo(std::vector<sptr<WindowVisibilityInfo>>& infos) const
419{
420    WMError ret = SingletonContainer::Get<WindowAdapterLite>().GetVisibilityWindowInfo(infos);
421    if (ret != WMError::WM_OK) {
422        WLOGFE("get window visibility info failed");
423    }
424    return ret;
425}
426
427void WindowManagerLite::UpdateWindowDrawingContentInfo(
428    const std::vector<sptr<WindowDrawingContentInfo>>& windowDrawingContentInfos) const
429{
430    pImpl_->NotifyWindowDrawingContentInfoChanged(windowDrawingContentInfos);
431}
432
433void WindowManagerLite::UpdateCameraWindowStatus(uint32_t accessTokenId, bool isShowing) const
434{
435    pImpl_->UpdateCameraWindowStatus(accessTokenId, isShowing);
436}
437
438void WindowManagerLite::OnRemoteDied()
439{
440    WLOGI("wms is died");
441    std::lock_guard<std::recursive_mutex> lock(mutex_);
442    if (destroyed_) {
443        WLOGE("Already destroyed");
444        return;
445    }
446    pImpl_->focusChangedListenerAgent_ = nullptr;
447    pImpl_->windowUpdateListenerAgent_ = nullptr;
448    pImpl_->windowVisibilityListenerAgent_ = nullptr;
449    pImpl_->windowDrawingContentListenerAgent_ = nullptr;
450}
451
452WMError WindowManagerLite::RegisterDrawingContentChangedListener(const sptr<IDrawingContentChangedListener>& listener)
453{
454    if (listener == nullptr) {
455        WLOGFE("listener could not be null");
456        return WMError::WM_ERROR_NULLPTR;
457    }
458    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
459    WMError ret = WMError::WM_OK;
460    if (pImpl_->windowDrawingContentListenerAgent_ == nullptr) {
461        pImpl_->windowDrawingContentListenerAgent_ = new (std::nothrow) WindowManagerAgentLite();
462        ret = SingletonContainer::Get<WindowAdapterLite>().RegisterWindowManagerAgent(
463            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_WINDOW_DRAWING_STATE,
464            pImpl_->windowDrawingContentListenerAgent_);
465    }
466    if (ret != WMError::WM_OK) {
467        WLOGFW("RegisterWindowManagerAgent failed !");
468        pImpl_->windowDrawingContentListenerAgent_ = nullptr;
469    } else {
470        auto iter = std::find(pImpl_->windowDrawingContentListeners_.begin(),
471            pImpl_->windowDrawingContentListeners_.end(), listener);
472        if (iter != pImpl_->windowDrawingContentListeners_.end()) {
473            WLOGFW("Listener is already registered.");
474            return WMError::WM_OK;
475        }
476        pImpl_->windowDrawingContentListeners_.emplace_back(listener);
477    }
478    return ret;
479}
480
481WMError WindowManagerLite::UnregisterDrawingContentChangedListener(const sptr<IDrawingContentChangedListener>& listener)
482{
483    if (listener == nullptr) {
484        WLOGFE("listener could not be null");
485        return WMError::WM_ERROR_NULLPTR;
486    }
487    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
488    pImpl_->windowDrawingContentListeners_.erase(std::remove_if(pImpl_->windowDrawingContentListeners_.begin(),
489        pImpl_->windowDrawingContentListeners_.end(),
490        [listener](sptr<IDrawingContentChangedListener> registeredListener) { return registeredListener == listener; }),
491        pImpl_->windowDrawingContentListeners_.end());
492
493    WMError ret = WMError::WM_OK;
494    if (pImpl_->windowDrawingContentListeners_.empty() && pImpl_->windowDrawingContentListenerAgent_ != nullptr) {
495        ret = SingletonContainer::Get<WindowAdapterLite>().UnregisterWindowManagerAgent(
496            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_WINDOW_DRAWING_STATE,
497            pImpl_->windowDrawingContentListenerAgent_);
498        if (ret == WMError::WM_OK) {
499            pImpl_->windowDrawingContentListenerAgent_ = nullptr;
500        }
501    }
502    return ret;
503}
504
505void WindowManagerLite::UpdateWindowModeTypeInfo(WindowModeType type) const
506{
507    pImpl_->NotifyWindowModeChange(type);
508}
509
510void WindowManagerLite::NotifyAccessibilityWindowInfo(const std::vector<sptr<AccessibilityWindowInfo>>& infos,
511    WindowUpdateType type) const
512{
513    pImpl_->NotifyAccessibilityWindowInfo(infos, type);
514}
515
516WMError WindowManagerLite::GetWindowModeType(WindowModeType& windowModeType) const
517{
518    WMError ret = SingletonContainer::Get<WindowAdapterLite>().GetWindowModeType(windowModeType);
519    if (ret != WMError::WM_OK) {
520        WLOGFE("get window visibility info failed");
521    }
522    return ret;
523}
524
525WMError WindowManagerLite::RegisterWindowModeChangedListener(const sptr<IWindowModeChangedListener>& listener)
526{
527    if (listener == nullptr) {
528        TLOGE(WmsLogTag::WMS_MAIN, "listener could not be null");
529        return WMError::WM_ERROR_NULLPTR;
530    }
531
532    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
533    if (pImpl_->windowModeListenerAgent_ == nullptr) {
534        pImpl_->windowModeListenerAgent_ = new (std::nothrow) WindowManagerAgentLite();
535    }
536    WMError ret = SingletonContainer::Get<WindowAdapterLite>().RegisterWindowManagerAgent(
537        WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_WINDOW_MODE, pImpl_->windowModeListenerAgent_);
538    if (ret != WMError::WM_OK) {
539        TLOGW(WmsLogTag::WMS_MAIN, "RegisterWindowManagerAgent failed!");
540        pImpl_->windowModeListenerAgent_ = nullptr;
541        return ret;
542    }
543    auto iter = std::find(pImpl_->windowModeListeners_.begin(), pImpl_->windowModeListeners_.end(), listener);
544    if (iter != pImpl_->windowModeListeners_.end()) {
545        TLOGW(WmsLogTag::WMS_MAIN, "Listener is already registered.");
546        return WMError::WM_OK;
547    }
548    pImpl_->windowModeListeners_.push_back(listener);
549    return ret;
550}
551
552WMError WindowManagerLite::UnregisterWindowModeChangedListener(const sptr<IWindowModeChangedListener>& listener)
553{
554    if (listener == nullptr) {
555        TLOGE(WmsLogTag::WMS_MAIN, "listener could not be null");
556        return WMError::WM_ERROR_NULLPTR;
557    }
558
559    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
560    auto iter = std::find(pImpl_->windowModeListeners_.begin(), pImpl_->windowModeListeners_.end(), listener);
561    if (iter == pImpl_->windowModeListeners_.end()) {
562        TLOGE(WmsLogTag::WMS_MAIN, "could not find this listener");
563        return WMError::WM_OK;
564    }
565    pImpl_->windowModeListeners_.erase(iter);
566    WMError ret = WMError::WM_OK;
567    if (pImpl_->windowModeListeners_.empty() && pImpl_->windowModeListenerAgent_ != nullptr) {
568        ret = SingletonContainer::Get<WindowAdapterLite>().UnregisterWindowManagerAgent(
569            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_WINDOW_MODE, pImpl_->windowModeListenerAgent_);
570        if (ret == WMError::WM_OK) {
571            pImpl_->windowModeListenerAgent_ = nullptr;
572        }
573    }
574    return ret;
575}
576
577WMError WindowManagerLite::RegisterCameraWindowChangedListener(const sptr<ICameraWindowChangedListener>& listener)
578{
579    if (listener == nullptr) {
580        TLOGE(WmsLogTag::WMS_SYSTEM, "listener could not be null");
581        return WMError::WM_ERROR_NULLPTR;
582    }
583
584    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
585    if (pImpl_->cameraWindowChangedListenerAgent_ == nullptr) {
586        pImpl_->cameraWindowChangedListenerAgent_ = new WindowManagerAgentLite();
587    }
588    WMError ret = SingletonContainer::Get<WindowAdapterLite>().RegisterWindowManagerAgent(
589        WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_CAMERA_WINDOW, pImpl_->cameraWindowChangedListenerAgent_);
590    if (ret != WMError::WM_OK) {
591        TLOGW(WmsLogTag::WMS_SYSTEM, "RegisterWindowManagerAgent failed!");
592        pImpl_->cameraWindowChangedListenerAgent_ = nullptr;
593    } else {
594        auto iter = std::find(pImpl_->cameraWindowChangedListeners_.begin(),
595            pImpl_->cameraWindowChangedListeners_.end(), listener);
596        if (iter != pImpl_->cameraWindowChangedListeners_.end()) {
597            TLOGW(WmsLogTag::WMS_SYSTEM, "Listener is already registered.");
598            return WMError::WM_OK;
599        }
600        pImpl_->cameraWindowChangedListeners_.push_back(listener);
601    }
602    return ret;
603}
604
605WMError WindowManagerLite::UnregisterCameraWindowChangedListener(const sptr<ICameraWindowChangedListener>& listener)
606{
607    if (listener == nullptr) {
608        TLOGE(WmsLogTag::WMS_SYSTEM, "listener could not be null");
609        return WMError::WM_ERROR_NULLPTR;
610    }
611
612    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
613    auto iter = std::find(pImpl_->cameraWindowChangedListeners_.begin(),
614        pImpl_->cameraWindowChangedListeners_.end(), listener);
615    if (iter == pImpl_->cameraWindowChangedListeners_.end()) {
616        TLOGE(WmsLogTag::WMS_SYSTEM, "could not find this listener");
617        return WMError::WM_OK;
618    }
619    pImpl_->cameraWindowChangedListeners_.erase(iter);
620    WMError ret = WMError::WM_OK;
621    if (pImpl_->cameraWindowChangedListeners_.empty() &&
622        pImpl_->cameraWindowChangedListenerAgent_ != nullptr) {
623        ret = SingletonContainer::Get<WindowAdapterLite>().UnregisterWindowManagerAgent(
624            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_CAMERA_WINDOW,
625            pImpl_->cameraWindowChangedListenerAgent_);
626        if (ret == WMError::WM_OK) {
627            pImpl_->cameraWindowChangedListenerAgent_ = nullptr;
628        }
629    }
630    return ret;
631}
632
633WMError WindowManagerLite::GetMainWindowInfos(int32_t topNum, std::vector<MainWindowInfo>& topNInfo)
634{
635    TLOGI(WmsLogTag::WMS_MAIN, "Get main window info lite");
636    return SingletonContainer::Get<WindowAdapterLite>().GetMainWindowInfos(topNum, topNInfo);
637}
638
639WMError WindowManagerLite::GetAllMainWindowInfos(std::vector<MainWindowInfo>& infos) const
640{
641    if (!infos.empty()) {
642        TLOGE(WmsLogTag::WMS_MAIN, "infos is not empty.");
643        return WMError::WM_ERROR_INVALID_PARAM;
644    }
645    return SingletonContainer::Get<WindowAdapterLite>().GetAllMainWindowInfos(infos);
646}
647
648WMError WindowManagerLite::ClearMainSessions(const std::vector<int32_t>& persistentIds)
649{
650    if (persistentIds.empty()) {
651        TLOGW(WmsLogTag::WMS_MAIN, "Clear main Session failed, persistentIds is empty.");
652        return WMError::WM_OK;
653    }
654    return SingletonContainer::Get<WindowAdapterLite>().ClearMainSessions(persistentIds);
655}
656
657WMError WindowManagerLite::ClearMainSessions(const std::vector<int32_t>& persistentIds,
658    std::vector<int32_t>& clearFailedIds)
659{
660    if (persistentIds.empty()) {
661        TLOGW(WmsLogTag::WMS_MAIN, "Clear main Session failed, persistentIds is empty.");
662        return WMError::WM_OK;
663    }
664    return SingletonContainer::Get<WindowAdapterLite>().ClearMainSessions(persistentIds, clearFailedIds);
665}
666
667WMError WindowManagerLite::RaiseWindowToTop(int32_t persistentId)
668{
669    WMError ret = SingletonContainer::Get<WindowAdapterLite>().RaiseWindowToTop(persistentId);
670    if (ret != WMError::WM_OK) {
671        TLOGE(WmsLogTag::WMS_SYSTEM, "raise window to top failed.");
672    }
673    return ret;
674}
675
676WMError WindowManagerLite::RegisterWMSConnectionChangedListener(const sptr<IWMSConnectionChangedListener>& listener)
677{
678    int32_t clientUserId = GetUserIdByUid(getuid());
679    if (clientUserId != SYSTEM_USERID) {
680        TLOGW(WmsLogTag::WMS_MULTI_USER, "Not u0 user, permission denied");
681        return WMError::WM_ERROR_INVALID_PERMISSION;
682    }
683    if (listener == nullptr) {
684        TLOGE(WmsLogTag::WMS_MULTI_USER, "WMS connection changed listener registered could not be null");
685        return WMError::WM_ERROR_NULLPTR;
686    }
687    TLOGI(WmsLogTag::WMS_MULTI_USER, "Register enter");
688    {
689        std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
690        if (pImpl_->wmsConnectionChangedListener_) {
691            TLOGI(WmsLogTag::WMS_MULTI_USER, "wmsConnectionChangedListener is already registered, do nothing");
692            return WMError::WM_OK;
693        }
694        pImpl_->wmsConnectionChangedListener_ = listener;
695    }
696    auto ret = SingletonContainer::Get<WindowAdapterLite>().RegisterWMSConnectionChangedListener(
697        std::bind(&WindowManagerLite::OnWMSConnectionChanged, this, std::placeholders::_1, std::placeholders::_2,
698            std::placeholders::_3));
699    if (ret != WMError::WM_OK) {
700        pImpl_->wmsConnectionChangedListener_ = nullptr;
701    }
702    return ret;
703}
704
705WMError WindowManagerLite::UnregisterWMSConnectionChangedListener()
706{
707    TLOGI(WmsLogTag::WMS_MULTI_USER, "Unregister enter");
708    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
709    pImpl_->wmsConnectionChangedListener_ = nullptr;
710    return WMError::WM_OK;
711}
712
713void WindowManagerLite::OnWMSConnectionChanged(int32_t userId, int32_t screenId, bool isConnected) const
714{
715    if (isConnected) {
716        pImpl_->NotifyWMSConnected(userId, screenId);
717    } else {
718        pImpl_->NotifyWMSDisconnected(userId, screenId);
719    }
720}
721
722WMError WindowManagerLite::NotifyWindowStyleChange(WindowStyleType type)
723{
724    pImpl_->NotifyWindowStyleChange(type);
725    return WMError::WM_OK;
726}
727
728WMError WindowManagerLite::RegisterWindowStyleChangedListener(const sptr<IWindowStyleChangedListener>& listener)
729{
730    TLOGI(WmsLogTag::WMS_MAIN, "start register windowStyleChangedListener");
731    if (listener == nullptr) {
732        TLOGE(WmsLogTag::WMS_MAIN, "listener could not be null");
733        return WMError::WM_ERROR_NULLPTR;
734    }
735    {
736        std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
737        if (pImpl_->windowStyleListenerAgent_ == nullptr) {
738            pImpl_->windowStyleListenerAgent_ = new WindowManagerAgentLite();
739        }
740        auto iter = std::find(pImpl_->windowStyleListeners_.begin(), pImpl_->windowStyleListeners_.end(), listener);
741        if (iter != pImpl_->windowStyleListeners_.end()) {
742            TLOGW(WmsLogTag::WMS_MAIN, "Listener is already registered.");
743            return WMError::WM_OK;
744        }
745        pImpl_->windowStyleListeners_.push_back(listener);
746    }
747    WMError ret = WMError::WM_OK;
748    ret = SingletonContainer::Get<WindowAdapterLite>().RegisterWindowManagerAgent(
749        WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_WINDOW_STYLE, pImpl_->windowStyleListenerAgent_);
750    if (ret != WMError::WM_OK) {
751        TLOGW(WmsLogTag::WMS_MAIN, "RegisterWindowManagerAgent failed!");
752        std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
753        pImpl_->windowStyleListenerAgent_ = nullptr;
754        auto iter = std::find(pImpl_->windowStyleListeners_.begin(), pImpl_->windowStyleListeners_.end(), listener);
755        if (iter != pImpl_->windowStyleListeners_.end()) {
756            pImpl_->windowStyleListeners_.erase(iter);
757        }
758    }
759    return ret;
760}
761
762WMError WindowManagerLite::UnregisterWindowStyleChangedListener(const sptr<IWindowStyleChangedListener>& listener)
763{
764    TLOGI(WmsLogTag::WMS_MAIN, "start unregister windowStyleChangedListener");
765    if (listener == nullptr) {
766        TLOGE(WmsLogTag::WMS_MAIN, "listener could not be null");
767        return WMError::WM_ERROR_NULLPTR;
768    }
769    {
770        std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
771        auto iter = std::find(pImpl_->windowStyleListeners_.begin(), pImpl_->windowStyleListeners_.end(), listener);
772        if (iter == pImpl_->windowStyleListeners_.end()) {
773            TLOGE(WmsLogTag::WMS_MAIN, "could not find this listener");
774            return WMError::WM_OK;
775        }
776        pImpl_->windowStyleListeners_.erase(iter);
777    }
778    WMError ret = WMError::WM_OK;
779    if (pImpl_->windowStyleListeners_.empty() && pImpl_->windowStyleListenerAgent_ != nullptr) {
780        ret = SingletonContainer::Get<WindowAdapterLite>().UnregisterWindowManagerAgent(
781            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_WINDOW_STYLE, pImpl_->windowStyleListenerAgent_);
782        if (ret == WMError::WM_OK) {
783            std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
784            pImpl_->windowStyleListenerAgent_ = nullptr;
785        }
786    }
787    return ret;
788}
789
790WindowStyleType WindowManagerLite::GetWindowStyleType()
791{
792    WindowStyleType styleType;
793    if (SingletonContainer::Get<WindowAdapterLite>().GetWindowStyleType(styleType) == WMError::WM_OK) {
794        return styleType;
795    }
796    return styleType;
797}
798
799
800WMError WindowManagerLite::TerminateSessionByPersistentId(int32_t persistentId)
801{
802    if (persistentId == INVALID_SESSION_ID) {
803        TLOGE(WmsLogTag::WMS_LIFE, "persistentId is invalid.");
804        return WMError::WM_ERROR_INVALID_PARAM;
805    }
806    return SingletonContainer::Get<WindowAdapterLite>().TerminateSessionByPersistentId(persistentId);
807}
808
809WMError WindowManagerLite::CloseTargetFloatWindow(const std::string& bundleName)
810{
811    if (bundleName.empty()) {
812        TLOGE(WmsLogTag::WMS_MULTI_WINDOW, "bundleName is empty.");
813        return WMError::WM_ERROR_INVALID_PARAM;
814    }
815    return SingletonContainer::Get<WindowAdapterLite>().CloseTargetFloatWindow(bundleName);
816}
817
818WMError WindowManagerLite::RegisterPiPStateChangedListener(const sptr<IPiPStateChangedListener>& listener)
819{
820    TLOGI(WmsLogTag::WMS_PIP, "in");
821    if (listener == nullptr) {
822        TLOGE(WmsLogTag::WMS_PIP, "listener could not be null");
823        return WMError::WM_ERROR_NULLPTR;
824    }
825
826    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
827    if (pImpl_->pipStateChangedListenerAgent_ == nullptr) {
828        pImpl_->pipStateChangedListenerAgent_ = new WindowManagerAgentLite();
829    }
830    WMError ret = SingletonContainer::Get<WindowAdapterLite>().RegisterWindowManagerAgent(
831        WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_PIP, pImpl_->pipStateChangedListenerAgent_);
832    if (ret != WMError::WM_OK) {
833        TLOGW(WmsLogTag::WMS_PIP, "RegisterWindowManagerAgent failed!");
834        pImpl_->pipStateChangedListenerAgent_ = nullptr;
835    } else {
836        auto iter = std::find(pImpl_->pipStateChangedListeners_.begin(),
837            pImpl_->pipStateChangedListeners_.end(), listener);
838        if (iter != pImpl_->pipStateChangedListeners_.end()) {
839            TLOGW(WmsLogTag::WMS_PIP, "Listener is already registered.");
840            return WMError::WM_OK;
841        }
842        pImpl_->pipStateChangedListeners_.push_back(listener);
843    }
844    return ret;
845}
846
847WMError WindowManagerLite::UnregisterPiPStateChangedListener(const sptr<IPiPStateChangedListener>& listener)
848{
849    TLOGI(WmsLogTag::WMS_PIP, "in");
850    if (listener == nullptr) {
851        TLOGE(WmsLogTag::WMS_PIP, "listener could not be null");
852        return WMError::WM_ERROR_NULLPTR;
853    }
854
855    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
856    auto iter = std::find(pImpl_->pipStateChangedListeners_.begin(),
857        pImpl_->pipStateChangedListeners_.end(), listener);
858    if (iter == pImpl_->pipStateChangedListeners_.end()) {
859        TLOGE(WmsLogTag::WMS_PIP, "could not find this listener");
860        return WMError::WM_OK;
861    }
862    pImpl_->pipStateChangedListeners_.erase(iter);
863    WMError ret = WMError::WM_OK;
864    if (pImpl_->pipStateChangedListeners_.empty() &&
865        pImpl_->pipStateChangedListenerAgent_ != nullptr) {
866        ret = SingletonContainer::Get<WindowAdapterLite>().UnregisterWindowManagerAgent(
867            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_PIP,
868            pImpl_->pipStateChangedListenerAgent_);
869        if (ret == WMError::WM_OK) {
870            pImpl_->pipStateChangedListenerAgent_ = nullptr;
871        }
872    }
873    return ret;
874}
875
876WMError WindowManagerLite::CloseTargetPiPWindow(const std::string& bundleName)
877{
878    if (bundleName.empty()) {
879        TLOGE(WmsLogTag::WMS_PIP, "bundleName is empty.");
880        return WMError::WM_ERROR_INVALID_PARAM;
881    }
882    TLOGD(WmsLogTag::WMS_PIP, "bundleName:%{public}s", bundleName.c_str());
883    return SingletonContainer::Get<WindowAdapterLite>().CloseTargetPiPWindow(bundleName);
884}
885
886WMError WindowManagerLite::GetCurrentPiPWindowInfo(std::string& bundleName)
887{
888    return SingletonContainer::Get<WindowAdapterLite>().GetCurrentPiPWindowInfo(bundleName);
889}
890
891void WindowManagerLite::UpdatePiPWindowStateChanged(const std::string& bundleName, bool isForeground) const
892{
893    pImpl_->UpdatePiPWindowStateChanged(bundleName, isForeground);
894}
895
896WMError WindowManagerLite::GetAccessibilityWindowInfo(std::vector<sptr<AccessibilityWindowInfo>>& infos) const
897{
898    WMError ret = SingletonContainer::Get<WindowAdapterLite>().GetAccessibilityWindowInfo(infos);
899    if (ret != WMError::WM_OK) {
900        WLOGFE("get window info failed");
901    }
902    return ret;
903}
904
905WMError WindowManagerLite::RegisterWindowUpdateListener(const sptr<IWindowUpdateListener>& listener)
906{
907    if (listener == nullptr) {
908        WLOGFE("listener could not be null");
909        return WMError::WM_ERROR_NULLPTR;
910    }
911    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
912    if (pImpl_->windowUpdateListenerAgent_ == nullptr) {
913        pImpl_->windowUpdateListenerAgent_ = new WindowManagerAgentLite();
914    }
915    WMError ret = SingletonContainer::Get<WindowAdapterLite>().RegisterWindowManagerAgent(
916        WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_WINDOW_UPDATE, pImpl_->windowUpdateListenerAgent_);
917    if (ret != WMError::WM_OK) {
918        WLOGFW("RegisterWindowManagerAgent failed!");
919        pImpl_->windowUpdateListenerAgent_ = nullptr;
920    } else {
921        auto iter = std::find(pImpl_->windowUpdateListeners_.begin(), pImpl_->windowUpdateListeners_.end(), listener);
922        if (iter != pImpl_->windowUpdateListeners_.end()) {
923            WLOGI("Listener is already registered.");
924            return WMError::WM_OK;
925        }
926        pImpl_->windowUpdateListeners_.emplace_back(listener);
927    }
928    return ret;
929}
930
931WMError WindowManagerLite::UnregisterWindowUpdateListener(const sptr<IWindowUpdateListener>& listener)
932{
933    if (listener == nullptr) {
934        WLOGFE("listener could not be null");
935        return WMError::WM_ERROR_NULLPTR;
936    }
937    std::lock_guard<std::recursive_mutex> lock(pImpl_->mutex_);
938    auto iter = std::find(pImpl_->windowUpdateListeners_.begin(), pImpl_->windowUpdateListeners_.end(), listener);
939    if (iter == pImpl_->windowUpdateListeners_.end()) {
940        WLOGFE("could not find this listener");
941        return WMError::WM_OK;
942    }
943    pImpl_->windowUpdateListeners_.erase(iter);
944    WMError ret = WMError::WM_OK;
945    if (pImpl_->windowUpdateListeners_.empty() && pImpl_->windowUpdateListenerAgent_ != nullptr) {
946        ret = SingletonContainer::Get<WindowAdapterLite>().UnregisterWindowManagerAgent(
947            WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_WINDOW_UPDATE, pImpl_->windowUpdateListenerAgent_);
948        if (ret == WMError::WM_OK) {
949            pImpl_->windowUpdateListenerAgent_ = nullptr;
950        }
951    }
952    return ret;
953}
954} // namespace Rosen
955} // namespace OHOS
956