@react-native-ohos/react-native-amap3d 3.2.5-rc.1

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

@@ -0,0 +1,46 @@
+/**
+ * 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 { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { RNPackage, TurboModulesFactory } from '@rnoh/react-native-openharmony/ts';
+import { AMap3DModule } from './AMap3DModule';
+
+class AMap3DModulesFactory extends TurboModulesFactory {
+  createTurboModule(name: string): TurboModule | null {
+    if (name === 'AMapSdk') {
+      return new AMap3DModule(this.ctx)
+    }
+    return null;
+  }
+
+  hasTurboModule(name: string): boolean {
+    return name === 'AMapSdk';
+  }
+}
+
+export class AMap3DPackage extends RNPackage {
+  createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
+    return new AMap3DModulesFactory(ctx);
+  }
+}

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

@@ -0,0 +1,24 @@
+import {
+    AMap, MapView, Marker, Polygon, Polyline, Circle
+} from '@amap/amap_lbs_map3d';
+import HashMap from '@ohos.util.HashMap';
+
+export default class GlobalCache {
+  public static index: number = 1
+  public static isGO: boolean = false;
+  public static cacheMap: Map<Object | undefined, number> = new Map()
+  public static cacheMapPageDestroy: Map<number, boolean> = new Map()
+  public static mapMarker: Map<number, Array<Marker>> = new Map();//map的tag和 marker集合
+  public static markerTagAndDescriptorTag: Map<number,Array<HashMap<number, string>>> = new Map();//map的tag和  marker的tag、marker的id
+  public static currentPageMarker: HashMap<number, number> = new HashMap();
+
+  public static mapPolyLine: Map<number, Array<Polyline>> = new Map();//存的是map的tag和polyLine集合
+  public static polyLinesTagAndDescriptorTag: Map<number,Array<HashMap<number, string>>> = new Map();//map的tag和  polyLine的tag、marker的id
+  public static currentPagePolyline: HashMap<number, number> = new HashMap();//存的是polyline的tag和map的tag
+
+  public static mapViews: HashMap<number, MapView> = new HashMap();
+  public static maps: HashMap<number, AMap> = new HashMap();
+
+  public static polygonCacheMap: HashMap<number, Polygon> = new HashMap();
+  public static circleCacheMap: HashMap<number, Circle> = new HashMap();
+}

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

@@ -0,0 +1,65 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2024 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 hilog from '@ohos.hilog';
+
+class Logger {
+  private domain : number;
+  private prefix : string;
+  private format : string = '%{public}s, %{public}s';
+  private isDebug : boolean;
+
+
+  /**
+   * constructor.
+   *
+   * @param Prefix Identifies the log tag.
+   * @param domain Domain Indicates the service domain, which is a hexadecimal integer ranging from 0x0 to 0xFFFFF.
+   */
+  constructor(prefix: string = 'MyApp', domain: number = 0xFF00, isDebug = false) {
+    this.prefix = prefix;
+    this.domain = domain;
+    this.isDebug = isDebug;
+  }
+
+  debug(...args: string[]): void {
+    if (this.isDebug) {
+      hilog.debug(this.domain, this.prefix, this.format, args);
+    }
+  }
+
+  info(...args: string[]): void {
+    hilog.info(this.domain, this.prefix, this.format, args);
+  }
+
+  warn(...args: string[]) : void {
+    hilog.warn(this.domain, this.prefix, this.format, args);
+  }
+
+  error(...args: string[]) : void {
+    hilog.error(this.domain, this.prefix, this.format, args);
+  }
+}
+
+export default new Logger('AMap3D', 0xFF00, false)

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

