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>::Bind(globalObj, &JsDragEvent::Constructor, &JsDragEvent::Destructor);
132 }
133 
SetJsPasteData(const JSRef<JSObject> & jsPasteData)134 void JsDragEvent::SetJsPasteData(const JSRef<JSObject>& jsPasteData)
135 {
136     jsPasteData_ = jsPasteData;
137 }
138 
GetJsPasteData(const JSCallbackInfo & args)139 void JsDragEvent::GetJsPasteData(const JSCallbackInfo& args)
140 {
141     args.SetReturnValue(jsPasteData_);
142 }
143 
GetScreenX(const JSCallbackInfo & args)144 void JsDragEvent::GetScreenX(const JSCallbackInfo& args)
145 {
146     auto xValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetScreenX())));
147     auto xValueRef = JSRef<JSVal>::Make(xValue);
148     args.SetReturnValue(xValueRef);
149 }
150 
GetScreenY(const JSCallbackInfo & args)151 void JsDragEvent::GetScreenY(const JSCallbackInfo& args)
152 {
153     auto yValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetScreenY())));
154     auto yValueRef = JSRef<JSVal>::Make(yValue);
155     args.SetReturnValue(yValueRef);
156 }
157 
GetX(const JSCallbackInfo & args)158 void JsDragEvent::GetX(const JSCallbackInfo& args)
159 {
160     auto xValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetX())));
161     auto xValueRef = JSRef<JSVal>::Make(xValue);
162     args.SetReturnValue(xValueRef);
163 }
164 
GetY(const JSCallbackInfo & args)165 void JsDragEvent::GetY(const JSCallbackInfo& args)
166 {
167     auto yValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetY())));
168     auto yValueRef = JSRef<JSVal>::Make(yValue);
169     args.SetReturnValue(yValueRef);
170 }
171 
GetDescription(const JSCallbackInfo & args)172 void JsDragEvent::GetDescription(const JSCallbackInfo& args)
173 {
174     auto description = JSVal(ToJSValue(dragEvent_->GetDescription()));
175     auto descriptionRef = JSRef<JSVal>::Make(description);
176     args.SetReturnValue(descriptionRef);
177 }
178 
SetDescription(const JSCallbackInfo & args)179 void JsDragEvent::SetDescription(const JSCallbackInfo& args)
180 {
181     if (args[0]->IsString()) {
182         dragEvent_->SetDescription(args[0]->ToString());
183     }
184 }
185 
SetData(const JSCallbackInfo & args)186 void JsDragEvent::SetData(const JSCallbackInfo& args)
187 {
188     if (!args[0]->IsObject()) {
189         return;
190     }
191     auto engine = EngineHelper::GetCurrentEngine();
192     CHECK_NULL_VOID(engine);
193     NativeEngine* nativeEngine = engine->GetNativeEngine();
194     panda::Local<JsiValue> value = args[0].Get().GetLocalHandle();
195     JSValueWrapper valueWrapper = value;
196     ScopeRAII scope(reinterpret_cast<napi_env>(nativeEngine));
197     napi_value nativeValue = nativeEngine->ValueToNapiValue(valueWrapper);
198     RefPtr<UnifiedData> udData = UdmfClient::GetInstance()->TransformUnifiedData(nativeValue);
199     CHECK_NULL_VOID(udData);
200     dragEvent_->SetData(udData);
201 }
202 
GetData(const JSCallbackInfo & args)203 void JsDragEvent::GetData(const JSCallbackInfo& args)
204 {
205     auto dragData = dragEvent_->GetData();
206     if (!dragEvent_->IsGetDataSuccess()) {
207         TAG_LOGI(AceLogTag::ACE_DRAG, "UDMF GetData failed in first attempt");
208         std::string udKey = dragEvent_->GetUdKey();
209         if (udKey.empty()) {
210             args.SetReturnValue(JSVal::Undefined());
211             return;
212         }
213         int ret = UdmfClient::GetInstance()->GetData(dragData, udKey);
214         if (ret != 0) {
215             TAG_LOGW(AceLogTag::ACE_DRAG, "UDMF GetData failed: %{public}d", ret);
216             auto engine = EngineHelper::GetCurrentEngine();
217             if (!engine) {
218                 args.SetReturnValue(JSVal::Undefined());
219                 return;
220             }
221             auto errorInfo = UdmfClient::GetInstance()->GetErrorInfo(ret);
222             NapiThrow(engine, errorInfo.first, errorInfo.second);
223             return;
224         } else {
225             dragEvent_->SetData(dragData);
226             dragEvent_->SetIsGetDataSuccess(true);
227         }
228     }
229     CHECK_NULL_VOID(dragData);
230     napi_value nativeValue = UdmfClient::GetInstance()->TransformUdmfUnifiedData(dragData);
231     CHECK_NULL_VOID(nativeValue);
232     auto jsValue = JsConverter::ConvertNapiValueToJsVal(nativeValue);
233     args.SetReturnValue(jsValue);
234 }
235 
GetSummary(const JSCallbackInfo & args)236 void JsDragEvent::GetSummary(const JSCallbackInfo& args)
237 {
238     auto engine = EngineHelper::GetCurrentEngine();
239     CHECK_NULL_VOID(engine);
240     auto summary = dragEvent_->GetSummary();
241     napi_value nativeValue = UdmfClient::GetInstance()->TransformSummary(summary);
242     CHECK_NULL_VOID(nativeValue);
243     auto jsValue = JsConverter::ConvertNapiValueToJsVal(nativeValue);
244     args.SetReturnValue(jsValue);
245 }
246 
SetResult(const JSCallbackInfo & args)247 void JsDragEvent::SetResult(const JSCallbackInfo& args)
248 {
249     if (args[0]->IsNumber()) {
250         auto dragRet = args[0]->ToNumber<int32_t>();
251         dragEvent_->SetResult((DragRet)dragRet);
252     }
253 }
254 
GetResult(const JSCallbackInfo & args)255 void JsDragEvent::GetResult(const JSCallbackInfo& args)
256 {
257     CHECK_NULL_VOID(dragEvent_);
258     auto dragRet = JSVal(ToJSValue(static_cast<int32_t>(dragEvent_->GetResult())));
259     auto dragRetRef = JSRef<JSVal>::Make(dragRet);
260     args.SetReturnValue(dragRetRef);
261 }
262 
GetPreviewRect(const JSCallbackInfo & args)263 void JsDragEvent::GetPreviewRect(const JSCallbackInfo& args)
264 {
265     auto rectObj = CreateRectangle(dragEvent_->GetPreviewRect());
266     JSRef<JSVal> previewRect = JSRef<JSObject>::Cast(rectObj);
267     args.SetReturnValue(previewRect);
268 }
269 
SetUseCustomDropAnimation(const JSCallbackInfo & args)270 void JsDragEvent::SetUseCustomDropAnimation(const JSCallbackInfo& args)
271 {
272     if (args[0]->IsBoolean()) {
273         dragEvent_->UseCustomAnimation(args[0]->ToBoolean());
274     }
275 }
276 
GetUseCustomDropAnimation(const JSCallbackInfo & args)277 void JsDragEvent::GetUseCustomDropAnimation(const JSCallbackInfo& args)
278 {
279     auto useCustomAnimation = JSVal(ToJSValue(dragEvent_->IsUseCustomAnimation()));
280     auto useCustomAnimationRef = JSRef<JSVal>::Make(useCustomAnimation);
281     args.SetReturnValue(useCustomAnimationRef);
282 }
283 
SetDragInfo(const JSCallbackInfo & args)284 void JsDragEvent::SetDragInfo(const JSCallbackInfo& args)
285 {
286     if (!args[0]->IsObject()) {
287         return;
288     }
289     auto engine = EngineHelper::GetCurrentEngine();
290     CHECK_NULL_VOID(engine);
291     NativeEngine* nativeEngine = engine->GetNativeEngine();
292     panda::Local<JsiValue> value = args[0].Get().GetLocalHandle();
293     JSValueWrapper valueWrapper = value;
294     ScopeRAII scope(reinterpret_cast<napi_env>(nativeEngine));
295     napi_value nativeValue = nativeEngine->ValueToNapiValue(valueWrapper);
296     RefPtr<UnifiedData> udData = UdmfClient::GetInstance()->TransformUnifiedData(nativeValue);
297     CHECK_NULL_VOID(udData);
298     dragEvent_->SetData(udData);
299 }
300 
GetDragInfo(const JSCallbackInfo & args)301 void JsDragEvent::GetDragInfo(const JSCallbackInfo& args)
302 {
303     auto dragData = dragEvent_->GetDragInfo();
304     CHECK_NULL_VOID(dragData);
305     napi_value nativeValue = UdmfClient::GetInstance()->TransformUdmfUnifiedData(dragData);
306     CHECK_NULL_VOID(nativeValue);
307     auto jsValue = JsConverter::ConvertNapiValueToJsVal(nativeValue);
308     args.SetReturnValue(jsValue);
309 }
310 
convertDragBehavior(int32_t dragBehavior)311 OHOS::Ace::DragBehavior convertDragBehavior(int32_t dragBehavior)
312 {
313     switch (dragBehavior) {
314         case 0:
315             return OHOS::Ace::DragBehavior::COPY;
316         case 1:
317             return OHOS::Ace::DragBehavior::MOVE;
318         default:
319             return OHOS::Ace::DragBehavior::UNKNOWN;
320     }
321 }
322 
SetDragBehavior(const JSCallbackInfo & args)323 void JsDragEvent::SetDragBehavior(const JSCallbackInfo& args)
324 {
325     if (args[0]->IsNumber()) {
326         dragEvent_->SetCopy(!static_cast<bool>(args[0]->ToNumber<int32_t>()));
327         dragEvent_->SetDragBehavior(convertDragBehavior(args[0]->ToNumber<int32_t>()));
328     }
329 }
330 
GetDragBehavior(const JSCallbackInfo & args)331 void JsDragEvent::GetDragBehavior(const JSCallbackInfo& args)
332 {
333     auto dragBehavior = JSVal(ToJSValue(static_cast<int32_t>(
334         dragEvent_->GetDragBehavior() == OHOS::Ace::DragBehavior::MOVE ? OHOS::Ace::DragBehavior::MOVE
335                                                                        : OHOS::Ace::DragBehavior::COPY)));
336     auto dragBehaviorRef = JSRef<JSVal>::Make(dragBehavior);
337     args.SetReturnValue(dragBehaviorRef);
338 }
339 
GetVelocityX(const JSCallbackInfo & args)340 void JsDragEvent::GetVelocityX(const JSCallbackInfo& args)
341 {
342     auto jsValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetVelocity().GetVelocityX())));
343     auto jsValueRef = JSRef<JSVal>::Make(jsValue);
344     args.SetReturnValue(jsValueRef);
345 }
346 
GetVelocityY(const JSCallbackInfo & args)347 void JsDragEvent::GetVelocityY(const JSCallbackInfo& args)
348 {
349     auto jsValue = JSVal(ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetVelocity().GetVelocityY())));
350     auto jsValueRef = JSRef<JSVal>::Make(jsValue);
351     args.SetReturnValue(jsValueRef);
352 }
353 
GetVelocity(const JSCallbackInfo & args)354 void JsDragEvent::GetVelocity(const JSCallbackInfo& args)
355 {
356     auto jsValue = JSVal(
357         ToJSValue(PipelineBase::Px2VpWithCurrentDensity(dragEvent_->GetVelocity().GetVelocityValue())));
358     auto jsValueRef = JSRef<JSVal>::Make(jsValue);
359     args.SetReturnValue(jsValueRef);
360 }
361 
GetModifierKeyState(const JSCallbackInfo & args)362 void JsDragEvent::GetModifierKeyState(const JSCallbackInfo& args)
363 {
364     bool ret = false;
365     auto keyState = NG::ArkTSUtils::GetModifierKeyState(args.GetJsiRuntimeCallInfo(),
366         dragEvent_->GetPressedKeyCodes());
367     if (keyState->IsTrue()) {
368         ret = true;
369     }
370 
371     auto jsValueRef = JSRef<JSVal>::Make(ToJSValue(ret));
372     args.SetReturnValue(jsValueRef);
373 }
374 
Constructor(const JSCallbackInfo & args)375 void JsDragEvent::Constructor(const JSCallbackInfo& args)
376 {
377     auto dragEvent = Referenced::MakeRefPtr<JsDragEvent>();
378     CHECK_NULL_VOID(dragEvent);
379     dragEvent->IncRefCount();
380     args.SetReturnValue(Referenced::RawPtr(dragEvent));
381 }
382 
Destructor(JsDragEvent * dragEvent)383 void JsDragEvent::Destructor(JsDragEvent* dragEvent)
384 {
385     if (dragEvent != nullptr) {
386         dragEvent->DecRefCount();
387     }
388 }
389 
CreateRectangle(const Rect & info)390 JSRef<JSObject> JsDragEvent::CreateRectangle(const Rect& info)
391 {
392     JSRef<JSObject> rectObj = JSRef<JSObject>::New();
393     rectObj->SetProperty<double>("x", PipelineBase::Px2VpWithCurrentDensity(info.Left()));
394     rectObj->SetProperty<double>("y", PipelineBase::Px2VpWithCurrentDensity(info.Top()));
395     rectObj->SetProperty<double>("width", PipelineBase::Px2VpWithCurrentDensity(info.Width()));
396     rectObj->SetProperty<double>("height", PipelineBase::Px2VpWithCurrentDensity(info.Height()));
397     return rectObj;
398 }
399 
JSBind(BindingTarget globalObj)400 void JsDragFunction::JSBind(BindingTarget globalObj)
401 {
402     JsPasteData::JSBind(globalObj);
403     JsDragEvent::JSBind(globalObj);
404 }
405 
Execute()406 void JsDragFunction::Execute()
407 {
408     JsFunction::Execute();
409 }
410 
Execute(const RefPtr<DragEvent> & info,const std::string & extraParams)411 JSRef<JSVal> JsDragFunction::Execute(const RefPtr<DragEvent>& info, const std::string& extraParams)
412 {
413     JSRef<JSVal> dragInfo = JSRef<JSObject>::Cast(CreateDragEvent(info));
414     JSRef<JSVal> jsonInfo = JSRef<JSVal>::Make(ToJSValue(extraParams));
415     JSRef<JSVal> params[] = { dragInfo, jsonInfo };
416     return JsFunction::ExecuteJS(2, params);
417 }
418 
Execute(const RefPtr<DragEvent> & info)419 JSRef<JSVal> JsDragFunction::Execute(const RefPtr<DragEvent>& info)
420 {
421     JSRef<JSVal> dragInfo = JSRef<JSObject>::Cast(CreateDragEvent(info));
422     JSRef<JSVal> params[] = { dragInfo };
423     return JsFunction::ExecuteJS(1, params);
424 }
425 
ItemDragStartExecute(const ItemDragInfo & info,int32_t itemIndex)426 JSRef<JSVal> JsDragFunction::ItemDragStartExecute(const ItemDragInfo& info, int32_t itemIndex)
427 {
428     JSRef<JSVal> itemDragInfo = JSRef<JSObject>::Cast(CreateItemDragInfo(info));
429     JSRef<JSVal> itemIndexParam = JSRef<JSVal>::Make(ToJSValue(itemIndex));
430     JSRef<JSVal> params[] = { itemDragInfo, itemIndexParam };
431     return JsFunction::ExecuteJS(2, params);
432 }
433 
ItemDragEnterExecute(const ItemDragInfo & info)434 void JsDragFunction::ItemDragEnterExecute(const ItemDragInfo& info)
435 {
436     JSRef<JSObject> itemDragInfo = JSRef<JSObject>::Cast(CreateItemDragInfo(info));
437     JSRef<JSVal> param = itemDragInfo;
438     JsFunction::ExecuteJS(1, &param);
439 }
440 
ItemDragMoveExecute(const ItemDragInfo & info,int32_t itemIndex,int32_t insertIndex)441 void JsDragFunction::ItemDragMoveExecute(const ItemDragInfo& info, int32_t itemIndex, int32_t insertIndex)
442 {
443     JSRef<JSVal> itemDragInfo = JSRef<JSObject>::Cast(CreateItemDragInfo(info));
444     JSRef<JSVal> itemIndexParam = JSRef<JSVal>::Make(ToJSValue(itemIndex));
445     JSRef<JSVal> insertIndexParam = JSRef<JSVal>::Make(ToJSValue(insertIndex));
446     JSRef<JSVal> params[] = { itemDragInfo, itemIndexParam, insertIndexParam };
447     JsFunction::ExecuteJS(3, params);
448 }
449 
ItemDragLeaveExecute(const ItemDragInfo & info,int32_t itemIndex)450 void JsDragFunction::ItemDragLeaveExecute(const ItemDragInfo& info, int32_t itemIndex)
451 {
452     JSRef<JSVal> itemDragInfo = JSRef<JSObject>::Cast(CreateItemDragInfo(info));
453     JSRef<JSVal> itemIndexParam = JSRef<JSVal>::Make(ToJSValue(itemIndex));
454     JSRef<JSVal> params[] = { itemDragInfo, itemIndexParam };
455     JsFunction::ExecuteJS(2, params);
456 }
457 
ItemDropExecute(const ItemDragInfo & info,int32_t itemIndex,int32_t insertIndex,bool isSuccess)458 void JsDragFunction::ItemDropExecute(const ItemDragInfo& info, int32_t itemIndex, int32_t insertIndex, bool isSuccess)
459 {
460     JSRef<JSVal> itemDragInfo = JSRef<JSObject>::Cast(CreateItemDragInfo(info));
461     JSRef<JSVal> itemIndexParam = JSRef<JSVal>::Make(ToJSValue(itemIndex));
462     JSRef<JSVal> insertIndexParam = JSRef<JSVal>::Make(ToJSValue(insertIndex));
463     JSRef<JSVal> isSuccessParam = JSRef<JSVal>::Make(ToJSValue(isSuccess));
464     JSRef<JSVal> params[] = { itemDragInfo, itemIndexParam, insertIndexParam, isSuccessParam };
465     JsFunction::ExecuteJS(4, params);
466 }
467 
PreDragExecute(const PreDragStatus preDragStatus)468 void JsDragFunction::PreDragExecute(const PreDragStatus preDragStatus)
469 {
470     JSRef<JSVal> preDragStatusParam = JSRef<JSVal>::Make(ToJSValue(static_cast<int32_t>(preDragStatus)));
471     JSRef<JSVal> params[] = { preDragStatusParam };
472     JsFunction::ExecuteJS(1, params);
473 }
474 
CreateDragEvent(const RefPtr<DragEvent> & info)475 JSRef<JSObject> JsDragFunction::CreateDragEvent(const RefPtr<DragEvent>& info)
476 {
477     JSRef<JSObject> dragObj = JSClass<JsDragEvent>::NewInstance();
478     auto dragEvent = Referenced::Claim(dragObj->Unwrap<JsDragEvent>());
479     CHECK_NULL_RETURN(dragEvent, dragObj);
480     dragEvent->SetDragEvent(info);
481     auto pasteDataInfo = dragEvent->GetDragEvent()->GetPasteData();
482     JSRef<JSObject> pasteData = CreatePasteData(pasteDataInfo);
483     dragEvent->SetJsPasteData(pasteData);
484     return dragObj;
485 }
486 
CreatePasteData(const RefPtr<PasteData> & info)487 JSRef<JSObject> JsDragFunction::CreatePasteData(const RefPtr<PasteData>& info)
488 {
489     JSRef<JSObject> pasteObj = JSClass<JsPasteData>::NewInstance();
490     auto pasteData = Referenced::Claim(pasteObj->Unwrap<JsPasteData>());
491     CHECK_NULL_RETURN(pasteData, pasteObj);
492     pasteData->SetPasteData(info);
493     return pasteObj;
494 }
495 
CreateItemDragInfo(const ItemDragInfo & info)496 JSRef<JSObject> JsDragFunction::CreateItemDragInfo(const ItemDragInfo& info)
497 {
498     JSRef<JSObject> itemDragInfoObj = JSRef<JSObject>::New();
499     itemDragInfoObj->SetProperty<double>("x", PipelineBase::Px2VpWithCurrentDensity(info.GetX()));
500     itemDragInfoObj->SetProperty<double>("y", PipelineBase::Px2VpWithCurrentDensity(info.GetY()));
501     return itemDragInfoObj;
502 }
503 
504 } // namespace OHOS::Ace::Framework
505