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

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

@@ -0,0 +1,168 @@
+#ifndef HARMONY_MAPVIEW_SRC_MAIN_CPP_MAPVIEWJSIBINDER_H
+#define HARMONY_MAPVIEW_SRC_MAIN_CPP_MAPVIEWJSIBINDER_H
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class MapViewJSIBinder : public ViewComponentJSIBinder {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "mapType", "number");
+        object.setProperty(rt, "initialCameraPosition", "Object");
+        object.setProperty(rt, "myLocationEnabled", "boolean");
+        object.setProperty(rt, "indoorViewEnabled", "boolean");
+        object.setProperty(rt, "buildingsEnabled", "boolean");
+        object.setProperty(rt, "labelsEnabled", "boolean");
+        object.setProperty(rt, "compassEnabled", "boolean");
+        object.setProperty(rt, "zoomControlsEnabled", "boolean");
+        object.setProperty(rt, "scaleControlsEnabled", "boolean");
+        object.setProperty(rt, "trafficEnabled", "boolean");
+        object.setProperty(rt, "maxZoom", "number");
+        object.setProperty(rt, "minZoom", "number");
+        object.setProperty(rt, "zoomGesturesEnabled", "boolean");
+        object.setProperty(rt, "scrollGesturesEnabled", "boolean");
+        object.setProperty(rt, "rotateGesturesEnabled", "boolean");
+        object.setProperty(rt, "tiltGesturesEnabled", "boolean");
+        object.setProperty(rt, "distanceFilter", "number");
+        object.setProperty(rt, "headingFilter", "number");
+        return object;
+    }
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override
+    {
+        return facebook::jsi::Object(rt);
+    }
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        events.setProperty(rt, "topPress", createDirectEvent(rt, "onPress"));
+        events.setProperty(rt, "topPressPoi", createDirectEvent(rt, "onPressPoi"));
+        events.setProperty(rt, "topLongPress", createDirectEvent(rt, "onLongPress"));
+        events.setProperty(rt, "topCameraMove", createDirectEvent(rt, "onCameraMove"));
+        events.setProperty(rt, "topCameraIdle", createDirectEvent(rt, "onCameraIdle"));
+        events.setProperty(rt, "topLoad", createDirectEvent(rt, "onLoad"));
+        return events;
+    }
+};
+
+class CircleJSIBinder : public ViewComponentJSIBinder {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "center", "Object");
+        object.setProperty(rt, "strokeColor", "number");
+        object.setProperty(rt, "radius", "number");
+        object.setProperty(rt, "strokeWidth", "number");
+        object.setProperty(rt, "fillColor", "number");
+        object.setProperty(rt, "zIndex", "number");
+        return object;
+    }
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+        return facebook::jsi::Object(rt);
+    }
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+};
+
+class HeatMapJSIBinder : public ViewComponentJSIBinder {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "data", "array");
+        object.setProperty(rt, "radius", "number");
+        object.setProperty(rt, "opacity", "number");
+        return object;
+    }
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+        return facebook::jsi::Object(rt);
+    }
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+};
+
+class MultipointJSIBinder : public ViewComponentJSIBinder {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "items", "array");
+        object.setProperty(rt, "icon", "Object");
+        return object;
+    }
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+        return facebook::jsi::Object(rt);
+    }
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+};
+
+class MarkerJSIBinder : public ViewComponentJSIBinder {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "position", "Object");
+        object.setProperty(rt, "opacity", "number");
+        object.setProperty(rt, "draggable", "boolean");
+        object.setProperty(rt, "flat", "boolean");
+        object.setProperty(rt, "zIndex", "number");
+        object.setProperty(rt, "anchor", "Object");
+        object.setProperty(rt, "centerOffset", "Object");
+        object.setProperty(rt, "icon", "number");
+        return object;
+    }
+    
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+        return facebook::jsi::Object(rt);
+    }
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        events.setProperty(rt, "topPress", createDirectEvent(rt, "onPress"));
+        events.setProperty(rt, "topDragStart", createDirectEvent(rt, "onDragStart"));
+        events.setProperty(rt, "topDrag", createDirectEvent(rt, "onDrag"));
+        events.setProperty(rt, "topDragEnd", createDirectEvent(rt, "onDragEnd"));
+        return events;
+    }
+};
+
+class PolygonJSIBinder : public ViewComponentJSIBinder {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "points", "array");
+        object.setProperty(rt, "strokeWidth", "number");
+        object.setProperty(rt, "strokeColor", "number");
+        object.setProperty(rt, "fillColor", "number");
+        object.setProperty(rt, "zIndex", "number");
+        return object;
+    }
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+        return facebook::jsi::Object(rt);
+    }
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+};
+
+class PolylineJSIBinder : public ViewComponentJSIBinder {
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "points", "array");
+        object.setProperty(rt, "dotted", "boolean");
+        object.setProperty(rt, "geodesic", "boolean");
+        object.setProperty(rt, "zIndex", "number");
+        object.setProperty(rt, "color", "number");
+        object.setProperty(rt, "colors", "array");
+        object.setProperty(rt, "gradient", "boolean");
+        object.setProperty(rt, "width", "number");
+        return object;
+    }
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+        return facebook::jsi::Object(rt);
+    }
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        events.setProperty(rt, "topPress", createDirectEvent(rt, "onPress"));
+        return events;
+    }
+};
+
+} // namespace  rnoh
+#endif

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

