@react-native-ohos/react-native-webview 13.10.5-rc.1

package/harmony/rn_webview/src/main/cpp/generated/react/renderer/components/react_native_webview/Props.cpp

@@ -0,0 +1,151 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GeneratePropsCpp.js
+ */
+
+#include <react/renderer/components/react_native_webview/Props.h>
+#include <folly/dynamic.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook {
+namespace react {
+
+RNCWebViewProps::RNCWebViewProps(
+    const PropsParserContext &context,
+    const RNCWebViewProps &sourceProps,
+    const RawProps &rawProps): ViewProps(context, sourceProps, rawProps),
+
+    allowFileAccess(convertRawProp(context, rawProps, "allowFileAccess", sourceProps.allowFileAccess, {false})),
+    allowsProtectedMedia(convertRawProp(context, rawProps, "allowsProtectedMedia",
+        sourceProps.allowsProtectedMedia, {false})),
+    allowsFullscreenVideo(convertRawProp(context, rawProps, "allowsFullscreenVideo",
+        sourceProps.allowsFullscreenVideo, {false})),
+    androidLayerType(convertRawProp(context, rawProps, "androidLayerType",
+        sourceProps.androidLayerType, {RNCWebViewAndroidLayerType::None})),
+    cacheMode(convertRawProp(context, rawProps, "cacheMode", sourceProps.cacheMode,
+        {RNCWebViewCacheMode::LOAD_DEFAULT})),
+    domStorageEnabled(convertRawProp(context, rawProps, "domStorageEnabled", sourceProps.domStorageEnabled, {false})),
+    downloadingMessage(convertRawProp(context, rawProps, "downloadingMessage", sourceProps.downloadingMessage, {})),
+    forceDarkOn(convertRawProp(context, rawProps, "forceDarkOn", sourceProps.forceDarkOn, {false})),
+    geolocationEnabled(convertRawProp(context, rawProps, "geolocationEnabled",
+        sourceProps.geolocationEnabled, {false})),
+    lackPermissionToDownloadMessage(convertRawProp(context, rawProps, "lackPermissionToDownloadMessage",
+        sourceProps.lackPermissionToDownloadMessage, {})),
+    messagingModuleName(convertRawProp(context, rawProps, "messagingModuleName", sourceProps.messagingModuleName, {})),
+    minimumFontSize(convertRawProp(context, rawProps, "minimumFontSize", sourceProps.minimumFontSize, {0})),
+    mixedContentMode(convertRawProp(context, rawProps, "mixedContentMode", sourceProps.mixedContentMode,
+        {RNCWebViewMixedContentMode::Never})),
+    nestedScrollEnabled(convertRawProp(context, rawProps, "nestedScrollEnabled",
+        sourceProps.nestedScrollEnabled, {false})),
+    overScrollMode(convertRawProp(context, rawProps, "overScrollMode", sourceProps.overScrollMode, {})),
+    saveFormDataDisabled(convertRawProp(context, rawProps, "saveFormDataDisabled",
+        sourceProps.saveFormDataDisabled, {false})),
+    scalesPageToFit(convertRawProp(context, rawProps, "scalesPageToFit", sourceProps.scalesPageToFit, {false})),
+    setBuiltInZoomControls(convertRawProp(context, rawProps, "setBuiltInZoomControls",
+        sourceProps.setBuiltInZoomControls, {false})),
+    setDisplayZoomControls(convertRawProp(context, rawProps, "setDisplayZoomControls",
+        sourceProps.setDisplayZoomControls, {false})),
+    setSupportMultipleWindows(convertRawProp(context, rawProps, "setSupportMultipleWindows",
+        sourceProps.setSupportMultipleWindows, {false})),
+    textZoom(convertRawProp(context, rawProps, "textZoom", sourceProps.textZoom, {0})),
+    thirdPartyCookiesEnabled(convertRawProp(context, rawProps, "thirdPartyCookiesEnabled",
+        sourceProps.thirdPartyCookiesEnabled, {false})),
+    hasOnScroll(convertRawProp(context, rawProps, "hasOnScroll", sourceProps.hasOnScroll, {false})),
+    injectedJavaScriptObject(convertRawProp(context, rawProps, "injectedJavaScriptObject",
+        sourceProps.injectedJavaScriptObject, {})),
+    allowingReadAccessToURL(convertRawProp(context, rawProps, "allowingReadAccessToURL",
+        sourceProps.allowingReadAccessToURL, {})),
+    allowsBackForwardNavigationGestures(convertRawProp(context, rawProps, "allowsBackForwardNavigationGestures",
+        sourceProps.allowsBackForwardNavigationGestures, {false})),
+    allowsInlineMediaPlayback(convertRawProp(context, rawProps, "allowsInlineMediaPlayback",
+        sourceProps.allowsInlineMediaPlayback, {false})),
+    allowsAirPlayForMediaPlayback(convertRawProp(context, rawProps, "allowsAirPlayForMediaPlayback",
+        sourceProps.allowsAirPlayForMediaPlayback, {false})),
+    allowsLinkPreview(convertRawProp(context, rawProps, "allowsLinkPreview",
+        sourceProps.allowsLinkPreview, {false})),
+    automaticallyAdjustContentInsets(convertRawProp(context, rawProps, "automaticallyAdjustContentInsets",
+        sourceProps.automaticallyAdjustContentInsets, {false})),
+    ignoreSilentHardwareSwitch(convertRawProp(context, rawProps, "ignoreSilentHardwareSwitch",
+        sourceProps.ignoreSilentHardwareSwitch, {false})),
+    autoManageStatusBarEnabled(convertRawProp(context, rawProps, "autoManageStatusBarEnabled",
+        sourceProps.autoManageStatusBarEnabled, {false})),
+    bounces(convertRawProp(context, rawProps, "bounces", sourceProps.bounces, {false})),
+    contentInset(convertRawProp(context, rawProps, "contentInset", sourceProps.contentInset, {})),
+    contentInsetAdjustmentBehavior(convertRawProp(context, rawProps, "contentInsetAdjustmentBehavior",
+        sourceProps.contentInsetAdjustmentBehavior, {RNCWebViewContentInsetAdjustmentBehavior::Never})),
+    contentMode(convertRawProp(context, rawProps, "contentMode", sourceProps.contentMode,
+        {RNCWebViewContentMode::Recommended})),
+    dataDetectorTypes(convertRawProp(context, rawProps, "dataDetectorTypes", sourceProps.dataDetectorTypes, {})),
+    decelerationRate(convertRawProp(context, rawProps, "decelerationRate", sourceProps.decelerationRate, {0.0})),
+    directionalLockEnabled(convertRawProp(context, rawProps, "directionalLockEnabled",
+        sourceProps.directionalLockEnabled, {false})),
+    enableApplePay(convertRawProp(context, rawProps, "enableApplePay", sourceProps.enableApplePay, {false})),
+    hideKeyboardAccessoryView(convertRawProp(context, rawProps, "hideKeyboardAccessoryView",
+        sourceProps.hideKeyboardAccessoryView, {false})),
+    keyboardDisplayRequiresUserAction(convertRawProp(context, rawProps, "keyboardDisplayRequiresUserAction",
+        sourceProps.keyboardDisplayRequiresUserAction, {false})),
+    limitsNavigationsToAppBoundDomains(convertRawProp(context, rawProps, "limitsNavigationsToAppBoundDomains",
+        sourceProps.limitsNavigationsToAppBoundDomains, {false})),
+    mediaCapturePermissionGrantType(convertRawProp(context, rawProps, "mediaCapturePermissionGrantType",
+        sourceProps.mediaCapturePermissionGrantType, {RNCWebViewMediaCapturePermissionGrantType::Prompt})),
+    pagingEnabled(convertRawProp(context, rawProps, "pagingEnabled", sourceProps.pagingEnabled, {false})),
+    pullToRefreshEnabled(convertRawProp(context, rawProps, "pullToRefreshEnabled",
+        sourceProps.pullToRefreshEnabled, {false})),
+    scrollEnabled(convertRawProp(context, rawProps, "scrollEnabled", sourceProps.scrollEnabled, {false})),
+    sharedCookiesEnabled(convertRawProp(context, rawProps, "sharedCookiesEnabled",
+        sourceProps.sharedCookiesEnabled, {false})),
+    textInteractionEnabled(convertRawProp(context, rawProps, "textInteractionEnabled",
+        sourceProps.textInteractionEnabled, {false})),
+    useSharedProcessPool(convertRawProp(context, rawProps, "useSharedProcessPool",
+        sourceProps.useSharedProcessPool, {false})),
+    menuItems(convertRawProp(context, rawProps, "menuItems", sourceProps.menuItems, {})),
+    suppressMenuItems(convertRawProp(context, rawProps, "suppressMenuItems", sourceProps.suppressMenuItems, {})),
+    hasOnFileDownload(convertRawProp(context, rawProps, "hasOnFileDownload", sourceProps.hasOnFileDownload, {false})),
+    fraudulentWebsiteWarningEnabled(convertRawProp(context, rawProps, "fraudulentWebsiteWarningEnabled",
+        sourceProps.fraudulentWebsiteWarningEnabled, {false})),
+    allowFileAccessFromFileURLs(convertRawProp(context, rawProps, "allowFileAccessFromFileURLs",
+        sourceProps.allowFileAccessFromFileURLs, {false})),
+    allowUniversalAccessFromFileURLs(convertRawProp(context, rawProps, "allowUniversalAccessFromFileURLs",
+        sourceProps.allowUniversalAccessFromFileURLs, {false})),
+    applicationNameForUserAgent(convertRawProp(context, rawProps, "applicationNameForUserAgent",
+        sourceProps.applicationNameForUserAgent, {})),
+    basicAuthCredential(convertRawProp(context, rawProps, "basicAuthCredential", sourceProps.basicAuthCredential, {})),
+    cacheEnabled(convertRawProp(context, rawProps, "cacheEnabled", sourceProps.cacheEnabled, {false})),
+    incognito(convertRawProp(context, rawProps, "incognito", sourceProps.incognito, {false})),
+    injectedJavaScript(convertRawProp(context, rawProps, "injectedJavaScript", sourceProps.injectedJavaScript, {})),
+    injectedJavaScriptBeforeContentLoaded(convertRawProp(context, rawProps, "injectedJavaScriptBeforeContentLoaded",
+        sourceProps.injectedJavaScriptBeforeContentLoaded, {})),
+    injectedJavaScriptForMainFrameOnly(convertRawProp(context, rawProps, "injectedJavaScriptForMainFrameOnly",
+        sourceProps.injectedJavaScriptForMainFrameOnly, {false})),
+    injectedJavaScriptBeforeContentLoadedForMainFrameOnly(convertRawProp(context, rawProps,
+        "injectedJavaScriptBeforeContentLoadedForMainFrameOnly",
+        sourceProps.injectedJavaScriptBeforeContentLoadedForMainFrameOnly, {false})),
+    javaScriptCanOpenWindowsAutomatically(convertRawProp(context, rawProps, "javaScriptCanOpenWindowsAutomatically",
+        sourceProps.javaScriptCanOpenWindowsAutomatically, {false})),
+    javaScriptEnabled(convertRawProp(context, rawProps, "javaScriptEnabled", sourceProps.javaScriptEnabled, {false})),
+    webviewDebuggingEnabled(convertRawProp(context, rawProps, "webviewDebuggingEnabled",
+        sourceProps.webviewDebuggingEnabled, {false})),
+    mediaPlaybackRequiresUserAction(convertRawProp(context, rawProps, "mediaPlaybackRequiresUserAction",
+        sourceProps.mediaPlaybackRequiresUserAction, {false})),
+    messagingEnabled(convertRawProp(context, rawProps, "messagingEnabled", sourceProps.messagingEnabled, {false})),
+    shouldStartLoadWithRequestEnabled(convertRawProp(context, rawProps, "shouldStartLoadWithRequestEnabled",
+        sourceProps.shouldStartLoadWithRequestEnabled, {false})),
+    hasOnOpenWindowEvent(convertRawProp(context, rawProps, "hasOnOpenWindowEvent",
+        sourceProps.hasOnOpenWindowEvent, {false})),
+    showsHorizontalScrollIndicator(convertRawProp(context, rawProps, "showsHorizontalScrollIndicator",
+        sourceProps.showsHorizontalScrollIndicator, {false})),
+    showsVerticalScrollIndicator(convertRawProp(context, rawProps, "showsVerticalScrollIndicator",
+        sourceProps.showsVerticalScrollIndicator, {false})),
+    newSource(convertRawProp(context, rawProps, "newSource", sourceProps.newSource, {})),
+    userAgent(convertRawProp(context, rawProps, "userAgent", sourceProps.userAgent, {})),
+    schemeList(convertRawProp(context, rawProps, "schemeList", sourceProps.schemeList, {}))
+    {}
+
+} // namespace react
+} // namespace facebook