@@ -0,0 +1,96 @@
+import { LatLng} from '@amap/amap_lbs_map3d'
+import { Descriptor, RNOHContext, ViewBaseProps } from '@rnoh/react-native-openharmony';
+import GlobalCache from '../GlobalCache';
+import { ArrayList } from '@kit.ArkTS';
+
+export function rgbaToHex(rgbaString: string): number {
+  // 处理十六进制字符串（如 #RGB、#RRGGBB、#AARRGGBB）
+  let value: number;
+  if (rgbaString.startsWith('#')) {
+    const hex = rgbaString.slice(1); // 去掉 #
+    // 根据长度解析十六进制
+    switch (hex.length) {
+      case 3: // #RGB → 转换为 #RRGGBB（Alpha=FF）
+        value = parseInt(hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2], 16);
+        return 0xFF000000 | value;
+      case 6: // #RRGGBB → 转换为 #AARRGGBB（Alpha=FF）
+        value = parseInt(hex, 16);
+        return 0xFF000000 | value;
+      case 8: // #AARRGGBB → 直接转换为数值
+        return parseInt(hex, 16);
+      default:
+        throw new Error('Invalid hex color format (expected #RGB, #RRGGBB, or #AARRGGBB)');
+    }
+  }
+
+  // 处理 RGB 格式（无 Alpha）
+  if (rgbaString.startsWith('rgb(')) {
+    const match = rgbaString.match(/(\d+(\.\d+)?)/g);
+    if (!match) throw new Error('Invalid RGB string format');
+    const red = parseInt(match[0]);
+    const green = parseInt(match[1]);
+    const blue = parseInt(match[2]);
+    value = 0xFF000000 | (red << 16) | (green << 8) | blue;
+    return value;
+  }
+
+  // 处理 RGBA 格式
+  if (rgbaString.startsWith('rgba(')) {
+    const match = rgbaString.match(/(\d+(\.\d+)?)/g);
+    if (!match) throw new Error('Invalid RGBA string format');
+    const r = match[0];
+    const g = match[1];
+    const b = match[2];
+    const a = match[3];
+    const red = Math.min(255, Math.max(0, parseInt(r)));
+    const green = Math.min(255, Math.max(0, parseInt(g)));
+    const blue = Math.min(255, Math.max(0, parseInt(b)));
+    const alpha = Math.round(Math.min(1, Math.max(0, parseFloat(a))) * 255);
+    value = (alpha << 24) | (red << 16) | (green << 8) | blue;
+    return value;
+  }
+  return 0xFF000000;
+}
+
+export interface AMapCircleProps extends ViewBaseProps {
+  center: LatLng;
+  radius?: number;
+  strokeWidth?: number;
+  strokeColor?: string;
+  fillColor?: string;
+  zIndex?: number;
+}
+
+export const A_MAP_CIRCLE_VIEW_TYPE: string = "AMapCircle";
+
+export type AMapCircleDescriptor = Descriptor<"AMapCircle", AMapCircleProps>
+@Component
+export struct AMapCircle {
+  static NAME:string = "AMapCircle";
+  ctx!: RNOHContext
+  tag: number = -1
+  @State circleDescriptor: AMapCircleDescriptor = {} as AMapCircleDescriptor
+  private unregisterDescriptorChangesListener?: () => void = undefined
+
+  aboutToAppear(): void {
+    this.unregisterDescriptorChangesListener = this.ctx.descriptorRegistry.subscribeToDescriptorChanges(this.tag,
+      async (newDescriptor) => {
+        /*------ 当RN侧属性props有更改 -------*/
+        let currentCircle = GlobalCache.circleCacheMap.get(this.tag)
+        this.circleDescriptor = (newDescriptor as AMapCircleDescriptor)
+        let mapCircleProp = this.circleDescriptor.props as AMapCircleProps;
+        if (currentCircle) {
+          currentCircle.setRadius(mapCircleProp.radius ? mapCircleProp.radius : 5000);
+          currentCircle.setCenter(new LatLng(mapCircleProp.center.latitude, mapCircleProp.center.longitude));
+          currentCircle.setFillColor(rgbaToHex(mapCircleProp.fillColor ? mapCircleProp.fillColor : "rgba(255, 0, 0, 0.5)"));
+          currentCircle.setStrokeColor(rgbaToHex(mapCircleProp.strokeColor ? mapCircleProp.strokeColor :
+            "rgba(0, 0, 255, 0.5)"))
+          currentCircle.setStrokeWidth(mapCircleProp.strokeWidth ? mapCircleProp.strokeWidth : 5);
+        }
+      }
+    )
+  }
+  build() {
+  }
+}
+

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