@@ -0,0 +1,43 @@
+#ifndef HARMONY_MAPVIEW_SRC_MAIN_CPP_MAPVIEWPACKAGE_H
+#define HARMONY_MAPVIEW_SRC_MAIN_CPP_MAPVIEWPACKAGE_H
+
+
+#include "RNOH/Package.h"
+#include "ComponentDescriptors.h"
+#include "MapViewJSIBinder.h"
+#include "AMap3dEventEmitRequestHandler.h"
+
+namespace rnoh {
+
+class MapViewPackage : public Package {
+public:
+    MapViewPackage(Package::Context ctx) : Package(ctx) {}
+    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override {
+        return {facebook::react::concreteComponentDescriptorProvider<facebook::react::MapViewComponentDescriptor>(),
+                facebook::react::concreteComponentDescriptorProvider<facebook::react::HeatMapComponentDescriptor>(),
+                facebook::react::concreteComponentDescriptorProvider<facebook::react::CircleComponentDescriptor>(),
+                facebook::react::concreteComponentDescriptorProvider<facebook::react::PolylineComponentDescriptor>(),
+                facebook::react::concreteComponentDescriptorProvider<facebook::react::PolygonComponentDescriptor>(),
+                facebook::react::concreteComponentDescriptorProvider<facebook::react::MultipointComponentDescriptor>(),
+                facebook::react::concreteComponentDescriptorProvider<facebook::react::MarkerComponentDescriptor>()};
+    }
+
+    ComponentJSIBinderByString createComponentJSIBinderByName() override {
+        return {{"AMapView", std::make_shared<MapViewJSIBinder>()},
+                {"AMapHeatMap", std::make_shared<HeatMapJSIBinder>()},
+                {"AMapCircle", std::make_shared<CircleJSIBinder>()},
+                {"AMapPolyline", std::make_shared<PolylineJSIBinder>()},
+                {"AMapPolygon", std::make_shared<PolygonJSIBinder>()},
+                {"AMapMultiPoint", std::make_shared<MultipointJSIBinder>()},
+                {"AMapMarker", std::make_shared<MarkerJSIBinder>()}};
+    }
+    EventEmitRequestHandlers createEventEmitRequestHandlers() override {
+        return {
+            {std::make_shared<AMapViewEventEmitRequestHandler>()},
+            {std::make_shared<AMapMarkerEventEmitRequestHandler>()},
+            {std::make_shared<AMapPolylineEventEmitRequestHandler>()},
+        };
+    }
+};
+} // namespace rnoh
+#endif

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

