@react-native-ohos/react-native-amap3d 3.2.5-rc.1 → 3.2.6-rc.2

package/harmony/rn_amap3d/src/main/cpp/Props.h

@@ -1,5 +1,5 @@
-#ifndef HARMONY_RN_AMAP3D_SRC_MAIN_CPP_PROPS_H
-#define HARMONY_RN_AMAP3D_SRC_MAIN_CPP_PROPS_H
+#ifndef AMAP3D_PROPS_H
+#define AMAP3D_PROPS_H
 
 #include <jsi/jsi.h>
 #include <react/renderer/components/view/ViewProps.h>
@@ -31,8 +31,9 @@ struct ImageSourcePropType {
     std::string bundle;
 };
 
-static inline void fromRawValue(const PropsParserContext &context, const RawValue &value, LatLng &result) {
-    auto map = (std::unordered_map<std::string, RawValue>)value;
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, LatLng &result)
+{
+    auto map = (butter::map<std::string, RawValue>)value;
     auto tmp_latitude = map.find("latitude");
     if (tmp_latitude != map.end()) {
         fromRawValue(context, tmp_latitude->second, result.latitude);
@@ -43,10 +44,11 @@ static inline void fromRawValue(const PropsParserContext &context, const RawValu
     }
 }
 
-static inline std::string toString(const LatLng &value) { return "[Object LatLng]"; }
+inline std::string toString(const LatLng &value) { return "[Object LatLng]"; }
 
-static inline void fromRawValue(const PropsParserContext &context, const RawValue &value, CameraPosition &result) {
-    auto map = (std::unordered_map<std::string, RawValue>)value;
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, CameraPosition &result)
+{
+    auto map = (butter::map<std::string, RawValue>)value;
     auto tmp_target = map.find("target");
     if (tmp_target != map.end()) {
         fromRawValue(context, tmp_target->second, result.target);
@@ -65,10 +67,11 @@ static inline void fromRawValue(const PropsParserContext &context, const RawValu
     }
 }
 
-static inline std::string toString(const CameraPosition &value) { return "[Object CameraPosition]"; }
+inline std::string toString(const CameraPosition &value) { return "[Object CameraPosition]"; }
 
-static inline void fromRawValue(const PropsParserContext &context, const RawValue &value, ImageSourcePropType &result) {
-    auto map = (std::unordered_map<std::string, RawValue>)value;
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, ImageSourcePropType &result)
+{
+    auto map = (butter::map<std::string, RawValue>)value;
     auto tmp_uri = map.find("uri");
     if (tmp_uri != map.end()) {
         fromRawValue(context, tmp_uri->second, result.uri);
@@ -99,7 +102,7 @@ static inline void fromRawValue(const PropsParserContext &context, const RawValu
     }
 }
 
-static inline std::string toString(const ImageSourcePropType &value) { return "[Object ImageSourcePropType]"; }
+inline std::string toString(const ImageSourcePropType &value) { return "[Object ImageSourcePropType]"; }
 
 class JSI_EXPORT MapViewProps final : public ViewProps {
 public:

package/harmony/rn_amap3d/src/main/cpp/ShadowNodes.cpp

@@ -3,13 +3,13 @@
 namespace facebook {
 namespace react {
 
-extern const char MapViewComponentName[] = "AMapView";
-extern const char HeatMapComponentName[] = "AMapHeatMap";
-extern const char CircleComponentName[] = "AMapCircle";
-extern const char PolylineComponentName[] = "AMapPolyline";
-extern const char PolygonComponentName[] = "AMapPolygon";
-extern const char MultipointComponentName[] = "AMapMultiPoint";
-extern const char MarkerComponentName[] = "AMapMarker";
+const char MapViewComponentName[] = "AMapView";
+const char HeatMapComponentName[] = "AMapHeatMap";
+const char CircleComponentName[] = "AMapCircle";
+const char PolylineComponentName[] = "AMapPolyline";
+const char PolygonComponentName[] = "AMapPolygon";
+const char MultipointComponentName[] = "AMapMultiPoint";
+const char MarkerComponentName[] = "AMapMarker";
 
 } // namespace react
 } // namespace facebook

package/harmony/rn_amap3d/src/main/cpp/ShadowNodes.h

@@ -9,24 +9,24 @@
 namespace facebook {
 namespace react {
 
-JSI_EXPORT extern const char MapViewComponentName[];
-JSI_EXPORT extern const char HeatMapComponentName[];
-JSI_EXPORT extern const char CircleComponentName[];
-JSI_EXPORT extern const char PolylineComponentName[];
-JSI_EXPORT extern const char PolygonComponentName[];
-JSI_EXPORT extern const char MultipointComponentName[];
-JSI_EXPORT extern const char MarkerComponentName[];
+JSI_EXPORT extern const char MapViewComponentName[100];
+JSI_EXPORT extern const char HeatMapComponentName[100];
+JSI_EXPORT extern const char CircleComponentName[100];
+JSI_EXPORT extern const char PolylineComponentName[100];
+JSI_EXPORT extern const char PolygonComponentName[100];
+JSI_EXPORT extern const char MultipointComponentName[100];
+JSI_EXPORT extern const char MarkerComponentName[100];
 
 /*
  * `ShadowNode` for <RNCViewPager> component.
  */
-using MapViewShadowNode = ConcreteViewShadowNode<MapViewComponentName, MapViewProps,MapViewEventEmitter>;
-using HeatMapShadowNode = ConcreteViewShadowNode<HeatMapComponentName, HeatMapProps,HeatMapEventEmitter>;
-using CircleShadowNode = ConcreteViewShadowNode<CircleComponentName, CircleProps,CircleEventEmitter>;
-using PolylineShadowNode = ConcreteViewShadowNode<PolylineComponentName, PolylineProps,PolylineEventEmitter>;
-using PolygonShadowNode = ConcreteViewShadowNode<PolygonComponentName, PolygonProps,PolygonEventEmitter>;
-using MultipointShadowNode = ConcreteViewShadowNode<MultipointComponentName, MultipointProps,MultiPointEventEmitter>;
-using MarkerShadowNode = ConcreteViewShadowNode<MarkerComponentName, MarkerProps,MarkerEventEmitter>;
+using MapViewShadowNode = ConcreteViewShadowNode<MapViewComponentName, MapViewProps, MapViewEventEmitter>;
+using HeatMapShadowNode = ConcreteViewShadowNode<HeatMapComponentName, HeatMapProps, HeatMapEventEmitter>;
+using CircleShadowNode = ConcreteViewShadowNode<CircleComponentName, CircleProps, CircleEventEmitter>;
+using PolylineShadowNode = ConcreteViewShadowNode<PolylineComponentName, PolylineProps, PolylineEventEmitter>;
+using PolygonShadowNode = ConcreteViewShadowNode<PolygonComponentName, PolygonProps, PolygonEventEmitter>;
+using MultipointShadowNode = ConcreteViewShadowNode<MultipointComponentName, MultipointProps, MultiPointEventEmitter>;
+using MarkerShadowNode = ConcreteViewShadowNode<MarkerComponentName, MarkerProps, MarkerEventEmitter>;
 
 } // namespace react
 } // namespace facebook

package/harmony/rn_amap3d/src/main/ets/AMap3DModule.ts

@@ -22,11 +22,59 @@
  * SOFTWARE.
  */
 
-import { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
 
+import type { UITurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { UITurboModule } from '@rnoh/react-native-openharmony/ts';
 
-export class AMap3DModule extends TurboModule {
-  constructor(ctx: TurboModuleContext) {
+declare global {
+  var AMapSDK: {
+    setXComponentCallback?: (callback: (data: any) => void) => void;
+    init?: (apiKey: string) => boolean;
+    setCenter?: (lat: number, lng: number) => void;
+  } | undefined;
+}
+
+export class AMap3DModule extends UITurboModule {
+  private static instance: AMap3DModule | null = null;
+
+  constructor(ctx: UITurboModuleContext) {
     super(ctx);
+    AMap3DModule.instance = this;
+  }
+
+  static getInstance(): AMap3DModule | null {
+    return this.instance;
+  }
+
+  nativeSetAMapXComponentCallback(callback: (eventData: any) => void): void {
+    try {
+      if (globalThis.AMapSDK && globalThis.AMapSDK.setXComponentCallback) {
+        globalThis.AMapSDK.setXComponentCallback(callback);
+      } else {
+        setTimeout(() => {
+          try {
+            callback({ type: 'mapReady', status: 'success' });
+          } catch (e) {
+          }
+        }, 50);
+      }
+    } catch (error) {
+      setTimeout(() => callback({ type: 'mapReady', status: 'fallback' }), 50);
+    }
   }
-}
+
+  init(apiKey: string): boolean {
+    return true;
+  }
+  setCenter(latitude: number, longitude: number): void {
+  }
+  isModuleAvailable(): boolean {
+    return true;
+  }
+}
+
+export const getAMapModuleInstance = (): AMap3DModule | null => {
+  return AMap3DModule.getInstance();
+};
+
+export default AMap3DModule;

package/harmony/rn_amap3d/src/main/ets/AMap3DPackage.ets

@@ -0,0 +1,119 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 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.
+ */
+import type {
+  UITurboModule,
+  UITurboModuleContext
+} from '@rnoh/react-native-openharmony/ts';
+import { RNOHPackage, TurboModulesFactory, ComponentBuilderContext } from '@rnoh/react-native-openharmony'
+import { AMap3DModule } from './AMap3DModule';
+import type { TurboModule } from '@rnoh/react-native-openharmony/ts';
+import { A_MAP_CIRCLE_VIEW_TYPE, AMapCircle } from './View/AMapCircle';
+import { A_MAP_MARKER_TYPE, AMapMarker } from './View/AMapMarker';
+import { A_MAP_POLYGON_TYPE, AMapPolygon } from './View/AMapPolygon';
+import { A_MAP_POLYLINE_TYPE, AMapPolyline } from './View/AMapPolyline';
+import { GOADE_MAP_VIEW_TYPE, AMapView } from './View/MapView';
+
+@Builder
+function aMapCircle(ctx: ComponentBuilderContext) {
+  AMapCircle({ ctx: ctx.rnComponentContext, tag: ctx.tag })
+}
+
+@Builder
+function aMapMarker(ctx: ComponentBuilderContext) {
+  AMapMarker({ ctx: ctx.rnComponentContext, tag: ctx.tag })
+}
+
+@Builder
+function aMapPolygon(ctx: ComponentBuilderContext) {
+  AMapPolygon({ ctx: ctx.rnComponentContext, tag: ctx.tag })
+}
+
+@Builder
+function aMapPolyline(ctx: ComponentBuilderContext) {
+  AMapPolyline({ ctx: ctx.rnComponentContext, tag: ctx.tag })
+}
+
+@Builder
+function aMapView(ctx: ComponentBuilderContext) {
+  AMapView({ ctx: ctx.rnComponentContext, tag: ctx.tag })
+}
+
+class RNAMap3DTurboModuleFactory extends TurboModulesFactory {
+  createTurboModule(name: string): TurboModule | null {
+    if (this.hasTurboModule(name)) {
+      return new AMap3DModule(this.ctx);
+    }
+    return null;
+  }
+
+  hasTurboModule(name: string): boolean {
+    return name === 'AMapSdk';
+  }
+}
+
+export class AMap3DPackage extends RNOHPackage {
+  // 确保模块被正确创建
+  getUITurboModuleFactoryByNameMap(): Map<
+  string,
+  (ctx: UITurboModuleContext) => UITurboModule | null
+  > {
+    const map = new Map<string, (ctx: UITurboModuleContext) => UITurboModule | null>();
+    map.set('AMapSdk', (ctx: UITurboModuleContext) => {
+      try {
+        const module = new AMap3DModule(ctx);
+        return module;
+      } catch (error) {
+        return null;
+      }
+    });
+    return map;
+  }
+
+  createTurboModulesFactory(ctx: UITurboModuleContext): TurboModulesFactory {
+    return new RNAMap3DTurboModuleFactory(ctx);
+  }
+
+  getDebugName(): string {
+    return 'AMap3DPackage';
+  }
+
+  createWrappedCustomRNComponentBuilderByComponentNameMap(): Map<string, WrappedBuilder<[ComponentBuilderContext]>> {
+    const aMapBuilderMap = new Map<string, WrappedBuilder<[ComponentBuilderContext]>>();
+
+    aMapBuilderMap.set(GOADE_MAP_VIEW_TYPE, wrapBuilder(aMapView))
+    aMapBuilderMap.set(A_MAP_CIRCLE_VIEW_TYPE, wrapBuilder(aMapCircle))
+    aMapBuilderMap.set(A_MAP_MARKER_TYPE, wrapBuilder(aMapMarker))
+    aMapBuilderMap.set(A_MAP_POLYGON_TYPE, wrapBuilder(aMapPolygon))
+    aMapBuilderMap.set(A_MAP_POLYLINE_TYPE, wrapBuilder(aMapPolyline))
+
+    return aMapBuilderMap;
+  }
+}
+
+export const createAMap3DPackage = () => {
+  console.log('Creating AMap3DPackage instance');
+  return new AMap3DPackage({});
+};
+
+export default AMap3DPackage;

package/harmony/rn_amap3d/src/main/ets/DownloadIcon.ets

@@ -0,0 +1,172 @@
+import { Marker, MarkerOptions, BitmapDescriptor, BitmapDescriptorFactory, } from '@amap/amap_lbs_map3d';
+import { fileIo } from '@kit.CoreFileKit';
+import { common } from '@kit.AbilityKit';
+import { BusinessError, request } from '@kit.BasicServicesKit';
+import { image } from '@kit.ImageKit';
+import Logger from './Logger';
+
+interface packOptsType {
+  format: string;
+  quality: number;
+}
+const IMAGE_FORMAT = ['gif', 'jpeg', 'jpg', 'webp', 'png'];
+const ENCODE_FORMAT = ['image/png', 'image/jpeg', 'image/webp'];
+
+export class DownloadIcon {
+  static async updataMakerIcon(context: UIContext, marker: Marker | MarkerOptions, icon: BitmapDescriptor) {
+    let src: string = icon['uri'];
+    let width: number | undefined = icon['width'] || undefined;
+    let height: number | undefined = icon['height'] || undefined;
+
+    let bitmapDes: BitmapDescriptor | undefined;
+
+    if (src) {
+      if (src!.startsWith('http://') || src!.startsWith('https://')) {
+        const filePath: string = await DownloadIcon.doLoadHttpImage(context, src, 0);
+        let imagePathToUse = filePath;
+        
+        if (width !== undefined || height !== undefined) {
+          // Process the image and get the processed path (could be temp file or original)
+          imagePathToUse = await DownloadIcon.resizeImage(filePath, width, height);
+        }
+        
+        let file = fileIo.openSync(imagePathToUse, fileIo.OpenMode.READ_ONLY);
+        bitmapDes = await BitmapDescriptorFactory.fromFd(file.fd);
+        fileIo.closeSync(file.fd);
+        marker.setIcon(bitmapDes);
+        
+        // Clean up temporary file if it was created and is different from original
+        if (imagePathToUse !== filePath) {
+          fileIo.unlinkSync(imagePathToUse);
+        }
+      } else {
+        bitmapDes =
+          await BitmapDescriptorFactory.fromRawfilePath(context.getHostContext()!.getApplicationContext(), src);
+        marker.setIcon(bitmapDes);
+      }
+    }
+  }
+
+  static async resizeImage(filePath: string, targetWidth: number | undefined, targetHeight: number | undefined): Promise<string> {
+    // Create a safe temporary file path by inserting .temp before the extension
+    const lastDotIndex = filePath.lastIndexOf('.');
+    let tempFilePath: string;
+    if (lastDotIndex !== -1) {
+      tempFilePath = filePath.substring(0, lastDotIndex) + '.temp' + filePath.substring(lastDotIndex);
+    } else {
+      tempFilePath = filePath + '.temp';
+    }
+    
+    try {
+      let file = fileIo.openSync(filePath, fileIo.OpenMode.READ_ONLY);
+      const imageSource = image.createImageSource(file.fd);
+      // Get picture format information
+      const imageInfo = imageSource.getImageInfoSync();
+      const mimeType = imageInfo.mimeType || '';
+      targetWidth = targetWidth !== undefined ? targetWidth : imageInfo.size.width;
+      targetHeight = targetHeight !== undefined ? targetHeight : imageInfo.size.height;
+      fileIo.closeSync(file.fd);
+      
+      const finalWidth = Math.round(targetWidth);
+      const finalHeight = Math.round(targetHeight);
+      let decodingOptions: image.DecodingOptions = {
+        sampleSize: 1,
+        editable: true,
+        desiredSize: { width: finalWidth, height: finalHeight },
+        index: 0
+      };
+      
+      let pixelMap = imageSource.createPixelMapSync(decodingOptions);
+
+      const imagePacker = image.createImagePacker();
+
+      let outputFormat: string;
+      if (mimeType.includes(IMAGE_FORMAT[0])) {
+        outputFormat = ENCODE_FORMAT[0];
+      } else if (mimeType.includes(IMAGE_FORMAT[1]) || mimeType.includes(IMAGE_FORMAT[2])) {
+        outputFormat = ENCODE_FORMAT[1];
+      } else if (mimeType.includes(IMAGE_FORMAT[3])) {
+        outputFormat = ENCODE_FORMAT[2];
+      } else {
+        outputFormat = ENCODE_FORMAT[0];
+      }
+
+      const packOpts: packOptsType = {
+        format: outputFormat,
+        quality: 100
+      };
+
+      const data = await imagePacker.packToData(pixelMap, packOpts);
+      const tempFile = fileIo.openSync(tempFilePath, fileIo.OpenMode.CREATE | fileIo.OpenMode.WRITE_ONLY);
+      await fileIo.write(tempFile.fd, data);
+      fileIo.closeSync(tempFile.fd);
+      
+      pixelMap.release();
+      imageSource.release();
+      return tempFilePath;
+    } catch (error) {
+      Logger.error('[resizeImage] Error resizing image: ' + error);
+      return filePath;
+    }
+  }
+
+  static async doLoadHttpImage(uiContext: UIContext, url: string, redirectCount: number = 0): Promise<string> {
+    let context = uiContext.getHostContext()! as common.UIAbilityContext;
+    let filesDir = context.filesDir;
+    let fileExtension = 'png';
+    const urlWithoutParams = url.split('?')[0];
+    const lastDotIndex = urlWithoutParams.lastIndexOf('.');
+    if (lastDotIndex !== -1) {
+      fileExtension = urlWithoutParams.slice(lastDotIndex + 1).toLowerCase();
+    }
+    const fullFileName: string = filesDir + "/" + new Date().getTime() + "." + fileExtension;
+
+    if (redirectCount > 5) {
+      throw new Error("Too many redirects");
+    }
+    return new Promise((resolve, reject) => {
+      const config: request.agent.Config = {
+        action: request.agent.Action.DOWNLOAD,
+        url,
+        method: 'GET',
+        headers: {},
+        saveas: fullFileName,
+        overwrite: true,
+        mode: request.agent.Mode.FOREGROUND,
+      };
+      
+      request.agent.create(context, config).then((task: request.agent.Task) => {
+        task.on('completed', () => {
+          Logger.info(`[maker icon]: finish downloadFile`);
+          resolve(fullFileName);
+        })
+        task.on('failed', (progress: request.agent.Progress) => {
+          Logger.info('[maker icon]: downloadFile failed.', JSON.stringify(progress));
+          reject(new Error('downloadFile failed: ' + JSON.stringify(progress)));
+        });
+        task.on('response', async (response: request.agent.HttpResponse) => {
+          Logger.info('[maker icon]: downloadFile response.', JSON.stringify(response));
+          if (response.statusCode > 300 && response.statusCode < 400) {
+            let redirectUrl: string = response.headers.get('location')?.toString() ?? '';
+            task.off('progress');
+            task.off('completed');
+            task.off('failed');
+            task.off('response');
+            task.stop();
+            try {
+              const result = await DownloadIcon.doLoadHttpImage(uiContext, redirectUrl, redirectCount + 1);
+              Logger.info(`[maker icon]:result: ${result} -----count: ${redirectCount}}`);
+              resolve(result)
+            } catch (error) {
+              reject(error);
+            }
+          }
+        });
+        task.start();
+      }).catch((error: BusinessError) => {
+        Logger.info(`[maker icon]: error downloadHttpFile`);
+        reject(new Error("downloadFile failed: " + error.message));
+      });
+    });
+  }
+}

package/harmony/rn_amap3d/src/main/ets/View/AMapCircle.ets

@@ -63,7 +63,7 @@ export interface AMapCircleProps extends ViewBaseProps {
 
 export const A_MAP_CIRCLE_VIEW_TYPE: string = "AMapCircle";
 
-export type AMapCircleDescriptor = Descriptor<"AMapCircle", AMapCircleProps>
+export type AMapCircleDescriptor = Descriptor<"AMapCircle", '', '', AMapCircleProps>
 @Component
 export struct AMapCircle {
   static NAME:string = "AMapCircle";
@@ -78,7 +78,7 @@ export struct AMapCircle {
         /*------ 当RN侧属性props有更改 -------*/
         let currentCircle = GlobalCache.circleCacheMap.get(this.tag)
         this.circleDescriptor = (newDescriptor as AMapCircleDescriptor)
-        let mapCircleProp = this.circleDescriptor.props as AMapCircleProps;
+        let mapCircleProp = this.circleDescriptor.rawProps as AMapCircleProps;
         if (currentCircle) {
           currentCircle.setRadius(mapCircleProp.radius ? mapCircleProp.radius : 5000);
           currentCircle.setCenter(new LatLng(mapCircleProp.center.latitude, mapCircleProp.center.longitude));

package/harmony/rn_amap3d/src/main/ets/View/AMapMarker.ets

@@ -18,7 +18,7 @@ export interface AMapMarkerProps extends ViewBaseProps {
 
 export const A_MAP_MARKER_TYPE: string = "AMapMarker";
 
-export type AMapMarkerDescriptor = Descriptor<"AMapMarker", AMapMarkerProps>;
+export type AMapMarkerDescriptor = Descriptor<"AMapMarker", '', '', AMapMarkerProps>;
 
 @Component
 export struct AMapMarker {
@@ -38,7 +38,7 @@ export struct AMapMarker {
         this.markers = GlobalCache.mapMarker.get(currentMapTag) ?? [];
         this.markerTagAndDescriptorTagArray = GlobalCache.markerTagAndDescriptorTag.get(currentMapTag) ?? [];
         this.amapDescriptor = (newDescriptor as AMapMarkerDescriptor)
-        let mapMarkerProps = this.amapDescriptor.props as AMapMarkerProps;
+        let mapMarkerProps = this.amapDescriptor.rawProps as AMapMarkerProps;
         if (this.markers) {
 
           for (let j = 0; j < this.markerTagAndDescriptorTagArray.length; ++j) {

package/harmony/rn_amap3d/src/main/ets/View/AMapPolygon.ets

@@ -13,7 +13,9 @@ export interface AMapPolygonProps extends ViewBaseProps {
 }
 
 export const A_MAP_POLYGON_TYPE: string = "AMapPolygon";
-export type AMapPolygonDescriptor = Descriptor<"AMapPolygon", AMapPolygonProps>
+
+export type AMapPolygonDescriptor = Descriptor<"AMapPolygon", '', '', AMapPolygonProps>
+
 @Component
 export struct AMapPolygon {
   ctx !: RNOHContext
@@ -28,7 +30,7 @@ export struct AMapPolygon {
         /*------ 当RN侧属性props有更改 -------*/
         let currentPolygon = GlobalCache.polygonCacheMap.get(this.tag)
         this.amapDescriptor = (newDescriptor as AMapPolygonDescriptor)
-        let mapPolygonProp = this.amapDescriptor.props as AMapPolygonProps;
+        let mapPolygonProp = this.amapDescriptor.rawProps as AMapPolygonProps;
         if (currentPolygon) {
           let polygonOptionsList = new ArrayList<LatLng>()
           for (let index = 0; index < mapPolygonProp.points.length; index++) {

package/harmony/rn_amap3d/src/main/ets/View/AMapPolyline.ets

@@ -22,7 +22,7 @@ export function convertColorsToNumbers(colorString: string): number {
 
 export const A_MAP_POLYLINE_TYPE: string = "AMapPolyline";
 
-export type AMapPolylineDescriptor = Descriptor<"AMapPolyline", AMapPolylineProps>
+export type AMapPolylineDescriptor = Descriptor<"AMapPolyline", '', '', AMapPolylineProps>
 
 @Component
 export struct AMapPolyline {
@@ -42,7 +42,7 @@ export struct AMapPolyline {
         this.polyLines = GlobalCache.mapPolyLine.get(currentMapTag) ?? [];
         this.polyLineTagAndDescriptorTagArray = GlobalCache.polyLinesTagAndDescriptorTag.get(currentMapTag) ?? [];
         this.amapDescriptor = (newDescriptor as AMapPolylineDescriptor)
-        let mapPolylineProp = this.amapDescriptor.props as AMapPolylineProps;
+        let mapPolylineProp = this.amapDescriptor.rawProps as AMapPolylineProps;
         if (this.polyLines && this.polyLines.length > 0) {
           for (let j = 0; j < this.polyLineTagAndDescriptorTagArray.length; ++j) {
             this.polyLineTagAndDescriptorTagArray[j].forEach(async (polyLineID: string, polyLineTag: number,