1 /*
2 * Copyright (c) 2021-2022 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 "frameworks/bridge/declarative_frontend/engine/functions/js_drag_function.h"
17
18 #include "base/log/log.h"
19 #include "frameworks/bridge/declarative_frontend/jsview/js_utils.h"
20 #include "frameworks/bridge/declarative_frontend/jsview/js_view_register.h"
21
22 #include "js_native_api_types.h"
23 #include "napi/native_api.h"
24 #include "native_engine/native_engine.h"
25 #include "native_engine/native_value.h"
26
27 #include "core/common/udmf/udmf_client.h"
28 #include "frameworks/bridge/common/utils/engine_helper.h"
29 #include "frameworks/bridge/declarative_frontend/engine/js_converter.h"
30 #include "frameworks/bridge/declarative_frontend/engine/js_types.h"
31 #include "frameworks/bridge/declarative_frontend/engine/jsi/nativeModule/arkts_utils.h"
32 #include "frameworks/bridge/js_frontend/engine/common/js_engine.h"
33
34 namespace OHOS::Ace::Framework {
35 namespace {
NapiThrow(const RefPtr<Framework::JsEngine> & engine,int32_t errCode,const std::string & message)36 void NapiThrow(const RefPtr<Framework::JsEngine>& engine, int32_t errCode, const std::string& message)
37 {
38 NativeEngine* nativeEngine = engine->GetNativeEngine();
39 napi_env env = reinterpret_cast<napi_env>(nativeEngine);
40 napi_value code = nullptr;
41 std::string strCode = std::to_string(errCode);
42 napi_create_string_utf8(env, strCode.c_str(), strCode.length(), &code);
43 napi_value msg = nullptr;
44 napi_create_string_utf8(env, message.c_str(), message.length(), &msg);
45 napi_value error = nullptr;
46 napi_create_error(env, code, msg, &error);
47 napi_throw(env, error);
48 }
49
50 } // namespace
51
52 class JsPasteData : public Referenced {
53 public:
JSBind(BindingTarget globalObj)54 static void JSBind(BindingTarget globalObj)
55 {
56 JSClass<JsPasteData>::Declare("PasteData");
57 JSClass<JsPasteData>::CustomMethod("setPlainText", &JsPasteData::SetPlainText);
58 JSClass<JsPasteData>::CustomMethod("getPlainText", &JsPasteData::GetPlainText);
59 JSClass<JsPasteData>::Bind(globalObj, &JsPasteData::Constructor, &JsPasteData::Destructor);
60 }
61
SetPlainText(const JSCallbackInfo & args)62 void SetPlainText(const JSCallbackInfo& args)
63 {
64 if (args[0]->IsString()) {
65 pasteData_->SetPlainText(args[0]->ToString());
66 }
67 }
68
GetPlainText(const JSCallbackInfo & args)69 void GetPlainText(const JSCallbackInfo& args)
70 {
71 auto plainText = JSVal(ToJSValue(pasteData_->GetPlainText()));
72 auto plainTextRef = JSRef<JSVal>::Make(plainText);
73 args.SetReturnValue(plainTextRef);
74 }
75
SetPasteData(const RefPtr<PasteData> & pasteData)76 void SetPasteData(const RefPtr<PasteData>& pasteData)
77 {
78 pasteData_ = pasteData;
79 }
80
GetPasteData() const81 RefPtr<PasteData> GetPasteData() const
82 {
83 return pasteData_;
84 }
85
86 private:
Constructor(const JSCallbackInfo & args)87 static void Constructor(const JSCallbackInfo& args)
88 {
89 auto jsPasteData = Referenced::MakeRefPtr<JsPasteData>();
90 jsPasteData->IncRefCount();
91 args.SetReturnValue(Referenced::RawPtr(jsPasteData));
92 }
93
Destructor(JsPasteData * jsPasteData)94 static void Destructor(JsPasteData* jsPasteData)
95 {
96 if (jsPasteData != nullptr) {
97 jsPasteData->DecRefCount();
98 }
99 }
100
101 RefPtr<PasteData> pasteData_;
102 };
103
JSBind(BindingTarget globalObj)104 void JsDragEvent::JSBind(BindingTarget globalObj)
105 {
106 JSClass<JsDragEvent>::Declare("DragEvent");
107 JSClass<JsDragEvent>::CustomMethod("getPasteData", &JsDragEvent::GetJsPasteData);
108 JSClass<JsDragEvent>::CustomMethod("getDisplayX", &JsDragEvent::GetScreenX);
109 JSClass<JsDragEvent>::CustomMethod("getDisplayY", &JsDragEvent::GetScreenY);
110 JSClass<JsDragEvent>::CustomMethod("getWindowX", &JsDragEvent::GetX);
111 JSClass<JsDragEvent>::CustomMethod("getWindowY", &JsDragEvent::GetY);
112 JSClass<JsDragEvent>::CustomMethod("getX", &JsDragEvent::GetX);
113 JSClass<JsDragEvent>::CustomMethod("getY", &JsDragEvent::GetY);
114 JSClass<JsDragEvent>::CustomMethod("getDescription", &JsDragEvent::GetDescription);
115 JSClass<JsDragEvent>::CustomMethod("setDescription", &JsDragEvent::SetDescription);
116 JSClass<JsDragEvent>::CustomMethod("setData", &JsDragEvent::SetData);
117 JSClass<JsDragEvent>::CustomMethod("getData", &JsDragEvent::GetData);
118 JSClass<JsDragEvent>::CustomMethod("getSummary", &JsDragEvent::GetSummary);
119 JSClass<JsDragEvent>::CustomMethod("setResult", &JsDragEvent::SetResult);
120 JSClass<JsDragEvent>::CustomMethod("getResult", &JsDragEvent::GetResult);
121 JSClass<JsDragEvent>::CustomMethod("getPreviewRect", &JsDragEvent::GetPreviewRect);
122 JSClass<JsDragEvent>::CustomProperty(
123 "useCustomDropAnimation", &JsDragEvent::GetUseCustomDropAnimation, &JsDragEvent::SetUseCustomDropAnimation);
124 JSClass<JsDragEvent>::CustomMethod("setDragInfo", &JsDragEvent::SetDragInfo);
125 JSClass<JsDragEvent>::CustomMethod("getDragInfo", &JsDragEvent::GetDragInfo);
126 JSClass<JsDragEvent>::CustomProperty("dragBehavior", &JsDragEvent::GetDragBehavior, &JsDragEvent::SetDragBehavior);
127 JSClass<JsDragEvent>::CustomMethod("getVelocityX", &JsDragEvent::GetVelocityX);
128 JSClass<JsDragEvent>::CustomMethod("getVelocityY", &JsDragEvent::GetVelocityY);
129 JSClass<JsDragEvent>::CustomMethod("getVelocity", &JsDragEvent::GetVelocity);
130 JSClass<JsDragEvent>::CustomMethod("getModifierKeyState", &JsDragEvent::GetModifierKeyState);
131 JSClass<JsDragEvent>::CustomMethod("startDataLoading", &JsDragEvent::StartDataLoading);
132 JSClass<JsDragEvent>::Bind(globalObj, &JsDragEvent::Constructor, &JsDragEvent::Destructor);
133 }
134
SetJsPasteData(const JSRef<JSObject> & jsPasteData)135 void JsDragEvent::SetJsPasteData(const JSRef<JSObject>& jsPasteData)
136 {
137 jsPasteData_ = jsPasteData;
138 }
139
GetJsPasteData(const JSCallbackInfo & args)140 void JsDragEvent::GetJsPasteData(const JSCallbackInfo& args)
141 {
142 args.SetReturnValue(jsPasteData_);
143 }
144
GetScreenX(const JSCallbackInfo & args)145 void JsDragEvent::GetScreenX(const JSCallbackInfo& args)
146 {
147 auto xValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetScreenX())));
148 auto xValueRef = JSRef<JSVal>::Make(xValue);
149 args.SetReturnValue(xValueRef);
150 }
151
GetScreenY(const JSCallbackInfo & args)152 void JsDragEvent::GetScreenY(const JSCallbackInfo& args)
153 {
154 auto yValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetScreenY())));
155 auto yValueRef = JSRef<JSVal>::Make(yValue);
156 args.SetReturnValue(yValueRef);
157 }
158
GetX(const JSCallbackInfo & args)159 void JsDragEvent::GetX(const JSCallbackInfo& args)
160 {
161 auto xValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetX())));
162 auto xValueRef = JSRef<JSVal>::Make(xValue);
163 args.SetReturnValue(xValueRef);
164 }
165
GetY(const JSCallbackInfo & args)166 void JsDragEvent::GetY(const JSCallbackInfo& args)
167 {
168 auto yValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetY())));
169 auto yValueRef = JSRef<JSVal>::Make(yValue);
170 args.SetReturnValue(yValueRef);
171 }
172
GetDescription(const JSCallbackInfo & args)173 void JsDragEvent::GetDescription(const JSCallbackInfo& args)
174 {
175 auto description = JSVal(ToJSValue(dragEvent_->GetDescription()));
176 auto descriptionRef = JSRef<JSVal>::Make(description);
177 args.SetReturnValue(descriptionRef);
178 }
179
SetDescription(const JSCallbackInfo & args)180 void JsDragEvent::SetDescription(const JSCallbackInfo& args)
181 {
182 if (args[0]->IsString()) {
183 dragEvent_->SetDescription(args[0]->ToString());
184 }
185 }
186
SetData(const JSCallbackInfo & args)187 void JsDragEvent::SetData(const JSCallbackInfo& args)
188 {
189 if (!args[0]->IsObject()) {
190 return;
191 }
192 auto engine = EngineHelper::GetCurrentEngine();
193 CHECK_NULL_VOID(engine);
194 NativeEngine* nativeEngine = engine->GetNativeEngine();
195 panda::Local<JsiValue> value = args[0].Get().GetLocalHandle();
196 JSValueWrapper valueWrapper = value;
197 ScopeRAII scope(reinterpret_cast<napi_env>(nativeEngine));
198 napi_value nativeValue = nativeEngine->ValueToNapiValue(valueWrapper);
199 RefPtr<UnifiedData> udData = UdmfClient::GetInstance()->TransformUnifiedData(nativeValue);
200 CHECK_NULL_VOID(udData);
201 dragEvent_->SetData(udData);
202 }
203
StartDataLoading(const JSCallbackInfo & args)204 void JsDragEvent::StartDataLoading(const JSCallbackInfo& args)
205 {
206 if (!args[0]->IsObject()) {
207 return;
208 }
209 auto engine = EngineHelper::GetCurrentEngine();
210 CHECK_NULL_VOID(engine);
211 std::string udKey = dragEvent_->GetUdKey();
212 if (udKey.empty()) {
213 args.SetReturnValue(JSVal::Undefined());
214 NapiThrow(engine, ERROR_CODE_DRAG_DATA_NOT_ONDROP, "Operation no allowed for current pharse.");
215 return;
216 }
217 NativeEngine* nativeEngine = engine->GetNativeEngine();
218 panda::Local<JsiValue> value = args[0].Get().GetLocalHandle();
219 JSValueWrapper valueWrapper = value;
220 napi_env env = reinterpret_cast<napi_env>(nativeEngine);
221 ScopeRAII scope(env);
222 napi_value nativeValue = nativeEngine->ValueToNapiValue(valueWrapper);
223 auto status = UdmfClient::GetInstance()->StartAsyncDataRetrieval(env, nativeValue, udKey);
224 if (status != 0) {
225 args.SetReturnValue(JSVal::Undefined());
226 napi_value result;
227 napi_get_and_clear_last_exception(env, &result);
228 NapiThrow(engine, ERROR_CODE_PARAM_INVALID, "Invalid input parameter.");
229 return;
230 }
231 auto jsUdKey = JSVal(ToJSValue(udKey));
232 auto jsUdKeyRef = JSRef<JSVal>::Make(jsUdKey);
233 args.SetReturnValue(jsUdKeyRef);
234 }
235
GetData(const JSCallbackInfo & args)236 void JsDragEvent::GetData(const JSCallbackInfo& args)
237 {
238 auto dragData = dragEvent_->GetData();
239 if (!dragEvent_->IsGetDataSuccess()) {
240 TAG_LOGI(AceLogTag::ACE_DRAG, "UDMF GetData failed in first attempt");
241 std::string udKey = dragEvent_->GetUdKey();
242 if (udKey.empty()) {
243 args.SetReturnValue(JSVal::Undefined());
244 return;
245 }
246 int ret = UdmfClient::GetInstance()->GetData(dragData, udKey);
247 if (ret != 0) {
248 TAG_LOGW(AceLogTag::ACE_DRAG, "UDMF GetData failed: %{public}d", ret);
249 auto engine = EngineHelper::GetCurrentEngine();
250 if (!engine) {
251 args.SetReturnValue(JSVal::Undefined());
252 return;
253 }
254 auto errorInfo = UdmfClient::GetInstance()->GetErrorInfo(ret);
255 NapiThrow(engine, errorInfo.first, errorInfo.second);
256 return;
257 } else {
258 dragEvent_->SetData(dragData);
259 dragEvent_->SetIsGetDataSuccess(true);
260 }
261 }
262 CHECK_NULL_VOID(dragData);
263 napi_value nativeValue = UdmfClient::GetInstance()->TransformUdmfUnifiedData(dragData);
264 CHECK_NULL_VOID(nativeValue);
265 auto jsValue = JsConverter::ConvertNapiValueToJsVal(nativeValue);
266 args.SetReturnValue(jsValue);
267 }
268
GetSummary(const JSCallbackInfo & args)269 void JsDragEvent::GetSummary(const JSCallbackInfo& args)
270 {
271 auto engine = EngineHelper::GetCurrentEngine();
272 CHECK_NULL_VOID(engine);
273 auto summary = dragEvent_->GetSummary();
274 napi_value nativeValue = UdmfClient::GetInstance()->TransformSummary(summary);
275 CHECK_NULL_VOID(nativeValue);
276 auto jsValue = JsConverter::ConvertNapiValueToJsVal(nativeValue);
277 args.SetReturnValue(jsValue);
278 }
279
SetResult(const JSCallbackInfo & args)280 void JsDragEvent::SetResult(const JSCallbackInfo& args)
281 {
282 if (args[0]->IsNumber()) {
283 auto dragRet = args[0]->ToNumber<int32_t>();
284 dragEvent_->SetResult((DragRet)dragRet);
285 }
286 }
287
GetResult(const JSCallbackInfo & args)288 void JsDragEvent::GetResult(const JSCallbackInfo& args)
289 {
290 CHECK_NULL_VOID(dragEvent_);
291 auto dragRet = JSVal(ToJSValue(static_cast<int32_t>(dragEvent_->GetResult())));
292 auto dragRetRef = JSRef<JSVal>::Make(dragRet);
293 args.SetReturnValue(dragRetRef);
294 }
295
GetPreviewRect(const JSCallbackInfo & args)296 void JsDragEvent::GetPreviewRect(const JSCallbackInfo& args)
297 {
298 auto rectObj = CreateRectangle(dragEvent_->GetPreviewRect());
299 JSRef<JSVal> previewRect = JSRef<JSObject>::Cast(rectObj);
300 args.SetReturnValue(previewRect);
301 }
302
SetUseCustomDropAnimation(const JSCallbackInfo & args)303 void JsDragEvent::SetUseCustomDropAnimation(const JSCallbackInfo& args)
304 {
305 if (args[0]->IsBoolean()) {
306 dragEvent_->UseCustomAnimation(args[0]->ToBoolean());
307 }
308 }
309
GetUseCustomDropAnimation(const JSCallbackInfo & args)310 void JsDragEvent::GetUseCustomDropAnimation(const JSCallbackInfo& args)
311 {
312 auto useCustomAnimation = JSVal(ToJSValue(dragEvent_->IsUseCustomAnimation()));
313 auto useCustomAnimationRef = JSRef<JSVal>::Make(useCustomAnimation);
314 args.SetReturnValue(useCustomAnimationRef);
315 }
316
SetDragInfo(const JSCallbackInfo & args)317 void JsDragEvent::SetDragInfo(const JSCallbackInfo& args)
318 {
319 if (!args[0]->IsObject()) {
320 return;
321 }
322 auto engine = EngineHelper::GetCurrentEngine();
323 CHECK_NULL_VOID(engine);
324 NativeEngine* nativeEngine = engine->GetNativeEngine();
325 panda::Local<JsiValue> value = args[0].Get().GetLocalHandle();
326 JSValueWrapper valueWrapper = value;
327 ScopeRAII scope(reinterpret_cast<napi_env>(nativeEngine));
328 napi_value nativeValue = nativeEngine->ValueToNapiValue(valueWrapper);
329 RefPtr<UnifiedData> udData = UdmfClient::GetInstance()->TransformUnifiedData(nativeValue);
330 CHECK_NULL_VOID(udData);
331 dragEvent_->SetData(udData);
332 }
333
GetDragInfo(const JSCallbackInfo & args)334 void JsDragEvent::GetDragInfo(const JSCallbackInfo& args)
335 {
336 auto dragData = dragEvent_->GetDragInfo();
337 CHECK_NULL_VOID(dragData);
338 napi_value nativeValue = UdmfClient::GetInstance()->TransformUdmfUnifiedData(dragData);
339 CHECK_NULL_VOID(nativeValue);
340 auto jsValue = JsConverter::ConvertNapiValueToJsVal(nativeValue);
341 args.SetReturnValue(jsValue);
342 }
343
convertDragBehavior(int32_t dragBehavior)344 OHOS::Ace::DragBehavior convertDragBehavior(int32_t dragBehavior)
345 {
346 switch (dragBehavior) {
347 case 0:
348 return OHOS::Ace::DragBehavior::COPY;
349 case 1:
350 return OHOS::Ace::DragBehavior::MOVE;
351 default:
352 return OHOS::Ace::DragBehavior::UNKNOWN;
353 }
354 }
355
SetDragBehavior(const JSCallbackInfo & args)356 void JsDragEvent::SetDragBehavior(const JSCallbackInfo& args)
357 {
358 if (args[0]->IsNumber()) {
359 dragEvent_->SetCopy(!static_cast<bool>(args[0]->ToNumber<int32_t>()));
360 dragEvent_->SetDragBehavior(convertDragBehavior(args[0]->ToNumber<int32_t>()));
361 }
362 }
363
GetDragBehavior(const JSCallbackInfo & args)364 void JsDragEvent::GetDragBehavior(const JSCallbackInfo& args)
365 {
366 auto dragBehavior = JSVal(ToJSValue(static_cast<int32_t>(
367 dragEvent_->GetDragBehavior() == OHOS::Ace::DragBehavior::MOVE ? OHOS::Ace::DragBehavior::MOVE
368 : OHOS::Ace::DragBehavior::COPY)));
369 auto dragBehaviorRef = JSRef<JSVal>::Make(dragBehavior);
370 args.SetReturnValue(dragBehaviorRef);
371 }
372
GetVelocityX(const JSCallbackInfo & args)373 void JsDragEvent::GetVelocityX(const JSCallbackInfo& args)
374 {
375 auto jsValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetVelocity().GetVelocityX())));
376 auto jsValueRef = JSRef<JSVal>::Make(jsValue);
377 args.SetReturnValue(jsValueRef);
378 }
379
GetVelocityY(const JSCallbackInfo & args)380 void JsDragEvent::GetVelocityY(const JSCallbackInfo& args)
381 {
382 auto jsValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetVelocity().GetVelocityY())));
383 auto jsValueRef = JSRef<JSVal>::Make(jsValue);
384 args.SetReturnValue(jsValueRef);
385 }
386
GetVelocity(const JSCallbackInfo & args)387 void JsDragEvent::GetVelocity(const JSCallbackInfo& args)
388 {
389 auto jsValue = JSVal(
390 ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetVelocity().GetVelocityValue())));
391 auto jsValueRef = JSRef<JSVal>::Make(jsValue);
392 args.SetReturnValue(jsValueRef);
393 }
394
GetModifierKeyState(const JSCallbackInfo & args)395 void JsDragEvent::GetModifierKeyState(const JSCallbackInfo& args)
396 {
397 bool ret = false;
398 auto keyState = NG::ArkTSUtils::GetModifierKeyState(args.GetJsiRuntimeCallInfo(),
399 dragEvent_->GetPressedKeyCodes());
400 if (keyState->IsTrue()) {
401 ret = true;
402 }
403
404 auto jsValueRef = JSRef<JSVal>::Make(ToJSValue(ret));
405 args.SetReturnValue(jsValueRef);
406 }
407
Constructor(const JSCallbackInfo & args)408 void JsDragEvent::Constructor(const JSCallbackInfo& args)
409 {
410 auto dragEvent = Referenced::MakeRefPtr<JsDragEvent>();
411 CHECK_NULL_VOID(dragEvent);
412 dragEvent->IncRefCount();
413 args.SetReturnValue(Referenced::RawPtr(dragEvent));
414 }
415
Destructor(JsDragEvent * dragEvent)416 void JsDragEvent::Destructor(JsDragEvent* dragEvent)
417 {
418 if (dragEvent != nullptr) {
419 dragEvent->DecRefCount();
420 }
421 }
422
CreateRectangle(const Rect & info)423 JSRef<JSObject> JsDragEvent::CreateRectangle(const Rect& info)
424 {
425 JSRef<JSObject> rectObj = JSRef<JSObject>::New();
426 rectObj->SetProperty<double>("x", PipelineBase::Px2VpWithCurrentDensity(info.Left()));
427 rectObj->SetProperty<double>("y", PipelineBase::Px2VpWithCurrentDensity(info.Top()));
428 rectObj->SetProperty<double>("width", PipelineBase::Px2VpWithCurrentDensity(info.Width()));
429 rectObj->SetProperty<double>("height", PipelineBase::Px2VpWithCurrentDensity(info.Height()));
430 return rectObj;
431 }
432
JSBind(BindingTarget globalObj)433 void JsDragFunction::JSBind(BindingTarget globalObj)
434 {
435 JsPasteData::JSBind(globalObj);
436 JsDragEvent::JSBind(globalObj);
437 }
438
Execute()439 void JsDragFunction::Execute()
440 {
441 JsFunction::Execute();
442 }
443
Execute(const RefPtr<DragEvent> & info,const std::string & extraParams)444 JSRef<JSVal> JsDragFunction::Execute(const RefPtr<DragEvent>& info, const std::string& extraParams)
445 {
446 JSRef<JSVal> dragInfo = JSRef<JSObject>::Cast(CreateDragEvent(info));
447 JSRef<JSVal> jsonInfo = JSRef<JSVal>::Make(ToJSValue(extraParams));
448 JSRef<JSVal> params[] = { dragInfo, jsonInfo };
449 return JsFunction::ExecuteJS(2, params);
450 }
451
Execute(const RefPtr<DragEvent> & info)452 JSRef<JSVal> JsDragFunction::Execute(const RefPtr<DragEvent>& info)
453 {
454 JSRef<JSVal> dragInfo = JSRef<JSObject>::Cast(CreateDragEvent(info));
455 JSRef<JSVal> params[] = { dragInfo };
456 return JsFunction::ExecuteJS(1, params);
457 }
458
ItemDragStartExecute(const ItemDragInfo & info,int32_t itemIndex)459 JSRef<JSVal> JsDragFunction::ItemDragStartExecute(const ItemDragInfo& info, int32_t itemIndex)
460 {
461 JSRef<JSVal> itemDragInfo = JSRef<JSObject>::Cast(CreateItemDragInfo(info));
462 JSRef<JSVal> itemIndexParam = JSRef<JSVal>::Make(ToJSValue(itemIndex));
463 JSRef<JSVal> params[] = { itemDragInfo, itemIndexParam };
464 return JsFunction::ExecuteJS(2, params);
465 }
466
ItemDragEnterExecute(const ItemDragInfo & info)467 void JsDragFunction::ItemDragEnterExecute(const ItemDragInfo& info)
468 {
469 JSRef<JSObject> itemDragInfo = JSRef<JSObject>::Cast(CreateItemDragInfo(info));
470 JSRef<JSVal> param = itemDragInfo;
471 JsFunction::ExecuteJS(1, ¶m);
472 }
473
ItemDragMoveExecute(const ItemDragInfo & info,int32_t itemIndex,int32_t insertIndex)474 void JsDragFunction::ItemDragMoveExecute(const ItemDragInfo& info, int32_t itemIndex, int32_t insertIndex)
475 {
476 JSRef<JSVal> itemDragInfo = JSRef<JSObject>::Cast(CreateItemDragInfo(info));
477 JSRef<JSVal> itemIndexParam = JSRef<JSVal>::Make(ToJSValue(itemIndex));
478 JSRef<JSVal> insertIndexParam = JSRef<JSVal>::Make(ToJSValue(insertIndex));
479 JSRef<JSVal> params[] = { itemDragInfo, itemIndexParam, insertIndexParam };
480 JsFunction::ExecuteJS(3, params);
481 }
482
ItemDragLeaveExecute(const ItemDragInfo & info,int32_t itemIndex)483 void JsDragFunction::ItemDragLeaveExecute(const ItemDragInfo& info, int32_t itemIndex)
484 {
485 JSRef<JSVal> itemDragInfo = JSRef<JSObject>::Cast(CreateItemDragInfo(info));
486 JSRef<JSVal> itemIndexParam = JSRef<JSVal>::Make(ToJSValue(itemIndex));
487 JSRef<JSVal> params[] = { itemDragInfo, itemIndexParam };
488 JsFunction::ExecuteJS(2, params);
489 }
490
ItemDropExecute(const ItemDragInfo & info,int32_t itemIndex,int32_t insertIndex,bool isSuccess)491 void JsDragFunction::ItemDropExecute(const ItemDragInfo& info, int32_t itemIndex, int32_t insertIndex, bool isSuccess)
492 {
493 JSRef<JSVal> itemDragInfo = JSRef<JSObject>::Cast(CreateItemDragInfo(info));
494 JSRef<JSVal> itemIndexParam = JSRef<JSVal>::Make(ToJSValue(itemIndex));
495 JSRef<JSVal> insertIndexParam = JSRef<JSVal>::Make(ToJSValue(insertIndex));
496 JSRef<JSVal> isSuccessParam = JSRef<JSVal>::Make(ToJSValue(isSuccess));
497 JSRef<JSVal> params[] = { itemDragInfo, itemIndexParam, insertIndexParam, isSuccessParam };
498 JsFunction::ExecuteJS(4, params);
499 }
500
PreDragExecute(const PreDragStatus preDragStatus)501 void JsDragFunction::PreDragExecute(const PreDragStatus preDragStatus)
502 {
503 JSRef<JSVal> preDragStatusParam = JSRef<JSVal>::Make(ToJSValue(static_cast<int32_t>(preDragStatus)));
504 JSRef<JSVal> params[] = { preDragStatusParam };
505 JsFunction::ExecuteJS(1, params);
506 }
507
CreateDragEvent(const RefPtr<DragEvent> & info)508 JSRef<JSObject> JsDragFunction::CreateDragEvent(const RefPtr<DragEvent>& info)
509 {
510 JSRef<JSObject> dragObj = JSClass<JsDragEvent>::NewInstance();
511 auto dragEvent = Referenced::Claim(dragObj->Unwrap<JsDragEvent>());
512 CHECK_NULL_RETURN(dragEvent, dragObj);
513 dragEvent->SetDragEvent(info);
514 auto pasteDataInfo = dragEvent->GetDragEvent()->GetPasteData();
515 JSRef<JSObject> pasteData = CreatePasteData(pasteDataInfo);
516 dragEvent->SetJsPasteData(pasteData);
517 return dragObj;
518 }
519
CreatePasteData(const RefPtr<PasteData> & info)520 JSRef<JSObject> JsDragFunction::CreatePasteData(const RefPtr<PasteData>& info)
521 {
522 JSRef<JSObject> pasteObj = JSClass<JsPasteData>::NewInstance();
523 auto pasteData = Referenced::Claim(pasteObj->Unwrap<JsPasteData>());
524 CHECK_NULL_RETURN(pasteData, pasteObj);
525 pasteData->SetPasteData(info);
526 return pasteObj;
527 }
528
CreateItemDragInfo(const ItemDragInfo & info)529 JSRef<JSObject> JsDragFunction::CreateItemDragInfo(const ItemDragInfo& info)
530 {
531 JSRef<JSObject> itemDragInfoObj = JSRef<JSObject>::New();
532 itemDragInfoObj->SetProperty<double>("x", PipelineBase::Px2VpWithCurrentDensity(info.GetX()));
533 itemDragInfoObj->SetProperty<double>("y", PipelineBase::Px2VpWithCurrentDensity(info.GetY()));
534 return itemDragInfoObj;
535 }
536
537 } // namespace OHOS::Ace::Framework
538