package/harmony/rn_webview/src/main/cpp/generated/react/renderer/components/react_native_webview/Props.h

@@ -0,0 +1,337 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GeneratePropsH.js
+ */
+#pragma once
+
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <vector>
+
+namespace facebook {
+    namespace react {
+        enum class RNCWebViewAndroidLayerType {
+            None,
+            Software,
+            Hardware
+        };
+        static RNCWebViewAndroidLayerType parseAndroidLayerType(const std::string& string)
+        {
+            if (string == "none") {
+                return RNCWebViewAndroidLayerType::None;
+            }
+            if (string == "software") {
+                return RNCWebViewAndroidLayerType::Software;
+            }
+            if (string == "hardware") {
+                return RNCWebViewAndroidLayerType::Hardware;
+            }
+            throw std::runtime_error("Unexpected value for RNCWebViewAndroidLayerType: " + string);
+        }
+        static inline void fromRawValue(const PropsParserContext &context, const RawValue &value,
+            RNCWebViewAndroidLayerType &result)
+        {
+            auto string = (std::string)value;
+            result = parseAndroidLayerType(string);
+        }
+        
+        static inline std::string toString(const RNCWebViewAndroidLayerType &value)
+        {
+            switch (value) {
+                case RNCWebViewAndroidLayerType::None:
+                    return "none";
+                case RNCWebViewAndroidLayerType::Software:
+                    return "software";
+                case RNCWebViewAndroidLayerType::Hardware:
+                    return "hardware";
+            }
+        }
+        enum class RNCWebViewCacheMode {
+            LOAD_DEFAULT,
+            LOAD_CACHE_ELSE_NETWORK,
+            LOAD_NO_CACHE,
+            LOAD_CACHE_ONLY
+        };
+        static RNCWebViewCacheMode parseCacheMode(const std::string& string)
+        {
+            if (string == "LOAD_DEFAULT") {
+                return RNCWebViewCacheMode::LOAD_DEFAULT;
+            }
+            if (string == "LOAD_CACHE_ELSE_NETWORK") {
+                return RNCWebViewCacheMode::LOAD_CACHE_ELSE_NETWORK;
+            }
+            if (string == "LOAD_NO_CACHE") {
+                return RNCWebViewCacheMode::LOAD_NO_CACHE;
+            }
+            if (string == "LOAD_CACHE_ONLY") {
+                return RNCWebViewCacheMode::LOAD_CACHE_ONLY;
+            }
+            throw std::runtime_error("Unexpected value for RNCWebViewCacheMode: " + string);
+        }
+        static inline void fromRawValue(const PropsParserContext &context, const RawValue &value,
+            RNCWebViewCacheMode &result)
+        {
+            auto string = (std::string)value;
+            result = parseCacheMode(string);
+        }
+        static inline std::string toString(const RNCWebViewCacheMode &value)
+        {
+            switch (value) {
+                case RNCWebViewCacheMode::LOAD_DEFAULT: return "LOAD_DEFAULT";
+                case RNCWebViewCacheMode::LOAD_CACHE_ELSE_NETWORK: return "LOAD_CACHE_ELSE_NETWORK";
+                case RNCWebViewCacheMode::LOAD_NO_CACHE: return "LOAD_NO_CACHE";
+                case RNCWebViewCacheMode::LOAD_CACHE_ONLY: return "LOAD_CACHE_ONLY";
+            }
+        }
+        enum class RNCWebViewMixedContentMode {
+            Never,
+            Always,
+            Compatibility
+        };
+        static RNCWebViewMixedContentMode parseMixedContentMode(const std::string& string)
+        {
+            if (string == "never") {
+                return RNCWebViewMixedContentMode::Never;
+            }
+            if (string == "always") {
+                return RNCWebViewMixedContentMode::Always;
+            }
+            if (string == "compatibility") {
+                return RNCWebViewMixedContentMode::Compatibility;
+            }
+            throw std::runtime_error("Unexpected value for RNCWebViewMixedContentMode: " + string);
+        }
+        static inline void fromRawValue(const PropsParserContext &context, const RawValue &value,
+            RNCWebViewMixedContentMode &result)
+        {
+            auto string = (std::string)value;
+            result = parseMixedContentMode(string);
+        }
+        
+        static inline std::string toString(const RNCWebViewMixedContentMode &value)
+        {
+            switch (value) {
+                case RNCWebViewMixedContentMode::Never:
+                    return "never";
+                case RNCWebViewMixedContentMode::Always:
+                    return "always";
+                case RNCWebViewMixedContentMode::Compatibility:
+                    return "compatibility";
+            }
+        }
+        enum class RNCWebViewContentInsetAdjustmentBehavior {
+            Never,
+            Automatic,
+            ScrollableAxes,
+            Always
+        };
+        static RNCWebViewContentInsetAdjustmentBehavior parseBehavior(const std::string& string)
+        {
+            if (string == "never") {
+                return RNCWebViewContentInsetAdjustmentBehavior::Never;
+            }
+            if (string == "automatic") {
+                return RNCWebViewContentInsetAdjustmentBehavior::Automatic;
+            }
+            if (string == "scrollableAxes") {
+                return RNCWebViewContentInsetAdjustmentBehavior::ScrollableAxes;
+            }
+            if (string == "always") {
+                return RNCWebViewContentInsetAdjustmentBehavior::Always;
+            }
+            throw std::runtime_error("Unexpected value for RNCWebViewContentInsetAdjustmentBehavior: " + string);
+        }
+        static inline void fromRawValue(const PropsParserContext &context, const RawValue &value,
+            RNCWebViewContentInsetAdjustmentBehavior &result)
+        {
+            auto string = (std::string)value;
+            result = parseBehavior(string);
+        }
+        static inline std::string toString(const RNCWebViewContentInsetAdjustmentBehavior &value)
+        {
+            switch (value) {
+                case RNCWebViewContentInsetAdjustmentBehavior::Never:
+                    return "never";
+                case RNCWebViewContentInsetAdjustmentBehavior::Automatic:
+                    return "automatic";
+                case RNCWebViewContentInsetAdjustmentBehavior::ScrollableAxes:
+                    return "scrollableAxes";
+                case RNCWebViewContentInsetAdjustmentBehavior::Always:
+                    return "always";
+            }
+        }
+        enum class RNCWebViewContentMode {
+            Recommended,
+            Mobile,
+            Desktop
+        };
+        static RNCWebViewContentMode parseContentMode(const std::string& string)
+        {
+            if (string == "recommended") {
+                return RNCWebViewContentMode::Recommended;
+            }
+            if (string == "mobile") {
+                return RNCWebViewContentMode::Mobile;
+            }
+            if (string == "desktop") {
+                return RNCWebViewContentMode::Desktop;
+            }
+            throw std::runtime_error("Unexpected value for RNCWebViewContentMode: " + string);
+        }
+        static inline void fromRawValue(const PropsParserContext &context, const RawValue &value,
+            RNCWebViewContentMode &result)
+        {
+            auto string = (std::string)value;
+            result = parseContentMode(string);
+        }
+        static inline std::string toString(const RNCWebViewContentMode &value)
+        {
+            switch (value) {
+                case RNCWebViewContentMode::Recommended:
+                    return "recommended";
+                case RNCWebViewContentMode::Mobile:
+                    return "mobile";
+                case RNCWebViewContentMode::Desktop:
+                    return "desktop";
+            }
+        }
+        enum class RNCWebViewMediaCapturePermissionGrantType {
+            Prompt,
+            Grant,
+            Deny,
+            GrantIfSameHostElsePrompt,
+            GrantIfSameHostElseDeny
+        };
+        static RNCWebViewMediaCapturePermissionGrantType parseMCPGType(const std::string& string)
+        {
+            if (string == "prompt") {
+                return RNCWebViewMediaCapturePermissionGrantType::Prompt;
+            }
+            if (string == "grant") {
+                return RNCWebViewMediaCapturePermissionGrantType::Grant;
+            }
+            if (string == "deny") {
+                return RNCWebViewMediaCapturePermissionGrantType::Deny;
+            }
+            if (string == "grantIfSameHostElsePrompt") {
+                return RNCWebViewMediaCapturePermissionGrantType::GrantIfSameHostElsePrompt;
+            }
+            if (string == "grantIfSameHostElseDeny") {
+                return RNCWebViewMediaCapturePermissionGrantType::GrantIfSameHostElseDeny;
+            }
+            throw std::runtime_error("Unexpected value for RNCWebViewMediaCapturePermissionGrantType: " + string);
+        }
+        static inline void fromRawValue(const PropsParserContext &context, const RawValue &value,
+            RNCWebViewMediaCapturePermissionGrantType &result)
+        {
+            auto string = (std::string)value;
+            result = parseMCPGType(string);
+        }
+        static inline std::string toString(const RNCWebViewMediaCapturePermissionGrantType &value)
+        {
+            switch (value) {
+                case RNCWebViewMediaCapturePermissionGrantType::Prompt: return "prompt";
+                case RNCWebViewMediaCapturePermissionGrantType::Grant: return "grant";
+                case RNCWebViewMediaCapturePermissionGrantType::Deny: return "deny";
+                case RNCWebViewMediaCapturePermissionGrantType::GrantIfSameHostElsePrompt:
+                    return "grantIfSameHostElsePrompt";
+                case RNCWebViewMediaCapturePermissionGrantType::GrantIfSameHostElseDeny:
+                    return "grantIfSameHostElseDeny";
+            }
+        }
+
+        class RNCWebViewProps final : public ViewProps {
+        public:
+            RNCWebViewProps() = default;
+            RNCWebViewProps(const PropsParserContext &context, const RNCWebViewProps &sourceProps,
+                const RawProps &rawProps);
+
+            #pragma mark - Props
+
+            bool allowFileAccess{false};
+            bool allowsProtectedMedia{false};
+            bool allowsFullscreenVideo{false};
+            RNCWebViewAndroidLayerType androidLayerType{RNCWebViewAndroidLayerType::None};
+            RNCWebViewCacheMode cacheMode{RNCWebViewCacheMode::LOAD_DEFAULT};
+            bool domStorageEnabled{false};
+            std::string downloadingMessage{};
+            bool forceDarkOn{false};
+            bool geolocationEnabled{false};
+            std::string lackPermissionToDownloadMessage{};
+            std::string messagingModuleName{};
+            int minimumFontSize{0};
+            RNCWebViewMixedContentMode mixedContentMode{RNCWebViewMixedContentMode::Never};
+            bool nestedScrollEnabled{false};
+            std::string overScrollMode{};
+            bool saveFormDataDisabled{false};
+            bool scalesPageToFit{false};
+            bool setBuiltInZoomControls{false};
+            bool setDisplayZoomControls{false};
+            bool setSupportMultipleWindows{false};
+            int textZoom{0};
+            bool thirdPartyCookiesEnabled{false};
+            bool hasOnScroll{false};
+            std::string injectedJavaScriptObject{};
+            std::string allowingReadAccessToURL{};
+            bool allowsBackForwardNavigationGestures{false};
+            bool allowsInlineMediaPlayback{false};
+            bool allowsAirPlayForMediaPlayback{false};
+            bool allowsLinkPreview{false};
+            bool automaticallyAdjustContentInsets{false};
+            bool ignoreSilentHardwareSwitch{false};
+            bool autoManageStatusBarEnabled{false};
+            bool bounces{false};
+            folly::dynamic contentInset{};
+            RNCWebViewContentInsetAdjustmentBehavior contentInsetAdjustmentBehavior{
+                RNCWebViewContentInsetAdjustmentBehavior::Never};
+            RNCWebViewContentMode contentMode{RNCWebViewContentMode::Recommended};
+            folly::dynamic dataDetectorTypes{};
+            double decelerationRate{0.0};
+            bool directionalLockEnabled{false};
+            bool enableApplePay{false};
+            bool hideKeyboardAccessoryView{false};
+            bool keyboardDisplayRequiresUserAction{false};
+            bool limitsNavigationsToAppBoundDomains{false};
+            RNCWebViewMediaCapturePermissionGrantType mediaCapturePermissionGrantType{
+                RNCWebViewMediaCapturePermissionGrantType::Prompt};
+            bool pagingEnabled{false};
+            bool pullToRefreshEnabled{false};
+            bool scrollEnabled{false};
+            bool sharedCookiesEnabled{false};
+            bool textInteractionEnabled{false};
+            bool useSharedProcessPool{false};
+            folly::dynamic menuItems{};
+            std::vector<folly::dynamic> suppressMenuItems{};
+            bool hasOnFileDownload{false};
+            bool fraudulentWebsiteWarningEnabled{false};
+            bool allowFileAccessFromFileURLs{false};
+            bool allowUniversalAccessFromFileURLs{false};
+            std::string applicationNameForUserAgent{};
+            folly::dynamic basicAuthCredential{};
+            bool cacheEnabled{false};
+            bool incognito{false};
+            std::string injectedJavaScript{};
+            std::string injectedJavaScriptBeforeContentLoaded{};
+            bool injectedJavaScriptForMainFrameOnly{false};
+            bool injectedJavaScriptBeforeContentLoadedForMainFrameOnly{false};
+            bool javaScriptCanOpenWindowsAutomatically{false};
+            bool javaScriptEnabled{false};
+            bool webviewDebuggingEnabled{false};
+            bool mediaPlaybackRequiresUserAction{false};
+            bool messagingEnabled{false};
+            bool shouldStartLoadWithRequestEnabled{false};
+            bool hasOnOpenWindowEvent{false};
+            bool showsHorizontalScrollIndicator{false};
+            bool showsVerticalScrollIndicator{false};
+            folly::dynamic newSource{};
+            std::string userAgent{};
+            folly::dynamic schemeList{};
+        };
+
+    } // namespace react
+} // namespace facebook

