From 4f4adce8e421f9d64bad73779f365a4182d48fbb Mon Sep 17 00:00:00 2001 From: Korobeinikov Evgeny Date: Fri, 1 Nov 2024 18:11:27 +0300 Subject: [PATCH 1/3] Exclude library.cc --- arkoala/framework/native/meson.build | 2 +- arkoala/framework/native/src/api-impl.cc | 50 +- .../src/generated/arkoala_api_generated.h | 2 +- .../native/src/generated/bridge_generated.cc | 486 +++++++++++++++++- .../native/src/generated/real_impl.cc | 1 + arkoala/framework/src/Application.ts | 12 +- arkoala/framework/src/Events.ts | 142 ----- .../framework/src/generated/NativeModule.ts | 12 + .../src/generated/NativeModuleEmpty.ts | 48 +- 9 files changed, 537 insertions(+), 218 deletions(-) diff --git a/arkoala/framework/native/meson.build b/arkoala/framework/native/meson.build index 60f306f9a..de8958dad 100644 --- a/arkoala/framework/native/meson.build +++ b/arkoala/framework/native/meson.build @@ -24,8 +24,8 @@ arkoala_sources = [ './src/generated/callback_deserialize_call.cc', './src/generated/callback_managed_caller.cc', './src/DeserializerBase.cc', - './src/library.cc', './src/callbacks.cc', + interop_src / 'common-interop.cc' ] sources = [ diff --git a/arkoala/framework/native/src/api-impl.cc b/arkoala/framework/native/src/api-impl.cc index ca89ccca3..500a97733 100644 --- a/arkoala/framework/native/src/api-impl.cc +++ b/arkoala/framework/native/src/api-impl.cc @@ -2067,11 +2067,11 @@ void VsyncJobWorker::OnOK() { } #endif // KOALA_NAPI -ArkUIPipelineContext GetPipelineContext(ArkUINodeHandle node) { +Ark_PipelineContext GetPipelineContext(Ark_NodeHandle node) { return nullptr; } -void SetVsyncCallback(ArkUIVMContext vmContext, ArkUIPipelineContext pipelineContext, ArkUI_Int32 callbackId) +void SetVsyncCallback(Ark_VMContext vmContext, Ark_PipelineContext pipelineContext, Ark_Int32 callbackId) { #ifdef KOALA_NAPI assert(currentJob == nullptr); @@ -2080,7 +2080,7 @@ void SetVsyncCallback(ArkUIVMContext vmContext, ArkUIPipelineContext pipelineCon #endif } -void UnblockVsyncWait(ArkUIVMContext vmContext, ArkUIPipelineContext pipelineContext) +void UnblockVsyncWait(Ark_VMContext vmContext, Ark_PipelineContext pipelineContext) { #ifdef KOALA_NAPI ArkUI_Int32 callbackId = currentJob ? currentJob->callbackId() : 0; @@ -2440,50 +2440,6 @@ extern "C" DLL_EXPORT const ArkUIAnyAPI *GetArkUINodeAPI(ArkUIAPIVariantKind kin { fprintf(stdout, "#### GETArkUINodeAPI\n"); switch (kind) { - case ArkUIAPIVariantKind::BASIC: { - fprintf(stdout, "#### GETArkUINodeAPI BASIC\n"); - switch (version) { - case ARKUI_BASIC_API_VERSION: return reinterpret_cast(GetBasicAPI()); - default: { - ARKOALA_LOG("Requested version %d is not supported, we're version %d\n", - version, ARKUI_BASIC_API_VERSION); - return nullptr; - } - } - } - case ArkUIAPIVariantKind::FULL: { - fprintf(stdout, "#### GETArkUINodeAPI FULL\n"); - switch (version) { - // case 29: return &impl_29; - case ARKUI_FULL_API_VERSION: return reinterpret_cast(&impl_full_current); - default: { - ARKOALA_LOG("Requested version %d is not supported, we're version %d\n", - version, ARKUI_FULL_API_VERSION); - return nullptr; - } - } - } - case ArkUIAPIVariantKind::GRAPHICS: { - switch (version) { - case ARKUI_NODE_GRAPHICS_API_VERSION: return reinterpret_cast(GetGraphicsAPI()); - default: { - ARKOALA_LOG("Requested version %d is not supported, we're version %d\n", - version, ARKUI_NODE_GRAPHICS_API_VERSION); - return nullptr; - } - } - } - case ArkUIAPIVariantKind::EXTENDED: { - switch (version) { - case ARKUI_EXTENDED_API_VERSION: return reinterpret_cast(&impl_extended_current); - default: { - ARKOALA_LOG("Requested version %d is not supported, we're version %d\n", - version, ARKUI_EXTENDED_API_VERSION); - return nullptr; - } - } - } - case GENERATED_Ark_APIVariantKind::GENERATED_FULL: { fprintf(stdout, "#### GETArkUINodeAPI GEN_FULL\n"); switch (version) { diff --git a/arkoala/framework/native/src/generated/arkoala_api_generated.h b/arkoala/framework/native/src/generated/arkoala_api_generated.h index 3ec15bb4a..21c951524 100644 --- a/arkoala/framework/native/src/generated/arkoala_api_generated.h +++ b/arkoala/framework/native/src/generated/arkoala_api_generated.h @@ -20349,6 +20349,7 @@ typedef struct GENERATED_ArkUIFullNodeAPI { const GENERATED_ArkUIGraphicsAPI* (*getGraphicsAPI)(); const GENERATED_ArkUIEventsAPI* (*getEventsAPI)(); const GENERATED_ArkUIExtendedNodeAPI* (*getExtendedAPI)(); + const GENERATED_ArkUIBasicNodeAPI* (*getBasicAPI)(); void (*setArkUIEventsAPI)(const GENERATED_ArkUIEventsAPI* api); } GENERATED_ArkUIFullNodeAPI; @@ -20357,7 +20358,6 @@ typedef struct GENERATED_ArkUIAnyAPI { } GENERATED_ArkUIAnyAPI; - struct Ark_AnyAPI { Ark_Int32 version; }; diff --git a/arkoala/framework/native/src/generated/bridge_generated.cc b/arkoala/framework/native/src/generated/bridge_generated.cc index 7363779ee..8f57b6399 100644 --- a/arkoala/framework/native/src/generated/bridge_generated.cc +++ b/arkoala/framework/native/src/generated/bridge_generated.cc @@ -17,17 +17,495 @@ #include "arkoala_api_generated.h" #include "Serializers.h" #include "arkoala-logging.h" +#include <__config> +#include +#include +#include "logging.h" -static const GENERATED_ArkUIFullNodeAPI* GetFullImpl() { + +#ifdef KOALA_OHOS +#define PUBLIC_STRING_FORMAT "%{public}s" +#define PUBLIC_NUMBER_FORMAT "%{public}d" +#define PUBLIC_POINTER_FORMAT "%{public}p" +#else +#define PUBLIC_STRING_FORMAT "%s" +#define PUBLIC_NUMBER_FORMAT "%d" +#define PUBLIC_POINTER_FORMAT "%p" +#endif + +#ifdef KOALA_WINDOWS +#include +// Here we need to find module where GetArkUINodeAPI() +// function is implemented. +void* FindModule() { + // To find from main exe + // return GetModuleHandle(nullptr); + HMODULE result = nullptr; +#ifdef USE_DUMMY_IMPL + // This way we search from the same current DLL. + GetModuleHandleEx( + GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, + reinterpret_cast(&FindModule), + &result); + ARKOALA_LOG0("Use dummy implementation\n"); + return result; +#else + const char* libnames[] = { + "libace_compatible.dll", + "libace.dll", + nullptr + }; + for (int i = 0; libnames[i] != nullptr; i++) { + GetModuleHandleEx( + GET_MODULE_HANDLE_EX_FLAG_PIN, + libnames[i], + &result); + if (result) return result; + } + ARKOALA_LOG("Cannot find module!"); + return nullptr; +#endif +} +void* FindFunction(void* library, const char* name) { + return (void*)GetProcAddress(reinterpret_cast(library), name); +} +#endif + +#if defined(KOALA_OHOS) || defined(KOALA_LINUX) || defined(KOALA_MACOS) +#include +void* FindModule() { +#ifdef USE_DUMMY_IMPL + return RTLD_DEFAULT; +#else + const char* libnames[] = { +#ifdef KOALA_OHOS +"/system/lib64/platformsdk/libace_compatible.z.so", +"/system/lib64/platformsdk/libace.z.so", +#else +"libace.so", +#endif + nullptr + }; + for (int i = 0; libnames[i] != nullptr; i++) { + ARKOALA_LOG("Loading " PUBLIC_STRING_FORMAT, libnames[i]); + void* result = dlopen(libnames[i], RTLD_LAZY | RTLD_LOCAL); + if (result) { + return result; + } else { + ARKOALA_LOG("Cannot load libace: " PUBLIC_STRING_FORMAT, dlerror()); + } + } + return nullptr; +#endif +} + +#if defined(USE_DUMMY_IMPL) && defined(KOALA_OHOS) +extern "C" ArkUINodeAPI* GetArkUINodeAPI(); +#endif + +void* FindFunction(void* library, const char* name) { +#if defined(USE_DUMMY_IMPL) && defined(KOALA_OHOS) + return reinterpret_cast(&GetArkUINodeAPI); +#else + return dlsym(library, name); +#endif +} +#endif + +using std::string; + +inline const char* getString(const KStringPtr& ptr) { + return ptr.c_str(); +} + +namespace Generated { + const GENERATED_ArkUIEventsAPI* GetArkUiEventsAPI(); +} + +static GENERATED_ArkUIAnyAPI* impls[GENERATED_Ark_APIVariantKind::GENERATED_COUNT] = { 0 }; + +static Ark_Int32 CallInt(Ark_VMContext vmContext, Ark_Int32 methodId, Ark_Int32 numArgs, GENERATED_Ark_EventCallbackArg* args) { + // TODO: make typed args supported! + KOALA_INTEROP_CALL_INT_INTS32(vmContext, methodId, numArgs, args) +} + +static struct GENERATED_Ark_APICallbackMethod callbackImpl = { + CallInt, +}; + +const GENERATED_ArkUIAnyAPI* GetAnyImpl(GENERATED_Ark_APIVariantKind kind, int version, std::string* result) { + if (!impls[kind]) { + GENERATED_ArkUIAnyAPI* impl = nullptr; + typedef GENERATED_ArkUIAnyAPI* (*GetAPI_t)(int, int); + GetAPI_t getAPI = nullptr; + char* envValue = getenv("__LIBACE_ENTRY_POINT"); + if (envValue) { + long long value = strtoll(envValue, NULL, 16); + if (value != 0) { + getAPI = reinterpret_cast(static_cast(value)); + } + } + if (getAPI == nullptr) { + void* module = FindModule(); + // Note, that RTLD_DEFAULT is ((void *) 0). + getAPI = reinterpret_cast(FindFunction(module, "GetArkUINodeAPI")); + if (!getAPI) { + if (result) + *result = "Cannot find GetArkUINodeAPI()"; + else + ARKOALA_LOG0("Cannot find GetArkUINodeAPI()"); + return nullptr; + } + } + + impl = (*getAPI)(kind, version); + if (!impl) { + if (result) + *result = "getAPI() returned null"; + else + ARKOALA_LOG0("getAPI() returned null"); + return nullptr; + } + + if (impl->version != version) { + if (result) { + char buffer[256]; + snprintf(buffer, sizeof(buffer), "FATAL ERROR: Arkoala API version mismatch, expected %d got %d", + version, impl->version); + *result = buffer; + } else { + ARKOALA_LOG("API version mismatch for API " PUBLIC_NUMBER_FORMAT ": expected " PUBLIC_NUMBER_FORMAT " got " PUBLIC_NUMBER_FORMAT, + kind, version, impl->version); + } + return nullptr; + } + if (kind == GENERATED_Ark_APIVariantKind::GENERATED_EXTENDED) { + ((GENERATED_ArkUIExtendedNodeAPI*)impl)->setCallbackMethod(&callbackImpl); + } + if (kind == GENERATED_Ark_APIVariantKind::GENERATED_FULL) { + ((GENERATED_ArkUIFullNodeAPI*)impl)->setArkUIEventsAPI(Generated::GetArkUiEventsAPI()); + } + /* + Do nothing for generated kinds of API + */ + impls[kind] = impl; + } + return impls[kind]; +} + +static const GENERATED_ArkUIFullNodeAPI* GetFullImpl(std::string* result = nullptr) { return reinterpret_cast( - GetAnyImpl(static_cast(GENERATED_Ark_APIVariantKind::GENERATED_FULL), - GENERATED_ARKUI_FULL_API_VERSION)); + GetAnyImpl(GENERATED_Ark_APIVariantKind::GENERATED_FULL, GENERATED_ARKUI_FULL_API_VERSION, result)); +} + +const GENERATED_ArkUIBasicNodeAPI* GetBasicImpl(std::string* result = nullptr) { + return reinterpret_cast(GetAnyImpl(GENERATED_Ark_APIVariantKind::GENERATED_BASIC, GENERATED_ARKUI_BASIC_NODE_API_VERSION, result)); } -static const GENERATED_ArkUINodeModifiers* GetNodeModifiers() { +const GENERATED_ArkUIGraphicsAPI* GetGraphicsImpl(std::string* result = nullptr) { + return reinterpret_cast(GetAnyImpl(GENERATED_Ark_APIVariantKind::GENERATED_GRAPHICS, GENERATED_ARKUI_NODE_GRAPHICS_API_VERSION, result)); +} + +const GENERATED_ArkUIExtendedNodeAPI* GetExtendedImpl(std::string* result = nullptr) { + return reinterpret_cast(GetAnyImpl(GENERATED_Ark_APIVariantKind::GENERATED_EXTENDED, GENERATED_ARKUI_EXTENDED_NODE_API_VERSION, result)); +} + +const GENERATED_ArkUINodeModifiers* GetNodeModifiers() { return GetFullImpl()->getNodeModifiers(); } +KNativePointer impl_CheckImpl() { + std::string error; + auto result = GetFullImpl(&error); + if (result) + return nullptr; + else + return new std::string(error); +} +KOALA_INTEROP_0(CheckImpl, KNativePointer) + +KNativePointer impl_CreateNode(KInt type, KInt id, KInt flags) { + auto result = GetFullImpl()->getBasicAPI()->createNode(static_cast(type), id, flags); + return result; +} +KOALA_INTEROP_3(CreateNode, KNativePointer, KInt, KInt, KInt) + +KNativePointer impl_GetNodeByViewStack() { + auto result = GetFullImpl()->getBasicAPI()->getNodeByViewStack(); + ARKOALA_LOG("getNodeByViewStack " PUBLIC_POINTER_FORMAT "\n", result); + return result; +} +KOALA_INTEROP_0(GetNodeByViewStack, KNativePointer) + +void impl_DisposeNode(KNativePointer nodePtr) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetFullImpl()->getBasicAPI()->disposeNode(node); +} +KOALA_INTEROP_V1(DisposeNode, KNativePointer) + +void impl_AddChild(KNativePointer parentPtr, KNativePointer childPtr) { + Ark_NodeHandle parent = reinterpret_cast(parentPtr); + Ark_NodeHandle child = reinterpret_cast(childPtr); + GetFullImpl()->getBasicAPI()->addChild(parent, child); +} +KOALA_INTEROP_V2(AddChild, KNativePointer, KNativePointer) + +void impl_RemoveChild(KNativePointer parentPtr, KNativePointer childPtr) { + Ark_NodeHandle parent = reinterpret_cast(parentPtr); + Ark_NodeHandle child = reinterpret_cast(childPtr); + GetFullImpl()->getBasicAPI()->removeChild(parent, child); + GetFullImpl()->getBasicAPI()->markDirty(parent, GENERATED_ARKUI_DIRTY_FLAG_MEASURE_BY_CHILD_REQUEST); +} +KOALA_INTEROP_V2(RemoveChild, KNativePointer, KNativePointer) + +void impl_InsertChildAfter(KNativePointer parentPtr, KNativePointer childPtr, KNativePointer siblingPtr) { + Ark_NodeHandle parent = reinterpret_cast(parentPtr); + Ark_NodeHandle child = reinterpret_cast(childPtr); + Ark_NodeHandle sibling = reinterpret_cast(siblingPtr); + GetFullImpl()->getBasicAPI()->insertChildAfter(parent, child, sibling); + GetFullImpl()->getBasicAPI()->markDirty(parent, GENERATED_ARKUI_DIRTY_FLAG_MEASURE_BY_CHILD_REQUEST); +} +KOALA_INTEROP_V3(InsertChildAfter, KNativePointer, KNativePointer, KNativePointer) + +void impl_SetCustomCallbackId(KVMContext vmContextPtr, KNativePointer nodePtr, KInt callbackId) { + Ark_VMContext vmContext = reinterpret_cast(vmContextPtr); + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetExtendedImpl()->setCustomCallback(vmContext, node, callbackId); +} +KOALA_INTEROP_CTX_V2(SetCustomCallbackId, KNativePointer, KInt) + +KInt impl_MeasureLayoutAndDraw(KVMContext vmContextPtr, KNativePointer nodePtr) { + Ark_VMContext vmContext = reinterpret_cast(vmContextPtr); + Ark_NodeHandle node = reinterpret_cast(nodePtr); + return GetExtendedImpl()->measureLayoutAndDraw(vmContext, node); +} +KOALA_INTEROP_CTX_1(MeasureLayoutAndDraw, KInt, KNativePointer) + +KInt impl_MeasureNode(KVMContext vmContextPtr, KNativePointer nodePtr, KFloat* data) { + Ark_VMContext vmContext = reinterpret_cast(vmContextPtr); + Ark_NodeHandle node = reinterpret_cast(nodePtr); + return GetExtendedImpl()->measureNode(vmContext, node, data); +} +KOALA_INTEROP_CTX_2(MeasureNode, KInt, KNativePointer, KFloat*) + +KInt impl_LayoutNode(KVMContext vmContextPtr, KNativePointer nodePtr, KFloat *data) { + Ark_VMContext vmContext = reinterpret_cast(vmContextPtr); + Ark_NodeHandle node = reinterpret_cast(nodePtr); + return GetExtendedImpl()->layoutNode(vmContext, node, reinterpret_cast(data)); +} +KOALA_INTEROP_CTX_2(LayoutNode, KInt, KNativePointer, KFloat*) + +KInt impl_DrawNode(KVMContext vmContextPtr, KNativePointer nodePtr, KFloat* data) { + Ark_VMContext vmContext = reinterpret_cast(vmContextPtr); + Ark_NodeHandle node = reinterpret_cast(nodePtr); + return GetExtendedImpl()->drawNode(vmContext, node, data); +} +KOALA_INTEROP_CTX_2(DrawNode, KInt, KNativePointer, KFloat*) + +void impl_SetMeasureWidth(KNativePointer nodePtr, KInt value) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetExtendedImpl()->setMeasureWidth(node, value); +} +KOALA_INTEROP_V2(SetMeasureWidth, KNativePointer, KInt) + +KInt impl_GetMeasureWidth(KNativePointer nodePtr) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + return GetExtendedImpl()->getMeasureWidth(node); +} +KOALA_INTEROP_1(GetMeasureWidth, KInt, KNativePointer) + +void impl_SetMeasureHeight(KNativePointer nodePtr, KInt value) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetExtendedImpl()->setMeasureHeight(node, value); +} +KOALA_INTEROP_V2(SetMeasureHeight, KNativePointer, KInt) + +KInt impl_GetMeasureHeight(KNativePointer nodePtr) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + return GetExtendedImpl()->getMeasureHeight(node); +} +KOALA_INTEROP_1(GetMeasureHeight, KInt, KNativePointer) + +void impl_SetX(KNativePointer nodePtr, KInt value) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetExtendedImpl()->setX(node, value); +} +KOALA_INTEROP_V2(SetX, KNativePointer, KInt) + +void impl_SetY(KNativePointer nodePtr, KInt value) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetExtendedImpl()->setY(node, value); +} +KOALA_INTEROP_V2(SetY, KNativePointer, KInt) + +void impl_SetAlignment(KNativePointer nodePtr, KInt value) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetExtendedImpl()->setAlignment(node, value); +} +KOALA_INTEROP_V2(SetAlignment, KNativePointer, KInt) + +KInt impl_GetAlignment(KNativePointer nodePtr) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + return GetExtendedImpl()->getAlignment(node); +} +KOALA_INTEROP_1(GetAlignment, KInt, KNativePointer) + +void impl_SetRangeUpdater(KNativePointer nodePtr, KInt updaterId) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetExtendedImpl()->setRangeUpdater(node, updaterId); +} +KOALA_INTEROP_V2(SetRangeUpdater, KNativePointer, KInt) + +int impl_SetLazyItemIndexer(KVMContext vmContextPtr, KNativePointer nodePtr, KInt indexerId) { + Ark_VMContext vmContext = reinterpret_cast(vmContextPtr); + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetExtendedImpl()->setLazyItemIndexer(vmContext, node, indexerId); + return 0; +} +KOALA_INTEROP_CTX_2(SetLazyItemIndexer, KInt ,KNativePointer, KInt) + +void impl_Dump(KNativePointer nodePtr) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetFullImpl()->getBasicAPI()->dumpTreeNode(node); +} +KOALA_INTEROP_V1(Dump, KNativePointer) + +void nodeFinalizerFunction(ArkUINodeHandle ptr) { + GetFullImpl()->getBasicAPI()->disposeNode(ptr); +} +KNativePointer impl_GetNodeFinalizer() { + return reinterpret_cast(&nodeFinalizerFunction); +} +KOALA_INTEROP_0(GetNodeFinalizer, KNativePointer) + +void impl_EmulateClickEvent(KInt nodeId, KFloat x, KFloat y) { + printf("EMULATE: ON_CLICK: nodeId: %d, x=%f, y=%f\n", nodeId, x, y); + + Ark_ClickEvent event; + event.target.area.width.type = 0; + event.target.area.width.value = 0; + event.target.area.width.unit = 1; + event.target.area.width.resource = 0; + event.target.area.height.type = 0; + event.target.area.height.value = 0; + event.target.area.height.unit = 1; + event.target.area.height.resource = 0; + event.target.area.position.x.tag = ARK_TAG_UNDEFINED; + event.target.area.position.y.tag = ARK_TAG_UNDEFINED; + event.target.area.globalPosition.x.tag = ARK_TAG_UNDEFINED; + event.target.area.globalPosition.y.tag = ARK_TAG_UNDEFINED; + event.timestamp.tag = ARK_TAG_INT32; + event.timestamp.i32 = 100; + event.source = ARK_SOURCE_TYPE_MOUSE; + event.axisHorizontal.tag = ARK_TAG_UNDEFINED; + event.axisVertical.tag = ARK_TAG_UNDEFINED; + event.pressure.tag = ARK_TAG_FLOAT32; + event.pressure.f32 = 0.0f; + event.tiltX.tag = ARK_TAG_FLOAT32; + event.tiltX.f32 = 0.0f; + event.tiltY.tag = ARK_TAG_FLOAT32; + event.tiltY.f32 = 0.0f; + event.sourceTool = ARK_SOURCE_TOOL_MOUSE; + event.deviceId.value.tag = ARK_TAG_INT32; + event.deviceId.value.i32 = 0; + event.displayX.tag = ARK_TAG_FLOAT32; + event.displayX.f32 = 0.0f; + event.displayY.tag = ARK_TAG_FLOAT32; + event.displayY.f32 = 0.0f; + event.windowX.tag = ARK_TAG_FLOAT32; + event.windowX.f32 = 0.0f; + event.windowY.tag = ARK_TAG_FLOAT32; + event.windowY.f32 = 0.0f; + event.screenX.tag = ARK_TAG_FLOAT32; + event.screenX.f32 = 0.0f; + event.screenY.tag = ARK_TAG_FLOAT32; + event.screenY.f32 = 0.0f; + event.x.tag = ARK_TAG_FLOAT32; + event.x.f32 = x; + event.y.tag = ARK_TAG_FLOAT32; + event.y.f32 = y; + event.preventDefault.id = 0; + + GetFullImpl()->getEventsAPI()->getCommonMethodEventsReceiver()->onClick(nodeId, event); +} +KOALA_INTEROP_V3(EmulateClickEvent, KInt, KFloat, KFloat) + +void impl_EmulateTextInputEvent(KInt nodeId, const KStringPtr& text) { + std::string value = getString(text); + printf("EMULATE: ON_TEXT_INPUT text: %s\n", value.c_str()); + Ark_String str { + .chars = value.c_str(), + .length = static_cast(value.length()) + }; + Opt_PreviewText preview; + preview.tag = ARK_TAG_UNDEFINED; + GetFullImpl()->getEventsAPI()->getTextInputEventsReceiver()->onChange(nodeId, str, preview); +} +KOALA_INTEROP_V2(EmulateTextInputEvent, KInt, KStringPtr) + +KInt impl_IndexerChecker(KVMContext vmContextPtr, KNativePointer nodePtr) { + Ark_VMContext vmContext = reinterpret_cast(vmContextPtr); + Ark_NodeHandle node = reinterpret_cast(nodePtr); + return GetExtendedImpl()->indexerChecker(vmContext, node); +} +KOALA_INTEROP_CTX_1(IndexerChecker, KInt, KNativePointer) + +// finial mark flag. +void impl_ApplyModifierFinish(KNativePointer nodePtr) { + Ark_NodeHandle node = reinterpret_cast(nodePtr); + GetFullImpl()->getBasicAPI()->applyModifierFinish(node); +} +KOALA_INTEROP_V1(ApplyModifierFinish, KNativePointer) + +KNativePointer impl_GetPipelineContext(KNativePointer nodePtr) { + auto node = reinterpret_cast(nodePtr); + return GetExtendedImpl()->getPipelineContext(node); +} +KOALA_INTEROP_1(GetPipelineContext, KNativePointer, KNativePointer) + +KInt impl_SetVsyncCallback(KVMContext vmContextPtr, KNativePointer pipelineContextPtr, Ark_Int32 callbackId) { + auto vmContext = reinterpret_cast(vmContextPtr); + auto pipelineContext = reinterpret_cast(pipelineContextPtr); + GetExtendedImpl()->setVsyncCallback(vmContext, pipelineContext, callbackId); + return 0; +} +KOALA_INTEROP_CTX_2(SetVsyncCallback, KInt, KNativePointer, KInt) + +KInt impl_UnblockVsyncWait(KVMContext vmContextPtr, KNativePointer pipelineContextPtr) { + auto vmContext = reinterpret_cast(vmContextPtr); + auto pipelineContext = reinterpret_cast(pipelineContextPtr); + GetExtendedImpl()->unblockVsyncWait(vmContext, pipelineContext); + return 0; +} +KOALA_INTEROP_CTX_1(UnblockVsyncWait, KInt, KNativePointer) + +KNativePointer impl_GetInteropProfile() { +#if KOALA_INTEROP_PROFILER + return new std::string(InteropProfiler::instance()->report()); +#else + return nullptr; +#endif +} +KOALA_INTEROP_0(GetInteropProfile, KNativePointer) + +void impl_ResetInteropProfile() { +#if KOALA_INTEROP_PROFILER + InteropProfiler::instance()->reset(); +#endif +} +KOALA_INTEROP_V0(ResetInteropProfile) + +KNativePointer impl_CaptureUIStructure() { + return 0; +} +KOALA_INTEROP_0(CaptureUIStructure, KNativePointer) + +KInt impl_ElementById(const KStringPtr& elementId) { + return -1; +} +KOALA_INTEROP_1(ElementById, KInt, KStringPtr) + + [[maybe_unused]] static const GENERATED_ArkUIAccessors* GetAccessors() { return GetFullImpl()->getAccessors(); } diff --git a/arkoala/framework/native/src/generated/real_impl.cc b/arkoala/framework/native/src/generated/real_impl.cc index f00302461..e1bc0213a 100644 --- a/arkoala/framework/native/src/generated/real_impl.cc +++ b/arkoala/framework/native/src/generated/real_impl.cc @@ -20762,6 +20762,7 @@ namespace OHOS::Ace::NG::GeneratedModifier { nullptr, OHOS::Ace::NG::GeneratedEvents::GENERATED_GetArkUiEventsAPI, GENERATED_GetExtendedAPI, + GENERATED_GetBasicAPI, OHOS::Ace::NG::GeneratedEvents::GENERATED_SetArkUiEventsAPI }; return &fullAPIImpl; diff --git a/arkoala/framework/src/Application.ts b/arkoala/framework/src/Application.ts index d9885568e..ff0c5e7f7 100644 --- a/arkoala/framework/src/Application.ts +++ b/arkoala/framework/src/Application.ts @@ -142,12 +142,6 @@ function updateStates(manager: StateManager, root: State): void } } -function emulateEvent(event: PeerEvent) { - let bufferInt32 = event.toInt32Array() - withInt32Array(bufferInt32, Access.READ, (bufferPtr: KInt32ArrayPtr) => { - nativeModule()._SendArkoalaEvent(bufferPtr, bufferInt32.length) - }) -} function measureLayoutAndDraw(peerNode: PeerNode) { nativeModule()._MeasureLayoutAndDraw(peerNode.peer.ptr) @@ -197,11 +191,11 @@ async function eventLoopRun( let skipFrames = 0 control.addListener("arkoala.press", (args: Object) => { let event = args as Partial - emulateEvent(new SinglePointerPeerEvent(event.nodeId!, event.x!, event.y!, event.status!)) + nativeModule()._EmulateClickEvent(event.nodeId!, event.x!, event.y!) }) control.addListener("arkoala.text.input", (args: Object) => { let event = args as Partial - emulateEvent(new TextInputEvent(event.nodeId!, event.text!)) + nativeModule()._EmulateTextInputEvent(event.nodeId!, event.text!) }) control.addListener("arkoala.app.exit", (args: Object) => { console.log("Got app exit request") @@ -235,9 +229,11 @@ async function eventLoopRun( if (enableDumpTree) dumpTree(root.value) } catch (e) { currentCrash = e as Object + console.log(e) } } // ... and wait till it is done. + await waitVsyncFunc() if (waitFramesCallback != undefined) { diff --git a/arkoala/framework/src/Events.ts b/arkoala/framework/src/Events.ts index 596f5d47f..653d55572 100644 --- a/arkoala/framework/src/Events.ts +++ b/arkoala/framework/src/Events.ts @@ -13,153 +13,11 @@ * limitations under the License. */ -import { Access, withInt32Array, bitsToPtr, KInt32ArrayPtr } from "@koalaui/interop" -import { nativeModule } from "./generated/NativeModule" -import { NativeString } from "./NativeString" -import { PeerEventKind, CallbackPeerEvent, PeerEvent, SinglePointerPeerEvent, MultiPointerPeerEvent, ComponentAsyncEventSubKind, AppearPeerEvent, DisappearPeerEvent, SwiperChangePeerEvent, TabsChangePeerEvent, VisibleAreaChangePeerEvent, ScrollIndexPeerEvent, NavigatorClickPeerEvent, SwiperAnimationPeerEvent, SliderChangePeerEvent, AreaPosition, AreaChangePeerEvent, BlurPeerEvent, HoverPeerEvent, KeyPeerEvent, MousePeerEvent, CanvasReadyPeerEvent, ListScrollPeerEvent, ListScrollIndexPeerEvent, ListScrollStartPeerEvent, ListScrollStopPeerEvent, ImageCompletePeerEvent, ImageErrorPeerEvent, RefreshStateChangePeerEvent, OnRefreshingPeerEvent, OnRadioChangePeerEvent, GesturePeerEvent, TextInputEvent, GridScrollPeerEvent, GridScrollStartPeerEvent, GridScrollStopPeerEvent, XComponentLoadPeerEvent, XComponentDestroyPeerEvent, AsyncComponentPeerEvent, NavBarStateChangePeerEvent, NavDestinationPeerEvent } from "./PeerEvents" -import { PeerNode } from "./PeerNode" - -const NUM_WORDS = 60 // sizeof(ArkUINodeEvent) / 4 -const bufferInt32 = new Int32Array(NUM_WORDS) export function checkEvents() { customEventsChecker() - while (true) { - let result = withInt32Array(bufferInt32, Access.WRITE, (bufferPtr: KInt32ArrayPtr) => { - return nativeModule()._CheckArkoalaEvents(bufferPtr, NUM_WORDS) - }) - if (result == 0) break - let event = decodeEvent(bufferInt32) - if (event?.kind == PeerEventKind.Callback) { - let callback = event as CallbackPeerEvent - let count = bufferInt32[CallbackPeerEvent.NumArgs] - let continuationId = bufferInt32[CallbackPeerEvent.ContinuationId] - callback.invoke(continuationId, new Int32Array(bufferInt32.subarray(CallbackPeerEvent.ContinuationId + 1, CallbackPeerEvent.ContinuationId + 1 + count))) - if (callback.autoDisposable) { - callback.dispose() - } - } else { - if (event) { - PeerNode.deliverEventFromPeer(event) - } - } - } } - let customEventsChecker = () => {} export function setCustomEventsChecker(eventsChecker: () => void) { customEventsChecker = eventsChecker } - -function decodeEvent(array: Int32Array): PeerEvent | undefined { - let kind = array[PeerEvent.Kind] - let nodeId = array[PeerEvent.NodeId] - // TODO: convert them all to fromInt32Array! - switch (kind) { - case PeerEventKind.SinglePointerInput: { - return SinglePointerPeerEvent.fromInt32Array(array) - } - case PeerEventKind.MultiPointerInput: { - let count = array[6] - return new MultiPointerPeerEvent(nodeId, array.subarray(7, 7 + count), array.subarray(17, 17 + count), array.subarray(27, 27 + count)) - } - case PeerEventKind.Callback: { - let id = array[CallbackPeerEvent.Id] - let result = CallbackPeerEvent.byId(id) - return result - } - case PeerEventKind.ComponentAsyncEvent: { - let subKind = array[AsyncComponentPeerEvent.SubKind] - switch (subKind) { - case ComponentAsyncEventSubKind.OnAppear: - return AppearPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnDisappear: - return DisappearPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnSwiperChange: - return SwiperChangePeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnTabsChange: - return TabsChangePeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnVisibleAreaChange: - return VisibleAreaChangePeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnClick: - // Same as SinglePointerInput case - return SinglePointerPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnListScrollIndex: - return ScrollIndexPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnNavigatorClick: - return NavigatorClickPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnSwiperAnimationStart: - return SwiperAnimationPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnSwiperAnimationEnd: - return SwiperAnimationPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnSwiperGestureSwipe: - return SwiperAnimationPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnSliderChange: - return SliderChangePeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnAreaChange: - let oldValue = new AreaPosition(array[7], array[8], array[9], array[10] , array[11], array[12]) - let newValue = new AreaPosition(array[13], array[14], array[15], array[16] , array[17], array[18]) - return new AreaChangePeerEvent(nodeId, oldValue, newValue) - case ComponentAsyncEventSubKind.OnBlur: - return BlurPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnHover: - return HoverPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnKeyEvent: - let keyTextSting = new NativeString(bitsToPtr(array, 11)) - return new KeyPeerEvent(nodeId, array[7], array[8], keyTextSting.toString(), array[9], array[10], array[11], array[12], array[13]) - case ComponentAsyncEventSubKind.OnMouse: - return MousePeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnCanvasReady: - return CanvasReadyPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnListScroll: - return ListScrollPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnListScrollIndex: - return ListScrollIndexPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnListScrollStart: - return ListScrollStartPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnListScrollStop: - return ListScrollStopPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnImageComplete: - return ImageCompletePeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnImageError: - let errorMessage = new NativeString(bitsToPtr(array, 7)) - return new ImageErrorPeerEvent(nodeId, array[7], array[8], errorMessage.toString()) - case ComponentAsyncEventSubKind.OnRefreshStateChange: - return RefreshStateChangePeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnRefreshRefreshing: - return OnRefreshingPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnRadioChange: - return OnRadioChangePeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnGridScroll: - return GridScrollPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnGridStart: - return GridScrollStartPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnGridStop: - return GridScrollStopPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnXComponentLoad: - let nativeString = new NativeString(bitsToPtr(array, 7)) - return new XComponentLoadPeerEvent(nodeId, nativeString.toString()) - case ComponentAsyncEventSubKind.OnXComponentDestroy: - return XComponentDestroyPeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.OnNavBarStateChange: - return NavBarStateChangePeerEvent.fromInt32Array(array) - case ComponentAsyncEventSubKind.NavDestination: - let name = new NativeString(bitsToPtr(array, 7)) - return new NavDestinationPeerEvent(nodeId, name.toString(), 0) - default: /* unknown */ { - throw new Error(`ComponentAsyncEvent subKind ${subKind} is not supported`) - } - } - } - case PeerEventKind.GestureAsyncEvent: { - let subKind = array[6] - return new GesturePeerEvent(nodeId, subKind, array.slice(7)) - } - case PeerEventKind.TextInput: { - return TextInputEvent.fromInt32Array(array) - } - default: /* unknown */ { - throw new Error(`Event kind ${kind} is not supported`) - } - } -} diff --git a/arkoala/framework/src/generated/NativeModule.ts b/arkoala/framework/src/generated/NativeModule.ts index e29c9af20..62082cec8 100644 --- a/arkoala/framework/src/generated/NativeModule.ts +++ b/arkoala/framework/src/generated/NativeModule.ts @@ -2294,6 +2294,18 @@ export interface ComponentOps { _LinearIndicatorController_start(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void _LinearIndicatorController_pause(ptr: KPointer): void _LinearIndicatorController_stop(ptr: KPointer): void + _UIExtensionProxy_ctor(): KPointer + _UIExtensionProxy_getFinalizer(): KPointer + _UIExtensionProxy_send(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void + _UIExtensionProxy_sendSync(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): KPointer + _UIExtensionProxy_on0(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void + _UIExtensionProxy_on1(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void + _UIExtensionProxy_off0(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void + _UIExtensionProxy_off1(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void + _CheckArkoalaGeneratedEvents(result: Uint8Array, size: KInt): KInt + _CheckArkoalaGeneratedEvents(result: Uint8Array, size: KInt): KInt + _EmulateClickEvent(nodeId: KInt, x: KFloat, y: KFloat): void + _EmulateTextInputEvent(nodeId: KInt, text: KStringPtr): void } export interface TestOps { diff --git a/arkoala/framework/src/generated/NativeModuleEmpty.ts b/arkoala/framework/src/generated/NativeModuleEmpty.ts index d59de47a7..12f1b7e9f 100644 --- a/arkoala/framework/src/generated/NativeModuleEmpty.ts +++ b/arkoala/framework/src/generated/NativeModuleEmpty.ts @@ -6885,21 +6885,6 @@ export class NativeModuleEmptyIntegrated implements NativeModuleIntegrated { console.log("_WaterFlowSections_length") return this } - _UIExtensionProxy_ctor(): KPointer { - console.log("_UIExtensionProxy_ctor") - return -1 - } - _UIExtensionProxy_getFinalizer(): KPointer { - console.log("_UIExtensionProxy_getFinalizer") - return -1 - } - _UIExtensionProxy_send(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void { - console.log("_UIExtensionProxy_send") - } - _UIExtensionProxy_sendSync(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): this { - console.log("_UIExtensionProxy_sendSync") - return this - } _UIExtensionProxy_onAsyncReceiverRegister(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void { console.log("_UIExtensionProxy_onAsyncReceiverRegister") } @@ -7031,6 +7016,39 @@ export class NativeModuleEmptyIntegrated implements NativeModuleIntegrated { _LinearIndicatorController_stop(ptr: KPointer): void { console.log("_LinearIndicatorController_stop") } + _UIExtensionProxy_ctor(): KPointer { + console.log("_UIExtensionProxy_ctor") + return -1 + } + _UIExtensionProxy_getFinalizer(): KPointer { + console.log("_UIExtensionProxy_getFinalizer") + return -1 + } + _UIExtensionProxy_send(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void { + console.log("_UIExtensionProxy_send") + } + _UIExtensionProxy_sendSync(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): KPointer { + console.log("_UIExtensionProxy_sendSync") + return -1 + } + _UIExtensionProxy_on0(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { + console.log("_UIExtensionProxy_on0") + } + _UIExtensionProxy_on1(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { + console.log("_UIExtensionProxy_on1") + } + _UIExtensionProxy_off0(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { + console.log("_UIExtensionProxy_off0") + } + _UIExtensionProxy_off1(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { + console.log("_UIExtensionProxy_off1") + } + _EmulateClickEvent(nodeId: number, x: number, y: number) { + console.log("_EmulateClickEvent") + } + _EmulateTextInputEvent(nodeId: number, text: KStringPtr) { + console.log("_EmulateTextInputEvent") + } _SetCallbackDispatcher(dispatcher: (id: int32, args: Uint8Array, length: int32) => int32): void { throw new Error("_SetCallbackDispatcher") } -- Gitee From fdccd35d30a6ea03ebb4382e0fd49ebe749c9295 Mon Sep 17 00:00:00 2001 From: Korobeinikov Evgeny Date: Tue, 5 Nov 2024 15:41:18 +0300 Subject: [PATCH 2/3] callbacks fix for click --- .../native/src/generated/bridge_generated.cc | 12 +++-- .../framework/src/generated/NativeModule.ts | 20 ++----- .../src/generated/NativeModuleEmpty.ts | 54 +++++++++---------- 3 files changed, 39 insertions(+), 47 deletions(-) diff --git a/arkoala/framework/native/src/generated/bridge_generated.cc b/arkoala/framework/native/src/generated/bridge_generated.cc index 8f57b6399..4a8ef405e 100644 --- a/arkoala/framework/native/src/generated/bridge_generated.cc +++ b/arkoala/framework/native/src/generated/bridge_generated.cc @@ -12,7 +12,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "library.h" #include "common-interop.h" #include "arkoala_api_generated.h" #include "Serializers.h" @@ -291,7 +290,7 @@ KOALA_INTEROP_CTX_2(MeasureNode, KInt, KNativePointer, KFloat*) KInt impl_LayoutNode(KVMContext vmContextPtr, KNativePointer nodePtr, KFloat *data) { Ark_VMContext vmContext = reinterpret_cast(vmContextPtr); Ark_NodeHandle node = reinterpret_cast(nodePtr); - return GetExtendedImpl()->layoutNode(vmContext, node, reinterpret_cast(data)); + return GetExtendedImpl()->layoutNode(vmContext, node, reinterpret_cast(data)); } KOALA_INTEROP_CTX_2(LayoutNode, KInt, KNativePointer, KFloat*) @@ -370,7 +369,7 @@ void impl_Dump(KNativePointer nodePtr) { } KOALA_INTEROP_V1(Dump, KNativePointer) -void nodeFinalizerFunction(ArkUINodeHandle ptr) { +void nodeFinalizerFunction(Ark_NodeHandle ptr) { GetFullImpl()->getBasicAPI()->disposeNode(ptr); } KNativePointer impl_GetNodeFinalizer() { @@ -424,9 +423,12 @@ void impl_EmulateClickEvent(KInt nodeId, KFloat x, KFloat y) { event.x.f32 = x; event.y.tag = ARK_TAG_FLOAT32; event.y.f32 = y; - event.preventDefault.id = 0; + event.preventDefault.resource.resourceId = 0; + event.preventDefault.resource.hold = [](KInt id){}; + event.preventDefault.resource.release = [](KInt id){}; + event.preventDefault.call = [](KInt id){}; - GetFullImpl()->getEventsAPI()->getCommonMethodEventsReceiver()->onClick(nodeId, event); + GetFullImpl()->getEventsAPI()->getLocationButtonEventsReceiver()->onClick(nodeId, event, ARK_LOCATION_BUTTON_ON_CLICK_RESULT_SUCCESS); } KOALA_INTEROP_V3(EmulateClickEvent, KInt, KFloat, KFloat) diff --git a/arkoala/framework/src/generated/NativeModule.ts b/arkoala/framework/src/generated/NativeModule.ts index 62082cec8..f5f9010eb 100644 --- a/arkoala/framework/src/generated/NativeModule.ts +++ b/arkoala/framework/src/generated/NativeModule.ts @@ -120,7 +120,9 @@ export interface InteropOps { _DumpPerf(arg: int32): KPointer _CheckArkoalaEvents(result: KInt32ArrayPtr, count: KInt): KInt _SendArkoalaEvent(event: KInt32ArrayPtr, count: KInt): void - _CheckArkoalaGeneratedEvents(result: Uint8Array, size: int32): int32 + _CheckArkoalaGeneratedEvents(result: Uint8Array, size: int32): int32 + _EmulateClickEvent(nodeId: KInt, x: KFloat, y: KFloat): void + _EmulateTextInputEvent(nodeId: KInt, text: KStringPtr): void _GetManagerCallbackCaller(callbackKind: int32): KPointer _GetManagedResourceHolder(): KPointer _GetManagedResourceReleaser(): KPointer @@ -2255,7 +2257,7 @@ export interface ComponentOps { _UIExtensionProxy_ctor(): KPointer _UIExtensionProxy_getFinalizer(): KPointer _UIExtensionProxy_send(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void - _UIExtensionProxy_sendSync(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): this + _UIExtensionProxy_sendSync(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): KPointer _UIExtensionProxy_onAsyncReceiverRegister(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void _UIExtensionProxy_onSyncReceiverRegister(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void _UIExtensionProxy_offAsyncReceiverRegister(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void @@ -2293,19 +2295,7 @@ export interface ComponentOps { _LinearIndicatorController_setProgress(ptr: KPointer, index: number, progress: number): void _LinearIndicatorController_start(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void _LinearIndicatorController_pause(ptr: KPointer): void - _LinearIndicatorController_stop(ptr: KPointer): void - _UIExtensionProxy_ctor(): KPointer - _UIExtensionProxy_getFinalizer(): KPointer - _UIExtensionProxy_send(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void - _UIExtensionProxy_sendSync(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): KPointer - _UIExtensionProxy_on0(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void - _UIExtensionProxy_on1(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void - _UIExtensionProxy_off0(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void - _UIExtensionProxy_off1(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void - _CheckArkoalaGeneratedEvents(result: Uint8Array, size: KInt): KInt - _CheckArkoalaGeneratedEvents(result: Uint8Array, size: KInt): KInt - _EmulateClickEvent(nodeId: KInt, x: KFloat, y: KFloat): void - _EmulateTextInputEvent(nodeId: KInt, text: KStringPtr): void + _LinearIndicatorController_stop(ptr: KPointer): void } export interface TestOps { diff --git a/arkoala/framework/src/generated/NativeModuleEmpty.ts b/arkoala/framework/src/generated/NativeModuleEmpty.ts index 12f1b7e9f..e2baf98a3 100644 --- a/arkoala/framework/src/generated/NativeModuleEmpty.ts +++ b/arkoala/framework/src/generated/NativeModuleEmpty.ts @@ -6885,6 +6885,33 @@ export class NativeModuleEmptyIntegrated implements NativeModuleIntegrated { console.log("_WaterFlowSections_length") return this } + _UIExtensionProxy_ctor(): KPointer { + console.log("_UIExtensionProxy_ctor") + return -1 + } + _UIExtensionProxy_getFinalizer(): KPointer { + console.log("_UIExtensionProxy_getFinalizer") + return -1 + } + _UIExtensionProxy_send(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void { + console.log("_UIExtensionProxy_send") + } + _UIExtensionProxy_sendSync(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): KPointer { + console.log("_UIExtensionProxy_sendSync") + return -1 + } + _UIExtensionProxy_on0(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { + console.log("_UIExtensionProxy_on0") + } + _UIExtensionProxy_on1(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { + console.log("_UIExtensionProxy_on1") + } + _UIExtensionProxy_off0(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { + console.log("_UIExtensionProxy_off0") + } + _UIExtensionProxy_off1(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { + console.log("_UIExtensionProxy_off1") + } _UIExtensionProxy_onAsyncReceiverRegister(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void { console.log("_UIExtensionProxy_onAsyncReceiverRegister") } @@ -7016,33 +7043,6 @@ export class NativeModuleEmptyIntegrated implements NativeModuleIntegrated { _LinearIndicatorController_stop(ptr: KPointer): void { console.log("_LinearIndicatorController_stop") } - _UIExtensionProxy_ctor(): KPointer { - console.log("_UIExtensionProxy_ctor") - return -1 - } - _UIExtensionProxy_getFinalizer(): KPointer { - console.log("_UIExtensionProxy_getFinalizer") - return -1 - } - _UIExtensionProxy_send(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): void { - console.log("_UIExtensionProxy_send") - } - _UIExtensionProxy_sendSync(ptr: KPointer, thisArray: Uint8Array, thisLength: int32): KPointer { - console.log("_UIExtensionProxy_sendSync") - return -1 - } - _UIExtensionProxy_on0(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { - console.log("_UIExtensionProxy_on0") - } - _UIExtensionProxy_on1(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { - console.log("_UIExtensionProxy_on1") - } - _UIExtensionProxy_off0(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { - console.log("_UIExtensionProxy_off0") - } - _UIExtensionProxy_off1(ptr: KPointer, type: KStringPtr, thisArray: Uint8Array, thisLength: int32): void { - console.log("_UIExtensionProxy_off1") - } _EmulateClickEvent(nodeId: number, x: number, y: number) { console.log("_EmulateClickEvent") } -- Gitee From b743b0cc62c07165955bb009b8feb86ba92dc0e7 Mon Sep 17 00:00:00 2001 From: Korobeinikov Evgeny Date: Tue, 5 Nov 2024 16:48:10 +0300 Subject: [PATCH 3/3] include fix --- arkoala/framework/native/src/generated/bridge_generated.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/arkoala/framework/native/src/generated/bridge_generated.cc b/arkoala/framework/native/src/generated/bridge_generated.cc index 4a8ef405e..727f94887 100644 --- a/arkoala/framework/native/src/generated/bridge_generated.cc +++ b/arkoala/framework/native/src/generated/bridge_generated.cc @@ -16,7 +16,6 @@ #include "arkoala_api_generated.h" #include "Serializers.h" #include "arkoala-logging.h" -#include <__config> #include #include #include "logging.h" -- Gitee