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 "drag_manager_impl.h"
17
18 #include "devicestatus_client.h"
19 #include "devicestatus_define.h"
20 #include "drag_data.h"
21 #include "drag_data_packer.h"
22
23 #undef LOG_TAG
24 #define LOG_TAG "DragManagerImpl"
25
26 namespace OHOS {
27 namespace Msdp {
28 namespace DeviceStatus {
29
UpdateDragStyle(DragCursorStyle style)30 int32_t DragManagerImpl::UpdateDragStyle(DragCursorStyle style)
31 {
32 CALL_DEBUG_ENTER;
33 if ((style < DragCursorStyle::DEFAULT) || (style > DragCursorStyle::MOVE)) {
34 FI_HILOGE("Invalid style:%{public}d", static_cast<int32_t>(style));
35 return RET_ERR;
36 }
37 FI_HILOGD("Ready to modify the style(%{public}d)", static_cast<int32_t>(style));
38 return DeviceStatusClient::GetInstance().UpdateDragStyle(style);
39 }
40
StartDrag(const DragData & dragData,std::shared_ptr<IStartDragListener> listener)41 int32_t DragManagerImpl::StartDrag(const DragData &dragData, std::shared_ptr<IStartDragListener> listener)
42 {
43 CALL_DEBUG_ENTER;
44 CHKPR(listener, RET_ERR);
45 if (DragDataPacker::CheckDragData(dragData) != RET_OK) {
46 FI_HILOGE("CheckDragData failed");
47 return RET_ERR;
48 }
49 {
50 std::lock_guard<std::mutex> guard(mtx_);
51 startDragListener_ = listener;
52 }
53 return DeviceStatusClient::GetInstance().StartDrag(dragData);
54 }
55
StopDrag(const DragDropResult & dropResult)56 int32_t DragManagerImpl::StopDrag(const DragDropResult &dropResult)
57 {
58 CALL_DEBUG_ENTER;
59 return DeviceStatusClient::GetInstance().StopDrag(dropResult);
60 }
61
GetDragTargetPid()62 int32_t DragManagerImpl::GetDragTargetPid()
63 {
64 CALL_DEBUG_ENTER;
65 return DeviceStatusClient::GetInstance().GetDragTargetPid();
66 }
67
GetUdKey(std::string & udKey)68 int32_t DragManagerImpl::GetUdKey(std::string &udKey)
69 {
70 CALL_DEBUG_ENTER;
71 return DeviceStatusClient::GetInstance().GetUdKey(udKey);
72 }
73
OnNotifyResult(const StreamClient & client,NetPacket & pkt)74 int32_t DragManagerImpl::OnNotifyResult(const StreamClient &client, NetPacket &pkt)
75 {
76 CALL_DEBUG_ENTER;
77 DragNotifyMsg notifyMsg;
78 int32_t result = 0;
79 int32_t dragBehavior = -1;
80 pkt >> notifyMsg.displayX >> notifyMsg.displayY >> result >> notifyMsg.targetPid >> dragBehavior;
81 if (pkt.ChkRWError()) {
82 FI_HILOGE("Packet read drag msg failed");
83 return RET_ERR;
84 }
85 if ((result < static_cast<int32_t>(DragResult::DRAG_SUCCESS)) ||
86 (result > static_cast<int32_t>(DragResult::DRAG_EXCEPTION))) {
87 FI_HILOGE("Invalid result:%{public}d", result);
88 return RET_ERR;
89 }
90 notifyMsg.result = static_cast<DragResult>(result);
91 if ((dragBehavior < static_cast<int32_t>(DragBehavior::UNKNOWN)) ||
92 (dragBehavior > static_cast<int32_t>(DragBehavior::MOVE))) {
93 FI_HILOGE("Invalid dragBehavior:%{public}d", dragBehavior);
94 return RET_ERR;
95 }
96 notifyMsg.dragBehavior = static_cast<DragBehavior>(dragBehavior);
97 std::lock_guard<std::mutex> guard(mtx_);
98 CHKPR(startDragListener_, RET_ERR);
99 startDragListener_->OnDragEndMessage(notifyMsg);
100 return RET_OK;
101 }
102
OnNotifyHideIcon(const StreamClient & client,NetPacket & pkt)103 int32_t DragManagerImpl::OnNotifyHideIcon(const StreamClient& client, NetPacket& pkt)
104 {
105 CALL_DEBUG_ENTER;
106 std::lock_guard<std::mutex> guard(mtx_);
107 CHKPR(startDragListener_, RET_ERR);
108 startDragListener_->OnHideIconMessage();
109 return RET_OK;
110 }
111
OnStateChangedMessage(const StreamClient & client,NetPacket & pkt)112 int32_t DragManagerImpl::OnStateChangedMessage(const StreamClient &client, NetPacket &pkt)
113 {
114 CALL_DEBUG_ENTER;
115 int32_t state = 0;
116 pkt >> state;
117 if (pkt.ChkRWError()) {
118 FI_HILOGE("Packet read drag msg failed");
119 return RET_ERR;
120 }
121 std::lock_guard<std::mutex> guard(mtx_);
122 for (const auto &listener : dragListener_) {
123 CHKPR(listener, RET_ERR);
124 listener->OnDragMessage(static_cast<DragState>(state));
125 }
126 return RET_OK;
127 }
128
OnDragStyleChangedMessage(const StreamClient & client,NetPacket & pkt)129 int32_t DragManagerImpl::OnDragStyleChangedMessage(const StreamClient &client, NetPacket &pkt)
130 {
131 CALL_DEBUG_ENTER;
132 int32_t style = 0;
133 pkt >> style;
134 if (pkt.ChkRWError()) {
135 FI_HILOGE("Packet read drag msg failed");
136 return RET_ERR;
137 }
138 std::lock_guard<std::mutex> guard(mtx_);
139 for (const auto &listener : subscriptListener_) {
140 CHKPR(listener, RET_ERR);
141 listener->OnMessage(static_cast<DragCursorStyle>(style));
142 }
143 return RET_OK;
144 }
145
AddDraglistener(DragListenerPtr listener)146 int32_t DragManagerImpl::AddDraglistener(DragListenerPtr listener)
147 {
148 CALL_INFO_TRACE;
149 CHKPR(listener, RET_ERR);
150 std::lock_guard<std::mutex> guard(mtx_);
151 if (!hasRegistered_) {
152 FI_HILOGI("Start monitoring");
153 int32_t ret = DeviceStatusClient::GetInstance().AddDraglistener();
154 if (ret != RET_OK) {
155 FI_HILOGE("Failed to register draglistener");
156 return ret;
157 }
158 hasRegistered_ = true;
159 }
160 if (std::all_of(dragListener_.cbegin(), dragListener_.cend(),
161 [listener](DragListenerPtr tListener) {
162 return (tListener != listener);
163 })) {
164 dragListener_.push_back(listener);
165 } else {
166 FI_HILOGW("The draglistener already exists");
167 }
168 return RET_OK;
169 }
170
RemoveDraglistener(DragListenerPtr listener)171 int32_t DragManagerImpl::RemoveDraglistener(DragListenerPtr listener)
172 {
173 CALL_INFO_TRACE;
174 std::lock_guard<std::mutex> guard(mtx_);
175 if (listener == nullptr) {
176 dragListener_.clear();
177 } else {
178 dragListener_.erase(std::remove_if(dragListener_.begin(), dragListener_.end(),
179 [listener] (auto lIter) {
180 return lIter == listener;
181 })
182 );
183 }
184
185 if (hasRegistered_ && dragListener_.empty()) {
186 hasRegistered_ = false;
187 return DeviceStatusClient::GetInstance().RemoveDraglistener();
188 }
189 return RET_OK;
190 }
191
AddSubscriptListener(SubscriptListenerPtr listener)192 int32_t DragManagerImpl::AddSubscriptListener(SubscriptListenerPtr listener)
193 {
194 CALL_INFO_TRACE;
195 CHKPR(listener, RET_ERR);
196 std::lock_guard<std::mutex> guard(mtx_);
197 if (!hasSubscriptRegistered_) {
198 FI_HILOGI("Start monitoring");
199 int32_t ret = DeviceStatusClient::GetInstance().AddSubscriptListener();
200 if (ret != RET_OK) {
201 FI_HILOGE("Failed to register");
202 return ret;
203 }
204 hasSubscriptRegistered_ = true;
205 }
206 if (std::all_of(subscriptListener_.cbegin(), subscriptListener_.cend(),
207 [listener](SubscriptListenerPtr tListener) {
208 return (tListener != listener);
209 })) {
210 subscriptListener_.push_back(listener);
211 } else {
212 FI_HILOGW("The listener already exists");
213 }
214 return RET_OK;
215 }
216
RemoveSubscriptListener(SubscriptListenerPtr listener)217 int32_t DragManagerImpl::RemoveSubscriptListener(SubscriptListenerPtr listener)
218 {
219 CALL_INFO_TRACE;
220 std::lock_guard<std::mutex> guard(mtx_);
221 if (listener == nullptr) {
222 subscriptListener_.clear();
223 } else {
224 subscriptListener_.erase(std::remove_if(subscriptListener_.begin(), subscriptListener_.end(),
225 [listener] (auto iter) {
226 return iter == listener;
227 })
228 );
229 }
230
231 if (hasSubscriptRegistered_ && subscriptListener_.empty()) {
232 hasSubscriptRegistered_ = false;
233 return DeviceStatusClient::GetInstance().RemoveSubscriptListener();
234 }
235 return RET_OK;
236 }
237
SetDragWindowVisible(bool visible,bool isForce)238 int32_t DragManagerImpl::SetDragWindowVisible(bool visible, bool isForce)
239 {
240 CALL_DEBUG_ENTER;
241 return DeviceStatusClient::GetInstance().SetDragWindowVisible(visible, isForce);
242 }
243
GetShadowOffset(ShadowOffset & shadowOffset)244 int32_t DragManagerImpl::GetShadowOffset(ShadowOffset &shadowOffset)
245 {
246 CALL_DEBUG_ENTER;
247 return DeviceStatusClient::GetInstance().GetShadowOffset(shadowOffset);
248 }
249
UpdateShadowPic(const ShadowInfo & shadowInfo)250 int32_t DragManagerImpl::UpdateShadowPic(const ShadowInfo &shadowInfo)
251 {
252 CALL_DEBUG_ENTER;
253 if (ShadowPacker::CheckShadowInfo(shadowInfo) != RET_OK) {
254 FI_HILOGE("CheckShadowInfo failed");
255 return RET_ERR;
256 }
257 return DeviceStatusClient::GetInstance().UpdateShadowPic(shadowInfo);
258 }
259
GetDragData(DragData & dragData)260 int32_t DragManagerImpl::GetDragData(DragData &dragData)
261 {
262 CALL_DEBUG_ENTER;
263 return DeviceStatusClient::GetInstance().GetDragData(dragData);
264 }
265
GetDragState(DragState & dragState)266 int32_t DragManagerImpl::GetDragState(DragState &dragState)
267 {
268 CALL_DEBUG_ENTER;
269 return DeviceStatusClient::GetInstance().GetDragState(dragState);
270 }
271
UpdatePreviewStyle(const PreviewStyle & previewStyle)272 int32_t DragManagerImpl::UpdatePreviewStyle(const PreviewStyle &previewStyle)
273 {
274 return DeviceStatusClient::GetInstance().UpdatePreviewStyle(previewStyle);
275 }
276
UpdatePreviewStyleWithAnimation(const PreviewStyle & previewStyle,const PreviewAnimation & animation)277 int32_t DragManagerImpl::UpdatePreviewStyleWithAnimation(const PreviewStyle &previewStyle,
278 const PreviewAnimation &animation)
279 {
280 return DeviceStatusClient::GetInstance().UpdatePreviewStyleWithAnimation(previewStyle, animation);
281 }
282
GetDragSummary(std::map<std::string,int64_t> & summarys)283 int32_t DragManagerImpl::GetDragSummary(std::map<std::string, int64_t> &summarys)
284 {
285 CALL_DEBUG_ENTER;
286 return DeviceStatusClient::GetInstance().GetDragSummary(summarys);
287 }
288
GetDragAction(DragAction & dragAction)289 int32_t DragManagerImpl::GetDragAction(DragAction &dragAction)
290 {
291 return DeviceStatusClient::GetInstance().GetDragAction(dragAction);
292 }
293
EnterTextEditorArea(bool enable)294 int32_t DragManagerImpl::EnterTextEditorArea(bool enable)
295 {
296 return DeviceStatusClient::GetInstance().EnterTextEditorArea(enable);
297 }
298
GetExtraInfo(std::string & extraInfo)299 int32_t DragManagerImpl::GetExtraInfo(std::string &extraInfo)
300 {
301 return DeviceStatusClient::GetInstance().GetExtraInfo(extraInfo);
302 }
303
AddPrivilege()304 int32_t DragManagerImpl::AddPrivilege()
305 {
306 return DeviceStatusClient::GetInstance().AddPrivilege();
307 }
308
EraseMouseIcon()309 int32_t DragManagerImpl::EraseMouseIcon()
310 {
311 return DeviceStatusClient::GetInstance().EraseMouseIcon();
312 }
313 } // namespace DeviceStatus
314 } // namespace Msdp
315 } // namespace OHOS
316