package/harmony/rn_webview/src/main/cpp/generated/react/renderer/components/react_native_webview/ShadowNodes.cpp

@@ -0,0 +1,19 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateShadowNodeCpp.js
+ */
+
+#include <react/renderer/components/react_native_webview/ShadowNodes.h>
+
+namespace facebook {
+namespace react {
+
+const char RNC_WEB_VIEW_COMPONENT_NAME[] = "RNCWebView";
+
+} // namespace react
+} // namespace facebook

package/harmony/rn_webview/src/main/cpp/generated/react/renderer/components/react_native_webview/ShadowNodes.h

@@ -0,0 +1,34 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateShadowNodeH.js
+ */
+
+#pragma once
+
+#include <react/renderer/components/react_native_webview/EventEmitters.h>
+#include <react/renderer/components/react_native_webview/Props.h>
+#include <react/renderer/components/react_native_webview/States.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <jsi/jsi.h>
+
+namespace facebook {
+namespace react {
+
+JSI_EXPORT extern const char RNC_WEB_VIEW_COMPONENT_NAME[32];
+
+/*
+ * `ShadowNode` for <RNCWebView> component.
+ */
+using RNCWebViewShadowNode = ConcreteViewShadowNode<
+    RNC_WEB_VIEW_COMPONENT_NAME,
+    RNCWebViewProps,
+    RNCWebViewEventEmitter,
+    RNCWebViewState>;
+
+} // namespace react
+} // namespace facebook