@@ -0,0 +1,83 @@
+import { BitmapDescriptor, BitmapDescriptorFactory, LatLng, Marker, Point } from '@amap/amap_lbs_map3d';
+import { Descriptor, RNComponentContext, RNOHContext, ViewBaseProps } from '@rnoh/react-native-openharmony';
+import { globalContext } from './MapView';
+import GlobalCache from '../GlobalCache';
+import { HashMap } from '@kit.ArkTS';
+
+export interface AMapMarkerProps extends ViewBaseProps {
+  position: LatLng;
+  icon?: BitmapDescriptor;
+  opacity?: number;
+  draggable?: boolean;
+  flat?: boolean;
+  zIndex?: number;
+  anchor?: Point;
+  centerOffset?: Point;
+  tag?:string;
+}
+
+export const A_MAP_MARKER_TYPE: string = "AMapMarker";
+
+export type AMapMarkerDescriptor = Descriptor<"AMapMarker", AMapMarkerProps>;
+
+@Component
+export struct AMapMarker {
+  ctx !: RNComponentContext
+  tag: number = -1
+  markers: Array<Marker> = []
+  markerTagAndDescriptorTagArray: Array<HashMap<number, string>> = []
+  @State amapDescriptor: AMapMarkerDescriptor = {} as AMapMarkerDescriptor
+  private unregisterDescriptorChangesListener?: () => void = undefined
+  static NAME: string = "AMapMarker";
+
+  aboutToAppear(): void {
+    this.unregisterDescriptorChangesListener = this.ctx.descriptorRegistry.subscribeToDescriptorChanges(this.tag,
+      async (newDescriptor) => {
+        /*------ 当RN侧属性props有更改 -------*/
+        let currentMapTag = GlobalCache.currentPageMarker.get(this.tag)
+        this.markers = GlobalCache.mapMarker.get(currentMapTag) ?? [];
+        this.markerTagAndDescriptorTagArray = GlobalCache.markerTagAndDescriptorTag.get(currentMapTag) ?? [];
+        this.amapDescriptor = (newDescriptor as AMapMarkerDescriptor)
+        let mapMarkerProps = this.amapDescriptor.props as AMapMarkerProps;
+        if (this.markers) {
+
+          for (let j = 0; j < this.markerTagAndDescriptorTagArray.length; ++j) {
+            this.markerTagAndDescriptorTagArray[j].forEach(async (markerID: string, markerTag: number, map: HashMap<number, string>) => {
+              if (markerTag == this.tag) {
+                for (let i = 0; i < this.markers.length; ++i) {
+                  if (this.markers[i].getId() == markerID) {
+                    this.markers[i].setPosition(new LatLng(mapMarkerProps.position.latitude, mapMarkerProps.position.longitude));
+                    this.markers[i].setAnchor(mapMarkerProps.anchor ? mapMarkerProps.anchor.x : 1,
+                      mapMarkerProps.anchor ? mapMarkerProps.anchor.y : 0.5);
+                    this.markers[i].setDraggable(mapMarkerProps.draggable ? mapMarkerProps.draggable : false);
+                    //this.markers[i].setZIndex(mapMarkerProps.zIndex ? mapMarkerProps.zIndex : 1);
+                    this.markers[i].setFlat(mapMarkerProps.flat ? mapMarkerProps.flat : false);
+                    this.markers[i].getOptions().setInfoWindowOffset(mapMarkerProps.centerOffset?.x,mapMarkerProps.centerOffset?.y);
+                    if (mapMarkerProps.icon) {
+                      try {
+                        let resoure: string = mapMarkerProps.icon["uri"];
+                        let bitmapDes: BitmapDescriptor | undefined =
+                          await BitmapDescriptorFactory.fromRawfilePath(globalContext, resoure);
+                        this.markers[i].setIcon(bitmapDes);
+                      } catch (error) {
+                        let bitmapDesNull: BitmapDescriptor | undefined =
+                          await BitmapDescriptorFactory.fromRawfilePath(globalContext, "common/marker_default.png");
+                        if (bitmapDesNull) {
+                          this.markers[i].setIcon(bitmapDesNull);
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            })
+          }
+        }
+      }
+    )
+  }
+
+  build() {
+    ContentSlot(this.ctx.getContentForTag(this.tag))
+  }
+}

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

@@ -0,0 +1,52 @@
+import { LatLng, } from '@amap/amap_lbs_map3d';
+import { Descriptor, RNOHContext, ViewBaseProps } from '@rnoh/react-native-openharmony';
+import GlobalCache from '../GlobalCache';
+import { ArrayList } from '@kit.ArkTS';
+import { rgbaToHex } from './AMapCircle';
+
+export interface AMapPolygonProps extends ViewBaseProps {
+  points: LatLng[];
+  strokeWidth?: number;
+  strokeColor?: string;
+  fillColor?: string;
+  zIndex?: number;
+}
+
+export const A_MAP_POLYGON_TYPE: string = "AMapPolygon";
+export type AMapPolygonDescriptor = Descriptor<"AMapPolygon", AMapPolygonProps>
+@Component
+export struct AMapPolygon {
+  ctx !: RNOHContext
+  tag: number = -1
+  @State amapDescriptor: AMapPolygonDescriptor = {} as AMapPolygonDescriptor
+  static NAME: string = "AMapPolygon";
+  private unregisterDescriptorChangesListener?: () => void = undefined
+
+  aboutToAppear(): void {
+    this.unregisterDescriptorChangesListener = this.ctx.descriptorRegistry.subscribeToDescriptorChanges(this.tag,
+      async (newDescriptor) => {
+        /*------ 当RN侧属性props有更改 -------*/
+        let currentPolygon = GlobalCache.polygonCacheMap.get(this.tag)
+        this.amapDescriptor = (newDescriptor as AMapPolygonDescriptor)
+        let mapPolygonProp = this.amapDescriptor.props as AMapPolygonProps;
+        if (currentPolygon) {
+          let polygonOptionsList = new ArrayList<LatLng>()
+          for (let index = 0; index < mapPolygonProp.points.length; index++) {
+            polygonOptionsList.add(new LatLng(mapPolygonProp.points[index].latitude,
+              mapPolygonProp.points[index].longitude))
+          }
+          currentPolygon.setPoints(polygonOptionsList);
+          currentPolygon.setFillColor(rgbaToHex(mapPolygonProp.fillColor ? mapPolygonProp.fillColor :
+            "rgba(255, 0, 0, 0.5)"));
+          currentPolygon.setStrokeWidth(mapPolygonProp.strokeWidth ? mapPolygonProp.strokeWidth : 5);
+          currentPolygon.setStrokeColor(rgbaToHex(mapPolygonProp.strokeColor ? mapPolygonProp.strokeColor :
+            "rgba(255, 0, 0, 0.5)"));
+          currentPolygon.setZIndex(mapPolygonProp.zIndex ? mapPolygonProp.zIndex : 2);
+        }
+      }
+    )
+  }
+
+  build() {
+  }
+}

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

@@ -0,0 +1,89 @@
+import { LatLng, Polyline, } from '@amap/amap_lbs_map3d';
+import { Descriptor, RNOHContext, ViewBaseProps } from '@rnoh/react-native-openharmony';
+import GlobalCache from '../GlobalCache';
+import { ArrayList, HashMap } from '@kit.ArkTS';
+import { rgbaToHex } from './AMapCircle';
+
+export interface AMapPolylineProps extends ViewBaseProps {
+  points: LatLng[];
+  width?: number;
+  color?: string;
+  zIndex?: number;
+  colors: string[];
+  gradient?: boolean;
+  geodesic?: boolean;
+  dotted?: boolean;
+}
+
+export function convertColorsToNumbers(colorString: string): number {
+  const hex = colorString.substring(1);
+  return parseInt(hex, 16);
+}
+
+export const A_MAP_POLYLINE_TYPE: string = "AMapPolyline";
+
+export type AMapPolylineDescriptor = Descriptor<"AMapPolyline", AMapPolylineProps>
+
+@Component
+export struct AMapPolyline {
+  ctx !: RNOHContext
+  tag: number = -1
+  polyLines: Array<Polyline> = [];
+  polyLineTagAndDescriptorTagArray: Array<HashMap<number, string>> = []
+  @State amapDescriptor: AMapPolylineDescriptor = {} as AMapPolylineDescriptor
+  static NAME: string = "AMapPolyline";
+  private unregisterDescriptorChangesListener?: () => void = undefined
+
+  aboutToAppear(): void {
+    this.unregisterDescriptorChangesListener = this.ctx.descriptorRegistry.subscribeToDescriptorChanges(this.tag,
+      async (newDescriptor) => {
+        /*------ 当RN侧属性props有更改 -------*/
+        let currentMapTag = GlobalCache.currentPagePolyline.get(this.tag)
+        this.polyLines = GlobalCache.mapPolyLine.get(currentMapTag) ?? [];
+        this.polyLineTagAndDescriptorTagArray = GlobalCache.polyLinesTagAndDescriptorTag.get(currentMapTag) ?? [];
+        this.amapDescriptor = (newDescriptor as AMapPolylineDescriptor)
+        let mapPolylineProp = this.amapDescriptor.props 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,
+              map: HashMap<number, string>) => {
+              if (polyLineTag == this.tag) {
+                for (let i = 0; i < this.polyLines.length; ++i) {
+                  if (this.polyLines[i].getId() == polyLineID) {
+                    this.polyLines[i].setZIndex(mapPolylineProp.zIndex ? mapPolylineProp.zIndex : 1);
+                    this.polyLines[i].setDottedLine(mapPolylineProp.dotted ? mapPolylineProp.dotted : false);
+                    this.polyLines[i].setGeodesic(mapPolylineProp.geodesic ? mapPolylineProp.geodesic : false);
+                    this.polyLines[i].setWidth(mapPolylineProp.width ? vp2px(mapPolylineProp.width) : vp2px(5));
+                    let polylineOptionsList = new ArrayList<LatLng>()
+                    for (let index = 0; index < mapPolylineProp.points.length; index++) {
+                      polylineOptionsList.add(new LatLng(mapPolylineProp.points[index].latitude,
+                        mapPolylineProp.points[index].longitude))
+                    }
+                    this.polyLines[i].setPoints(polylineOptionsList);
+                    if (mapPolylineProp.color) {
+                      this.polyLines[i].setColor(rgbaToHex(mapPolylineProp.color ? mapPolylineProp.color :
+                        "rgba(0, 255, 0, 0.5)"));
+                    }
+                    if (mapPolylineProp.colors) {
+                      let test = new Int32Array(mapPolylineProp.colors.length)
+                      for (let i = 0; i < mapPolylineProp.colors.length; ++i) {
+                        let str = mapPolylineProp.colors[i].replace("#", "0xff")
+                        test[i] = parseInt(str.substring(2, str.length), 16)
+                      }
+                      this.polyLines[i].getOptions().setColorValues(test);
+                      this.polyLines[i].getOptions().setGradient(mapPolylineProp.gradient ? mapPolylineProp.gradient : false);
+                      this.polyLines[i].setOptions(this.polyLines[i].getOptions());
+                    }
+                  }
+                }
+              }
+            })
+          }
+        }
+      }
+    )
+  }
+
+  build() {
+  }
+}