@@ -0,0 +1,86 @@
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+#include "Props.h"
+
+namespace facebook {
+namespace react {
+
+MapViewProps::MapViewProps(const PropsParserContext &context, const MapViewProps &sourceProps, const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      initialCameraPosition(convertRawProp(context, rawProps, "initialCameraPosition",
+                                           sourceProps.initialCameraPosition, {{0, 0}, 0, 0, 0})),
+      myLocationEnabled(convertRawProp(context, rawProps, "myLocationEnabled", sourceProps.myLocationEnabled, false)),
+      indoorViewEnabled(convertRawProp(context, rawProps, "indoorViewEnabled", sourceProps.indoorViewEnabled, false)),
+      buildingsEnabled(convertRawProp(context, rawProps, "buildingsEnabled", sourceProps.buildingsEnabled, false)),
+      labelsEnabled(convertRawProp(context, rawProps, "labelsEnabled", sourceProps.labelsEnabled, false)),
+      compassEnabled(convertRawProp(context, rawProps, "compassEnabled", sourceProps.compassEnabled, false)),
+      zoomControlsEnabled(
+          convertRawProp(context, rawProps, "zoomControlsEnabled", sourceProps.zoomControlsEnabled, false)),
+      scaleControlsEnabled(
+          convertRawProp(context, rawProps, "scaleControlsEnabled", sourceProps.scaleControlsEnabled, false)),
+      trafficEnabled(convertRawProp(context, rawProps, "trafficEnabled", sourceProps.trafficEnabled, false)),
+      maxZoom(convertRawProp(context, rawProps, "maxZoom", sourceProps.maxZoom, 0.f)),
+      minZoom(convertRawProp(context, rawProps, "minZoom", sourceProps.minZoom, 0.f)),
+      mapType(convertRawProp(context, rawProps, "mapType", sourceProps.mapType, 0)),
+      zoomGesturesEnabled(
+          convertRawProp(context, rawProps, "zoomGesturesEnabled", sourceProps.zoomGesturesEnabled, false)),
+      scrollGesturesEnabled(
+          convertRawProp(context, rawProps, "scrollGesturesEnabled", sourceProps.scrollGesturesEnabled, false)),
+      rotateGesturesEnabled(
+          convertRawProp(context, rawProps, "rotateGesturesEnabled", sourceProps.rotateGesturesEnabled, false)),
+      tiltGesturesEnabled(
+          convertRawProp(context, rawProps, "tiltGesturesEnabled", sourceProps.tiltGesturesEnabled, false)) {}
+
+CircleProps::CircleProps(const PropsParserContext &context, const CircleProps &sourceProps, const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      circle(convertRawProp(context, rawProps, "data", sourceProps.circle, {0, 0})),
+      radius(convertRawProp(context, rawProps, "radius", sourceProps.radius, 2.f)),
+      strokeWidth(convertRawProp(context, rawProps, "strokeWidth", sourceProps.strokeWidth, 1.f)),
+      strokeColor(convertRawProp(context, rawProps, "strokeColor", sourceProps.strokeColor, 0x000000)),
+      fillColor(convertRawProp(context, rawProps, "fillColor", sourceProps.fillColor, 0x000000)),
+      levelIndex(convertRawProp(context, rawProps, "zIndex", sourceProps.levelIndex, 0)) {}
+
+HeatMapProps::HeatMapProps(const PropsParserContext &context, const HeatMapProps &sourceProps, const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      radius(convertRawProp(context, rawProps, "radius", sourceProps.radius, 2.f)),
+      opacity(convertRawProp(context, rawProps, "opacity", sourceProps.opacity, 0.f)),
+      data(convertRawProp(context, rawProps, "data", sourceProps.data, {{0, 0}, {0, 0}, {0, 0}})) {}
+
+MultipointProps::MultipointProps(const PropsParserContext &context, const MultipointProps &sourceProps,
+                                 const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      items(convertRawProp(context, rawProps, "items", sourceProps.items, {{0, 0}, {0, 0}, {0, 0}})),
+      icon(convertRawProp(context, rawProps, "radius", sourceProps.icon, {"/0", 0, 0, 0, "/0", "/0", "/0"})) {}
+
+MarkerProps::MarkerProps(const PropsParserContext &context, const MarkerProps &sourceProps, const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      draggable(convertRawProp(context, rawProps, "draggable", sourceProps.draggable, false)),
+      flat(convertRawProp(context, rawProps, "flat", sourceProps.flat, false)),
+      anchor(convertRawProp(context, rawProps, "anchor", sourceProps.anchor, {0,0})),
+      centerOffset(convertRawProp(context, rawProps, "centerOffset", sourceProps.centerOffset, {0,0})),
+      position(convertRawProp(context, rawProps, "position", sourceProps.position, {0,0})),
+      levelIndex(convertRawProp(context, rawProps, "zIndex", sourceProps.levelIndex, 0)),
+      icon(convertRawProp(context, rawProps, "icon", sourceProps.icon,{"/0", 0, 0, 0, "/0", "/0", "/0"})) {}
+
+PolylineProps::PolylineProps(const PropsParserContext &context, const PolylineProps &sourceProps,
+                             const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      width(convertRawProp(context, rawProps, "width", sourceProps.width, 1.f)),
+      color(convertRawProp(context, rawProps, "color", sourceProps.color, 0x000000)),
+      colors(convertRawProp(context, rawProps, "colors", sourceProps.colors, {0xFF5566,0x112233,0x114477})),
+      levelIndex(convertRawProp(context, rawProps, "zIndex", sourceProps.levelIndex, 0.f)),
+      geodesic(convertRawProp(context, rawProps, "geodesic", sourceProps.geodesic, false)),
+      dotted(convertRawProp(context, rawProps, "dotted", sourceProps.dotted, false)),
+      gradient(convertRawProp(context, rawProps, "gradient", sourceProps.gradient, false)),
+      points(convertRawProp(context, rawProps, "points", sourceProps.points, {{0, 0}, {0, 0}, {0, 0}})) {}
+
+PolygonProps::PolygonProps(const PropsParserContext &context, const PolygonProps &sourceProps, const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps),
+      points(convertRawProp(context, rawProps, "points", sourceProps.points, {{0, 0}, {0, 0}, {0, 0}})),
+      strokeWidth(convertRawProp(context, rawProps, "strokeWidth", sourceProps.strokeWidth, 1.f)),
+      strokeColor(convertRawProp(context, rawProps, "strokeColor", sourceProps.strokeColor, 0x000000)),
+      fillColor(convertRawProp(context, rawProps, "fillColor", sourceProps.fillColor, 0x000000)),
+      levelIndex(convertRawProp(context, rawProps, "zIndex", sourceProps.levelIndex, 0.f)) {}
+
+} // namespace react
+} // namespace facebook

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

@@ -0,0 +1,258 @@
+#ifndef HARMONY_RN_AMAP3D_SRC_MAIN_CPP_PROPS_H
+#define HARMONY_RN_AMAP3D_SRC_MAIN_CPP_PROPS_H
+
+#include <jsi/jsi.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook {
+namespace react {
+
+struct LatLng {
+    double latitude;
+    double longitude;
+};
+
+struct CameraPosition {
+    LatLng target;
+    double zoom;
+    double bearing;
+    double tilt;
+};
+
+struct ImageSourcePropType {
+    std::string uri;
+    double width;
+    double height;
+    double scale;
+    std::string method;
+    std::string body;
+    std::string bundle;
+};
+
+static inline void fromRawValue(const PropsParserContext &context, const RawValue &value, LatLng &result) {
+    auto map = (std::unordered_map<std::string, RawValue>)value;
+    auto tmp_latitude = map.find("latitude");
+    if (tmp_latitude != map.end()) {
+        fromRawValue(context, tmp_latitude->second, result.latitude);
+    }
+    auto tmp_longitude = map.find("longitude");
+    if (tmp_longitude != map.end()) {
+        fromRawValue(context, tmp_longitude->second, result.longitude);
+    }
+}
+
+static 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;
+    auto tmp_target = map.find("target");
+    if (tmp_target != map.end()) {
+        fromRawValue(context, tmp_target->second, result.target);
+    }
+    auto tmp_zoom = map.find("zoom");
+    if (tmp_zoom != map.end()) {
+        fromRawValue(context, tmp_zoom->second, result.zoom);
+    }
+    auto tmp_bearing = map.find("bearing");
+    if (tmp_bearing != map.end()) {
+        fromRawValue(context, tmp_bearing->second, result.bearing);
+    }
+    auto tmp_tilt = map.find("tilt");
+    if (tmp_tilt != map.end()) {
+        fromRawValue(context, tmp_tilt->second, result.tilt);
+    }
+}
+
+static 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;
+    auto tmp_uri = map.find("uri");
+    if (tmp_uri != map.end()) {
+        fromRawValue(context, tmp_uri->second, result.uri);
+    }
+    auto tmp_width = map.find("width");
+    if (tmp_width != map.end()) {
+        fromRawValue(context, tmp_width->second, result.width);
+    }
+    auto tmp_height = map.find("height");
+    if (tmp_height != map.end()) {
+        fromRawValue(context, tmp_height->second, result.height);
+    }
+    auto tmp_scale = map.find("scale");
+    if (tmp_scale != map.end()) {
+        fromRawValue(context, tmp_scale->second, result.scale);
+    }
+    auto tmp_method = map.find("method");
+    if (tmp_method != map.end()) {
+        fromRawValue(context, tmp_method->second, result.method);
+    }
+    auto tmp_body = map.find("body");
+    if (tmp_body != map.end()) {
+        fromRawValue(context, tmp_body->second, result.body);
+    }
+    auto tmp_bundle = map.find("bundle");
+    if (tmp_bundle != map.end()) {
+        fromRawValue(context, tmp_bundle->second, result.bundle);
+    }
+}
+
+static inline std::string toString(const ImageSourcePropType &value) { return "[Object ImageSourcePropType]"; }
+
+class JSI_EXPORT MapViewProps final : public ViewProps {
+public:
+    MapViewProps() = default;
+    MapViewProps(const PropsParserContext &context, const MapViewProps &sourceProps, const RawProps &rawProps);
+
+#pragma mark - Props
+    // 地图类型
+    int mapType;
+    // 初始状态
+    CameraPosition initialCameraPosition;
+    // 是否显示当前定位
+    bool myLocationEnabled;
+    // 是否显示室内地图
+    bool indoorViewEnabled;
+    // 是否显示3D建筑
+    bool buildingsEnabled;
+    // 是否显示标注
+    bool labelsEnabled;
+    // 是否显示指南针
+    bool compassEnabled;
+    // 是否显示放大缩小按钮
+    bool zoomControlsEnabled;
+    // 是否显示比例尺
+    bool scaleControlsEnabled;
+    // 是否显示路况
+    bool trafficEnabled;
+    // 最大缩放级别
+    double maxZoom;
+    // 最小缩放级别
+    double minZoom;
+    // 是否启用缩放手势，用于放大缩小
+    bool zoomGesturesEnabled;
+    // 是否启用滑动手势，用于平移
+    bool scrollGesturesEnabled;
+    // 是否启用旋转手势，用于调整方向
+    bool rotateGesturesEnabled;
+    // 是否启用倾斜手势，用于改变视角
+    bool tiltGesturesEnabled;
+    //设定定位的最小更新距离
+    double distanceFilter;
+    //设定最小更新角度，默认为 1 度
+    double headingFilter;
+};
+
+class JSI_EXPORT CircleProps final : public ViewProps {
+public:
+    CircleProps() = default;
+    CircleProps(const PropsParserContext &context, const CircleProps &sourceProps, const RawProps &rawProps);
+
+#pragma mark - CircleProps
+    // 圆点坐标
+    LatLng circle;
+    // 半径
+    double radius;
+    // 边线宽度
+    double strokeWidth;
+    // 边线颜色
+    int strokeColor;
+    // 填充颜色
+    int fillColor;
+    // 层级
+    int levelIndex;
+};
+
+class JSI_EXPORT HeatMapProps final : public ViewProps {
+public:
+    HeatMapProps() = default;
+    HeatMapProps(const PropsParserContext &context, const HeatMapProps &sourceProps, const RawProps &rawProps);
+#pragma mark - HeatMapProps
+    // 节点坐标
+    std::vector<LatLng> data;
+    // 半径（米）
+    double radius;
+    // 透明度
+    double opacity;
+};
+
+class JSI_EXPORT MultipointProps final : public ViewProps {
+public:
+    MultipointProps() = default;
+    MultipointProps(const PropsParserContext &context, const MultipointProps &sourceProps, const RawProps &rawProps);
+
+#pragma mark - Multipoint
+    // 坐标点集合
+    std::vector<LatLng> items;
+    // icon
+    ImageSourcePropType icon;
+};
+
+class JSI_EXPORT MarkerProps final : public ViewProps {
+public:
+    MarkerProps() = default;
+    MarkerProps(const PropsParserContext &context, const MarkerProps &sourceProps, const RawProps &rawProps);
+
+#pragma mark - MarkerProps
+    // 坐标
+    LatLng position;
+    // 是否可拖拽
+    bool draggable;
+    // 是否平贴地图
+    bool flat;
+    // 层级
+    int levelIndex;
+    // 覆盖物锚点比例
+    Point anchor;
+    //覆盖物偏移位置
+    Point centerOffset;
+    // icon
+    ImageSourcePropType icon;
+};
+
+class JSI_EXPORT PolylineProps final : public ViewProps {
+public:
+    PolylineProps() = default;
+    PolylineProps(const PropsParserContext &context, const PolylineProps &sourceProps, const RawProps &rawProps);
+
+#pragma mark - PolylineProps
+    // 节点坐标
+    std::vector<LatLng> points;
+    // 线段宽度
+    double width;
+    // 线段颜色
+    int color;
+    // 多段颜色
+    std::vector<int> colors;
+    // 层级
+    double levelIndex;
+    // 是否绘制大地线
+    bool geodesic;
+    // 是否绘制虚线
+    bool dotted;
+    // 是否颜色渐变
+    bool gradient;
+};
+
+class JSI_EXPORT PolygonProps final : public ViewProps {
+public:
+    PolygonProps() = default;
+    PolygonProps(const PropsParserContext &context, const PolygonProps &sourceProps, const RawProps &rawProps);
+
+#pragma mark - PolygonProps
+    // 节点坐标
+    std::vector<LatLng> points;
+    // 边线宽度
+    double strokeWidth;
+    // 边线颜色
+    int strokeColor;
+    // 填充颜色
+    int fillColor;
+    // 层级
+    double levelIndex;
+};
+} // namespace react
+} // namespace facebook
+#endif

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

@@ -0,0 +1,15 @@
+#include "ShadowNodes.h"
+
+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";
+
+} // namespace react
+} // namespace facebook

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

@@ -0,0 +1,33 @@
+#ifndef HARMONY_MAPVIEW_SRC_MAIN_CPP_SHADOWNODES_H
+#define HARMONY_MAPVIEW_SRC_MAIN_CPP_SHADOWNODES_H
+
+#include "Props.h"
+#include "AMapEventEmitters.h"
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <jsi/jsi.h>
+
+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[];
+
+/*
+ * `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>;
+
+} // namespace react
+} // namespace facebook
+#endif

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

@@ -0,0 +1,32 @@
+/**
+ * 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 { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+
+
+export class AMap3DModule extends TurboModule {
+  constructor(ctx: TurboModuleContext) {
+    super(ctx);
+  }
+}