package/harmony/rn_webview/src/main/cpp/generated/react/renderer/components/react_native_webview/States.cpp

@@ -0,0 +1,16 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateStateCpp.js
+ */
+#include <react/renderer/components/react_native_webview/States.h>
+
+namespace facebook {
+namespace react {
+
+} // namespace react
+} // namespace facebook

package/harmony/rn_webview/src/main/cpp/generated/react/renderer/components/react_native_webview/States.h

@@ -0,0 +1,20 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateStateH.js
+ */
+#pragma once
+
+namespace facebook {
+namespace react {
+
+class RNCWebViewState {
+public:
+    RNCWebViewState() = default;
+};
+
+} // namespace react
+} // namespace facebook

package/harmony/rn_webview/src/main/ets/CutomReference.ts

@@ -0,0 +1,50 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2025 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export class CustomReference {
+  private atomicValue: number;
+  private callBack!: Function;
+  constructor(init: number) {
+    this.atomicValue = init
+  }
+
+  getValue() {
+    return this.atomicValue
+  }
+
+  setCallBack(callBack: Function) {
+    this.callBack = callBack
+  }
+
+  getCallBack() {
+    return this.callBack
+  }
+
+  setValue(newValue: number) {
+    this.atomicValue = newValue
+    if (this.callBack) {
+      this.callBack()
+    }
+  }
+}