From a3f19ea07ee13d022fd0963ff46cafce2beae686 Mon Sep 17 00:00:00 2001 From: xia5804 Date: Fri, 1 Aug 2025 12:21:26 +0800 Subject: [PATCH] createWebDocumentAdapter Signed-off-by: xia5804 --- .../ani/webview/ets/@ohos.web.webview.ets | 30 ++ .../ani/webview/src/common/ani_class_name.h | 1 + .../webview/src/common/ani_parse_utils.cpp | 47 ++- .../ani/webview/src/common/ani_parse_utils.h | 2 + .../kits/ani/webview/src/sts_web_webview.cpp | 1 + .../ani_webview_controller.cpp | 353 ++++++++++++++++++ .../ani_webview_controller.h | 1 + ...ani_webview_createpdf_execute_callback.cpp | 2 +- 8 files changed, 419 insertions(+), 18 deletions(-) diff --git a/interfaces/kits/ani/webview/ets/@ohos.web.webview.ets b/interfaces/kits/ani/webview/ets/@ohos.web.webview.ets index f293c4c63..0db0632a2 100644 --- a/interfaces/kits/ani/webview/ets/@ohos.web.webview.ets +++ b/interfaces/kits/ani/webview/ets/@ohos.web.webview.ets @@ -16,6 +16,7 @@ import { Resource } from 'global.resource'; import type image from '@ohos.multimedia.image'; import { AsyncCallback, BusinessError, Callback } from '@ohos.base'; import { WebNetErrorList } from '@ohos.web.netErrorList'; +import print from '@ohos.print' class Cleaner { private ptr: long = 0 @@ -686,6 +687,7 @@ export default namespace webview { native getSurfaceId(): string; native static enableWholeWebPageDrawing(): void; native setPrintBackground(enable: boolean): void; + native createWebPrintDocumentAdapter(jobName: string): print.PrintDocumentAdapter; native getPrintBackground(): boolean; native webPageSnapshot(info: SnapshotInfo, callback: AsyncCallback): void; native injectOfflineResourcesInternal(resourceMaps: Array) : void; @@ -1827,4 +1829,32 @@ export default namespace webview { native getArrayBuffer(): ArrayBuffer; native getArray(): Array; } + + export class PrintDocumentAdapterInner implements print.PrintDocumentAdapter{ + static { + loadLibrary("webview_ani.z"); + } + private nativePtr: long = 0; + private cleaner?: Cleaner; + + registerCleaner(ptr: long): void { + this.cleaner = new Cleaner(ptr, "PrintDocumentAdapterInner") + destroyRegister.register(this, this.cleaner!, unregisterToken); + } + unregisterCleaner(): void { + destroyRegister.unregister(unregisterToken); + } + + bindNativePtr(ptr: long): void { + if (this.nativePtr == 0) { + this.nativePtr = ptr; + this.registerCleaner(this.nativePtr) + } + } + + native onStartLayoutWrite(jobId: string, oldAttrs: print.PrintAttributes, newAttrs: print.PrintAttributes, fd: int, + writeResultCallback: (jobId: string, writeResult: print.PrintFileCreationState) => void): void; + + native onJobStateChanged(jobId: string, state: print.PrintDocumentAdapterState): void; + } } diff --git a/interfaces/kits/ani/webview/src/common/ani_class_name.h b/interfaces/kits/ani/webview/src/common/ani_class_name.h index 13f5ab183..be03142df 100644 --- a/interfaces/kits/ani/webview/src/common/ani_class_name.h +++ b/interfaces/kits/ani/webview/src/common/ani_class_name.h @@ -38,6 +38,7 @@ const char* ANI_ENUM_MEDIA_PLAY_BACK_STATE = "L@ohos/web/webview/webview/MediaPl const char* ANI_SNAPSHOT_RESULT_CLASS_NAME = "L@ohos/web/webview/webview/SnapshotResultClass;"; const char* ANI_PDF_DATA_CLASS_NAME = "L@ohos/web/webview/webview/PdfData;"; const char* ANI_CLASS_WEB_RESOURCETYPE = "L@ohos/web/webview/webview/WebResourceType;"; +const char* ANI_PRINT_DOCUMENT_ADAPTER_INNER_CLASS_NAME = "L@ohos/web/webview/webview/PrintDocumentAdapterInner;"; } // namespace NWeb } // namespace OHOS diff --git a/interfaces/kits/ani/webview/src/common/ani_parse_utils.cpp b/interfaces/kits/ani/webview/src/common/ani_parse_utils.cpp index fe539a476..89e1f4176 100644 --- a/interfaces/kits/ani/webview/src/common/ani_parse_utils.cpp +++ b/interfaces/kits/ani/webview/src/common/ani_parse_utils.cpp @@ -306,6 +306,25 @@ bool AniParseUtils::ParseStringArrayMap(ani_env* env, ani_object argv, std::map< return true; } +bool AniParseUtils::EnumParseInt32_t(ani_env* env, ani_enum_item enum_item, int32_t& outValue) +{ + ani_class doubleObject; + if (env->FindClass("Lstd/core/Object;", &doubleObject) != ANI_OK) { + WVLOG_E("EnumParseInt32 failed - invalid FindClass type"); + return false; + } + ani_boolean isObject; + if (env->Object_InstanceOf(static_cast(enum_item), doubleObject, &isObject) != ANI_OK || + isObject != ANI_TRUE) { + WVLOG_E("EnumParseInt32 failed - invalid int type"); + return false; + } + ani_int number = 0; + env->EnumItem_GetValue_Int(enum_item, &number); + outValue = static_cast(number); + return true; +} + bool AniParseUtils::GetStringList(ani_env *env, ani_object array, std::vector& outValue) { ani_double arrayLength; @@ -1267,33 +1286,27 @@ ani_ref AniParseUtils::ConvertNWebToAniValue(ani_env* env, std::shared_ptrsecond(env, src); } -bool AniParseUtils::ParseArrayBuffer(ani_env* env, ani_object script, std::string& outValue) +bool AniParseUtils::GetRefProperty(ani_env* env, ani_object param, const char* name, ani_ref& value) { - if (!env) { - WVLOG_E("env is nullptr"); + if (env == nullptr) { + WVLOG_E("null env"); return false; } - ani_boolean isArrayBuffer = false; - ani_class arrayBufferClass; + ani_status status; - if ((status = env->FindClass("Lescompat/ArrayBuffer;", &arrayBufferClass)) != ANI_OK) { - WVLOG_E("find buffer class error status : %{public}d", status); + ani_boolean isUndefined = true; + + if ((status = env->Object_GetPropertyByName_Ref(param, name, &value)) != ANI_OK) { + WVLOG_E("status: %{public}d, name : %{public}s", status, name); return false; } - if ((env->Object_InstanceOf(script, arrayBufferClass, &isArrayBuffer) != ANI_OK) || !isArrayBuffer) { - WVLOG_E("Object_InstanceOf error status : %{public}d", status); + if ((status = env->Reference_IsUndefined(value, &isUndefined)) != ANI_OK) { + WVLOG_E("status: %{public}d, name : %{public}s", status, name); return false; } - - char* arrBuf = nullptr; - size_t byteLength = 0; - if ((status = env->ArrayBuffer_GetInfo( - static_cast(script), reinterpret_cast(&arrBuf), &byteLength)) != ANI_OK) { - WVLOG_E("ArrayBuffer_GetInfo error status : %{public}d", status); + if (isUndefined) { return false; } - - outValue = std::string(arrBuf, byteLength); return true; } } diff --git a/interfaces/kits/ani/webview/src/common/ani_parse_utils.h b/interfaces/kits/ani/webview/src/common/ani_parse_utils.h index 1a3d0f481..61ba4fd11 100644 --- a/interfaces/kits/ani/webview/src/common/ani_parse_utils.h +++ b/interfaces/kits/ani/webview/src/common/ani_parse_utils.h @@ -49,6 +49,7 @@ public: const char *keyName, std::string keyValue); static std::shared_ptr ParseCacheOptions(ani_env* env, ani_object cacheOptions); static bool ParseStringArray(ani_env* env, ani_object argv, std::vector& outValue); + static bool EnumParseInt32_t(ani_env* env, ani_enum_item enum_item, int32_t& outValue); static bool ParseStringArrayMap(ani_env* env, ani_object argv, std::map& outValue); static bool GetStringList(ani_env *env, ani_object array, std::vector& outValue); static bool ParseIP(ani_env *env, ani_object urlObj, std::string& ip); @@ -78,6 +79,7 @@ public: int& fd, size_t& scriptLength); static ani_ref ConvertNWebToAniValue(ani_env *env, std::shared_ptr src); static bool ParseArrayBuffer(ani_env *env, ani_object script, std::string& outValue); + static bool GetRefProperty(ani_env* env, ani_object param, const char* name, ani_ref& value); }; } // namespace NWeb } // namespace OHOS diff --git a/interfaces/kits/ani/webview/src/sts_web_webview.cpp b/interfaces/kits/ani/webview/src/sts_web_webview.cpp index 297eb7b75..e47f91cd4 100644 --- a/interfaces/kits/ani/webview/src/sts_web_webview.cpp +++ b/interfaces/kits/ani/webview/src/sts_web_webview.cpp @@ -71,6 +71,7 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result) StsWebSchemeHandlerResourceInit(env); StsWebSchemeHandlerRequestInit(env); StsWebSchemeHandlerInit(env); + StsPrintDocumentAdapterInit(env); *result = ANI_VERSION_1; return ANI_OK; } diff --git a/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.cpp b/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.cpp index 70e6cd70b..b2379cacb 100644 --- a/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.cpp +++ b/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.cpp @@ -104,6 +104,7 @@ constexpr double SCALE_MAX = 2.0; constexpr double HALF = 2.0; constexpr double TEN_MILLIMETER_TO_INCH = 0.39; const char* ANI_WEB_CUSTOM_SCHEME_CLASS = "L@ohos/web/webview/webview/WebCustomSchemeClass;"; +using WebPrintWriteResultCallback = std::function; struct PDFMarginConfig { double top = TEN_MILLIMETER_TO_INCH; double bottom = TEN_MILLIMETER_TO_INCH; @@ -479,6 +480,8 @@ static void Clean(ani_env *env, ani_object object) reinterpret_cast(ptr)->DecStrongRef(reinterpret_cast(ptr)); } else if (clsName == "WebHttpBodyStream") { delete reinterpret_cast(ptr); + } else if (clsName == "PrintDocumentAdapterInner") { + delete reinterpret_cast(ptr); } else { WVLOG_E("Clean unsupport className: %{public}s", clsName.c_str()); } @@ -4788,6 +4791,354 @@ static void RunJavaScriptCallbackExt(ani_env* env, ani_object object, ani_object return RunJSCallback(env, object, script, callbackObj, true); } +static ani_ref CreateWebPrintDocumentAdapter(ani_env* env, ani_object object, ani_string jobName) +{ + if (env == nullptr) { + WVLOG_E("env is nullptr"); + return nullptr; + } + std::string jobNameString; + if (!AniParseUtils::ParseString(env, jobName, jobNameString)) { + AniBusinessError::ThrowError(env, PARAM_CHECK_ERROR, + NWebError::FormatString(ParamCheckErrorMsgTemplate::TYPE_ERROR, "jopName", "string")); + return nullptr; + } + + auto* controller = reinterpret_cast(AniParseUtils::Unwrap(env, object)); + if (!controller || !controller->IsInit()) { + AniBusinessError::ThrowErrorByErrCode(env, INIT_ERROR); + return nullptr; + } + + void* webPrintDocument = controller->CreateWebPrintDocumentAdapter(jobNameString); + if (!webPrintDocument) { + WVLOG_E("failed to Unwrap webPrintDocument"); + AniBusinessError::ThrowErrorByErrCode(env, PARAM_CHECK_ERROR); + return nullptr; + } + + WebPrintDocument* webPrintDoc = new (std::nothrow) WebPrintDocument(webPrintDocument); + if (webPrintDoc == nullptr) { + WVLOG_E("new web print failed"); + return nullptr; + } + + ani_object printDocumentAdapterObj = {}; + if (AniParseUtils::CreateObjectVoid( + env, "L@ohos/web/webview/webview/PrintDocumentAdapterInner;", printDocumentAdapterObj) == false) { + WVLOG_E("[printDocumentAdapter] CreateObjectVoid failed"); + return nullptr; + } + + WVLOG_I("webPrintDoc is %{public}p", webPrintDoc); + if (!AniParseUtils::Wrap(env, printDocumentAdapterObj, "L@ohos/web/webview/webview/PrintDocumentAdapterInner;", + reinterpret_cast(webPrintDoc))) { + WVLOG_E("[printDocumentAdapter] WebDownloadDelegate wrap failed"); + delete webPrintDoc; + webPrintDoc = nullptr; + return nullptr; + } + return printDocumentAdapterObj; +} + +static void OnJobStateChanged(ani_env* env, ani_object object, ani_string jobId, ani_enum_item state) +{ + if (env == nullptr) { + WVLOG_E("env is nullptr"); + return; + } + WebPrintDocument* webPrintDocument = reinterpret_cast(AniParseUtils::Unwrap(env, object)); + if (!webPrintDocument) { + WVLOG_E("failed to Unwrap webPrintDocument"); + AniBusinessError::ThrowErrorByErrCode(env, INIT_ERROR); + return; + } + std::string jobIDString; + if (!AniParseUtils::ParseString(env, jobId, jobIDString)) { + WVLOG_E("failed to parse jobId"); + AniBusinessError::ThrowErrorByErrCode(env, PARAM_CHECK_ERROR); + return; + } + int32_t stateInt = 0; + if (!AniParseUtils::EnumParseInt32_t(env, state, stateInt)) { + WVLOG_E("failed to parse state"); + AniBusinessError::ThrowErrorByErrCode(env, PARAM_CHECK_ERROR); + return; + } + webPrintDocument->OnJobStateChanged(jobIDString, stateInt); + return; +} + +WebPrintWriteResultCallback ParseWebPrintWriteResultCallback(ani_env* env, ani_object object, ani_fn_object callback) +{ + WVLOG_D("ParseWebPrintWriteResultCallback"); + if (env == nullptr) { + WVLOG_E("env is nullptr"); + return nullptr; + } + + ani_ref callbackRef; + + if (env->GlobalReference_Create(static_cast(callback), &callbackRef) != ANI_OK) { + WVLOG_E("failed to create reference for callback"); + return nullptr; + } + + auto pCallback = [env, cbRef = std::move(callbackRef)](std::string jobId, uint32_t state) { + std::vector argv; + ani_string jobIdString; + if (env->String_NewUTF8(jobId.c_str(), jobId.size(), &jobIdString) == ANI_OK) { + argv.push_back(static_cast(jobIdString)); + } + ani_enum_item stateEnum; + if (AniParseUtils::GetEnumItemByIndex( + env, "L@ohos/print/print/PrintFileCreationState;", static_cast(state), stateEnum)) { + argv.push_back(static_cast(stateEnum)); + } + ani_ref fnReturnVal; + env->FunctionalObject_Call(reinterpret_cast(cbRef), argv.size(), argv.data(), &fnReturnVal); + env->GlobalReference_Delete(cbRef); + }; + return pCallback; +} + +static void ParsePrintRangeAdapter(ani_env* env, ani_object pageRange, PrintAttributesAdapter& printAttr) +{ + if (env == nullptr) { + WVLOG_E("env is nullptr"); + return; + } + + if (!pageRange) { + WVLOG_E("ParsePrintRangeAdapter failed."); + return; + } + ani_int startPage; + ani_int endPage; + ani_ref pages; + if (env->Object_GetPropertyByName_Int(pageRange, "startPage", &startPage) != ANI_OK) { + WVLOG_E("ParsePrintRangeAdapter failed to get startPage"); + } + + if (env->Object_GetPropertyByName_Int(pageRange, "endPage", &endPage) != ANI_OK) { + WVLOG_E("ParsePrintRangeAdapter failed to get startPage"); + } + + if (env->Object_GetPropertyByName_Ref(pageRange, "pages", &pages) != ANI_OK) { + WVLOG_E("ParsePrintRangeAdapter failed to get pages"); + } + ani_array_int pagesArrayInt = static_cast(pages); + + printAttr.pageRange.startPage = static_cast(startPage); + + printAttr.pageRange.endPage = static_cast(endPage); + WVLOG_D("printAttr.pageRange.startPage is %{public}d,printAttr.pageRange.endPage is %{public}d", + printAttr.pageRange.startPage, printAttr.pageRange.endPage); + + ani_size length = 0; + env->Array_GetLength(pagesArrayInt, &length); + for (uint32_t i = 0; i < length; ++i) { + ani_int pagesInt; + env->Array_GetRegion_Int(pagesArrayInt, i, length, &pagesInt); + int pagesNum = static_cast(pagesInt); + printAttr.pageRange.pages.push_back(pagesNum); + } +} + +static void ParsePrintPageSizeAdapter(ani_env* env, ani_object pageSize, PrintAttributesAdapter& printAttr) +{ + if (env == nullptr) { + WVLOG_E("env is nullptr"); + return; + } + + if (!pageSize) { + WVLOG_E("ParsePrintPageSizeAdapter failed."); + return; + } + + ani_int width; + ani_int height; + if (env->Object_GetPropertyByName_Int(pageSize, "width", &width) != ANI_OK) { + WVLOG_E("ParsePrintPageSizeAdapter failed to get width"); + } + if (env->Object_GetPropertyByName_Int(pageSize, "height", &height)) { + WVLOG_E("ParsePrintPageSizeAdapter failed to get height"); + } + + printAttr.pageSize.width = static_cast(width); + printAttr.pageSize.height = static_cast(height); + WVLOG_D("width is %{public}d,height is %{public}d", printAttr.pageSize.width, printAttr.pageSize.height); +} + +static void ParsePrintMarginAdapter(ani_env* env, ani_object margin, PrintAttributesAdapter& printAttr) +{ + if (env == nullptr) { + WVLOG_E("env is nullptr"); + return; + } + + if (!margin) { + WVLOG_E("ParsePrintMarginAdapter failed."); + return; + } + + ani_int top; + ani_int bottom; + ani_int left; + ani_int right; + if (env->Object_GetPropertyByName_Int(margin, "top", &top) != ANI_OK) { + WVLOG_D("ParsePrintMarginAdapter failed to get top"); + } + if (env->Object_GetPropertyByName_Int(margin, "bottom", &bottom) != ANI_OK) { + WVLOG_D("ParsePrintMarginAdapter failed to get bottom"); + } + if (env->Object_GetPropertyByName_Int(margin, "left", &left) != ANI_OK) { + WVLOG_D("ParsePrintMarginAdapter failed to get left"); + } + if (env->Object_GetPropertyByName_Int(margin, "right", &right) != ANI_OK) { + WVLOG_D("ParsePrintMarginAdapter failed to get right"); + } + + printAttr.margin.top = static_cast(top); + printAttr.margin.bottom = static_cast(bottom); + printAttr.margin.left = static_cast(left); + printAttr.margin.right = static_cast(right); + WVLOG_D("top is %{public}d,bottom is %{public}d,left is %{public}d,right is %{public}d", printAttr.margin.top, + printAttr.margin.bottom, printAttr.margin.left, printAttr.margin.right); +} + +static bool ParseWebPrintAttrParams(ani_env* env, ani_object obj, PrintAttributesAdapter& printAttr) +{ + if (env == nullptr) { + WVLOG_E("env is nullptr"); + return false; + } + + if (!obj) { + WVLOG_E("ParseWebPrintAttrParams failed."); + return false; + } + ani_ref copyNumber_ref; + ani_ref pageRange_ref; + ani_ref isSequential_ref; + ani_ref pageSize_ref; + ani_ref isLandscape_ref; + ani_ref colorMode_ref; + ani_ref duplexMode_ref; + ani_ref margin; + + int32_t copyNumber = 0; + if (AniParseUtils::GetRefProperty(env, obj, "copyNumber", copyNumber_ref)) { + AniParseUtils::ParseInt32(env, copyNumber_ref, copyNumber); + } + + if (AniParseUtils::GetRefProperty(env, obj, "pageRange", pageRange_ref)) { + ParsePrintRangeAdapter(env, static_cast(pageRange_ref), printAttr); + } + + bool isSequential = false; + if (AniParseUtils::GetRefProperty(env, obj, "isSequential", isSequential_ref)) { + AniParseUtils::ParseBoolean(env, isSequential_ref, isSequential); + } + + if (AniParseUtils::GetRefProperty(env, obj, "pageSize", pageSize_ref)) { + ParsePrintPageSizeAdapter(env, static_cast(pageSize_ref), printAttr); + } + + bool isLandscape = false; + if (AniParseUtils::GetRefProperty(env, obj, "isSequential", isLandscape_ref)) { + AniParseUtils::ParseBoolean(env, isLandscape_ref, isLandscape); + } + + int32_t colorMode = 0; + if (AniParseUtils::GetRefProperty(env, obj, "colorMode", colorMode_ref)) { + AniParseUtils::ParseInt32(env, colorMode_ref, colorMode); + } + + int32_t duplexMode = 0; + if (AniParseUtils::GetRefProperty(env, obj, "duplexMode", duplexMode_ref)) { + AniParseUtils::ParseInt32(env, duplexMode_ref, duplexMode); + } + + if (AniParseUtils::GetRefProperty(env, obj, "margin", margin)) { + ParsePrintMarginAdapter(env, static_cast(margin), printAttr); + } + + printAttr.copyNumber = static_cast(copyNumber); + printAttr.isSequential = static_cast(isSequential); + printAttr.isLandscape = static_cast(isLandscape); + printAttr.colorMode = static_cast(colorMode); + printAttr.duplexMode = static_cast(duplexMode); + WVLOG_D("copyNumber is %{public}d,isSequential is %{public}d,isLandscape is %{public}d,colorMode is " + "%{public}d,duplexMode is %{public}d", + printAttr.copyNumber, printAttr.isSequential, printAttr.isLandscape, printAttr.colorMode, printAttr.duplexMode); + + return true; +} + +static void OnStartLayoutWrite(ani_env* env, ani_object object, ani_string jobId, ani_object oldPrintAttr, + ani_object newPrintAttr, ani_int fd, ani_fn_object callback) +{ + if (env == nullptr) { + WVLOG_E("env is nullptr"); + return; + } + WebPrintDocument* webPrintDocument = reinterpret_cast(AniParseUtils::Unwrap(env, object)); + if (!webPrintDocument) { + WVLOG_E("failed to Unwrap webPrintDocument"); + AniBusinessError::ThrowErrorByErrCode(env, INIT_ERROR); + return; + } + + std::string jobIDString; + if (!AniParseUtils::ParseString(env, jobId, jobIDString)) { + AniBusinessError::ThrowErrorByErrCode(env, PARAM_CHECK_ERROR); + return; + } + + int32_t fdUint = static_cast(fd); + PrintAttributesAdapter oldPA; + if (!ParseWebPrintAttrParams(env, oldPrintAttr, oldPA)) { + WVLOG_E("failed to ParseWebPrintAttrParams oldPrintAttr"); + AniBusinessError::ThrowErrorByErrCode(env, PARAM_CHECK_ERROR); + return; + } + PrintAttributesAdapter newPA; + if (!ParseWebPrintAttrParams(env, newPrintAttr, newPA)) { + WVLOG_E("failed to ParseWebPrintAttrParams newPrintAttr"); + AniBusinessError::ThrowErrorByErrCode(env, PARAM_CHECK_ERROR); + return; + } + WebPrintWriteResultCallback writeResultCallback = nullptr; + writeResultCallback = ParseWebPrintWriteResultCallback(env, object, callback); + webPrintDocument->OnStartLayoutWrite(jobIDString, oldPA, newPA, fdUint, writeResultCallback); + return; +} + +ani_status StsPrintDocumentAdapterInit(ani_env* env) +{ + ani_class printDocumentAdapterCls = nullptr; + ani_status status = env->FindClass(ANI_PRINT_DOCUMENT_ADAPTER_INNER_CLASS_NAME, &printDocumentAdapterCls); + if (status != ANI_OK || !printDocumentAdapterCls) { + WVLOG_E( + "find %{public}s class failed, status: %{public}d", ANI_PRINT_DOCUMENT_ADAPTER_INNER_CLASS_NAME, status); + return ANI_ERROR; + } + + std::array methodArray = { + ani_native_function { "onStartLayoutWrite", nullptr, reinterpret_cast(OnStartLayoutWrite) }, + ani_native_function { "onJobStateChanged", nullptr, reinterpret_cast(OnJobStateChanged) }, + }; + + status = env->Class_BindNativeMethods(printDocumentAdapterCls, methodArray.data(), methodArray.size()); + if (status != ANI_OK) { + WVLOG_E("Class_BindNativeMethods failed status: %{public}d", status); + } + + return ANI_OK; +} + ani_status StsWebviewControllerInit(ani_env *env) { WVLOG_D("[DOWNLOAD] StsWebviewControllerInit"); @@ -4900,6 +5251,8 @@ ani_status StsWebviewControllerInit(ani_env *env) reinterpret_cast(SetServiceWorkerWebSchemeHandler) }, ani_native_function { "runJavaScriptCallback", nullptr, reinterpret_cast(RunJavaScriptCallback) }, ani_native_function { "runJavaScriptCallbackExt", nullptr, reinterpret_cast(RunJavaScriptCallbackExt) }, + ani_native_function { + "createWebPrintDocumentAdapter", nullptr, reinterpret_cast(CreateWebPrintDocumentAdapter) }, }; status = env->Class_BindNativeMethods(webviewControllerCls, controllerMethods.data(), controllerMethods.size()); if (status != ANI_OK) { diff --git a/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.h b/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.h index 065960829..63dde2f4d 100644 --- a/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.h +++ b/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_controller.h @@ -46,6 +46,7 @@ ani_status StsWebSchemeHandlerResourceInit(ani_env *env); ani_status StsWebSchemeHandlerRequestInit(ani_env *env); ani_status StsWebSchemeHandlerInit(ani_env *env); ani_status StsJsMessageExtInit(ani_env *env); +ani_status StsPrintDocumentAdapterInit(ani_env* env); } // namespace NWeb } // namespace OHOS #endif // OHOS_NWEB_ANI_WEBVIEW_CONTROLLER_H \ No newline at end of file diff --git a/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_createpdf_execute_callback.cpp b/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_createpdf_execute_callback.cpp index 8826f78a2..c76fbe63e 100644 --- a/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_createpdf_execute_callback.cpp +++ b/interfaces/kits/ani/webview/src/webviewcontroller/ani_webview_createpdf_execute_callback.cpp @@ -169,7 +169,7 @@ static ani_object GetArrayBuffer(ani_env* env, ani_object object) return nullptr; } - for (ani_size i = 0; i < size; i++) { + for (ani_int i = 0; i < size; i++) { ani_int value = pdfResult[i]; status = env->Object_CallMethodByName_Void( arrayObject, "set", "IB:V", static_cast(i), static_cast(value)); -- Gitee