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