expo-gaode-map 1.0.4 → 1.0.6

package/src/ExpoGaodeMapModule.ts

@@ -1,12 +1,46 @@
-
 import { NativeModule, requireNativeModule } from 'expo';
 import type { ExpoGaodeMapModuleEvents } from './ExpoGaodeMap.types';
-
+import type { LatLng, CoordinateType } from './types';
 
 declare class ExpoGaodeMapModule extends NativeModule<ExpoGaodeMapModuleEvents> {
-  // 地图控制方法已移至 MapView 的 ref 调用
-  // 使用方式: mapRef.current.moveCamera() 等
+  // SDK 初始化
+  initSDK(config: { androidKey?: string; iosKey?: string }): void;
+  getVersion(): string;
+  
+  // 定位控制
+  start(): void;
+  stop(): void;
+  isStarted(): Promise<boolean>;
+  getCurrentLocation(): Promise<any>;
+  coordinateConvert(coordinate: LatLng, type: CoordinateType): Promise<LatLng>;
+  
+  // 定位配置
+  setLocatingWithReGeocode(isReGeocode: boolean): void;
+  setLocationMode(mode: number): void;
+  setInterval(interval: number): void;
+  setOnceLocation(isOnceLocation: boolean): void;
+  setSensorEnable(sensorEnable: boolean): void;
+  setWifiScan(wifiScan: boolean): void;
+  setGpsFirst(gpsFirst: boolean): void;
+  setOnceLocationLatest(onceLocationLatest: boolean): void;
+  setGeoLanguage(language: string): void;
+  setLocationCacheEnable(locationCacheEnable: boolean): void;
+  setHttpTimeOut(httpTimeOut: number): void;
+  setDesiredAccuracy(accuracy: number): void;
+  setLocationTimeout(timeout: number): void;
+  setReGeocodeTimeout(timeout: number): void;
+  setDistanceFilter(distance: number): void;
+  setPausesLocationUpdatesAutomatically(pauses: boolean): void;
+  setAllowsBackgroundLocationUpdates(allows: boolean): void;
+  setLocationProtocol(protocol: string): void;
+  
+  // 方向更新 (iOS)
+  startUpdatingHeading(): void;
+  stopUpdatingHeading(): void;
+  
+  // 权限
+  checkLocationPermission(): Promise<any>;
+  requestLocationPermission(): Promise<any>;
 }
 
-// This call loads the native module object from the JSI.
 export default requireNativeModule<ExpoGaodeMapModule>('ExpoGaodeMap');

package/src/ExpoGaodeMapView.tsx

@@ -1,6 +1,6 @@
 import { requireNativeViewManager } from 'expo-modules-core';
 import * as React from 'react';
-
+import { EventManager } from './utils/EventManager';
 import type {
   MapViewProps,
   MapViewRef,
@@ -14,15 +14,12 @@ import type {
   PolygonProps,
 } from './types';
 
-// 重新导出 MapViewRef 供外部使用
 export type { MapViewRef } from './types';
 
 const NativeView: React.ComponentType<MapViewProps & { ref?: React.Ref<NativeMapViewRef> }> = requireNativeViewManager('ExpoGaodeMap');
 
-// 创建 Context 用于子组件访问 MapRef
 export const MapContext = React.createContext<React.RefObject<MapViewRef | null> | null>(null);
 
-// Marker 事件管理器
 type MarkerEventCallbacks = {
   onPress?: () => void;
   onDragStart?: () => void;
@@ -30,104 +27,14 @@ type MarkerEventCallbacks = {
   onDragEnd?: (event: { nativeEvent: LatLng }) => void;
 };
 
-class MarkerEventManager {
-  private callbacks = new Map<string, MarkerEventCallbacks>();
-  
-  register(markerId: string, callbacks: MarkerEventCallbacks) {
-    this.callbacks.set(markerId, callbacks);
-  }
-  
-  unregister(markerId: string) {
-    this.callbacks.delete(markerId);
-  }
-  
-  trigger(markerId: string, eventType: keyof MarkerEventCallbacks, data?: any) {
-    const callbacks = this.callbacks.get(markerId);
-    if (callbacks && callbacks[eventType]) {
-      callbacks[eventType]!(data);
-    }
-  }
-}
-
-export const MarkerEventContext = React.createContext<MarkerEventManager | null>(null);
-
-// Circle 事件管理器
-type CircleEventCallbacks = {
-  onPress?: () => void;
-};
-
-class CircleEventManager {
-  private callbacks = new Map<string, CircleEventCallbacks>();
-  
-  register(circleId: string, callbacks: CircleEventCallbacks) {
-    this.callbacks.set(circleId, callbacks);
-  }
-  
-  unregister(circleId: string) {
-    this.callbacks.delete(circleId);
-  }
-  
-  trigger(circleId: string, eventType: keyof CircleEventCallbacks) {
-    const callbacks = this.callbacks.get(circleId);
-    if (callbacks && callbacks[eventType]) {
-      callbacks[eventType]!();
-    }
-  }
-}
-
-export const CircleEventContext = React.createContext<CircleEventManager | null>(null);
-
-// Polygon 事件管理器
-type PolygonEventCallbacks = {
-  onPress?: () => void;
-};
-
-class PolygonEventManager {
-  private callbacks = new Map<string, PolygonEventCallbacks>();
-  
-  register(polygonId: string, callbacks: PolygonEventCallbacks) {
-    this.callbacks.set(polygonId, callbacks);
-  }
-  
-  unregister(polygonId: string) {
-    this.callbacks.delete(polygonId);
-  }
-  
-  trigger(polygonId: string, eventType: keyof PolygonEventCallbacks) {
-    const callbacks = this.callbacks.get(polygonId);
-    if (callbacks && callbacks[eventType]) {
-      callbacks[eventType]!();
-    }
-  }
-}
-
-export const PolygonEventContext = React.createContext<PolygonEventManager | null>(null);
-
-// Polyline 事件管理器
-type PolylineEventCallbacks = {
+type OverlayEventCallbacks = {
   onPress?: () => void;
 };
 
-class PolylineEventManager {
-  private callbacks = new Map<string, PolylineEventCallbacks>();
-  
-  register(polylineId: string, callbacks: PolylineEventCallbacks) {
-    this.callbacks.set(polylineId, callbacks);
-  }
-  
-  unregister(polylineId: string) {
-    this.callbacks.delete(polylineId);
-  }
-  
-  trigger(polylineId: string, eventType: keyof PolylineEventCallbacks) {
-    const callbacks = this.callbacks.get(polylineId);
-    if (callbacks && callbacks[eventType]) {
-      callbacks[eventType]!();
-    }
-  }
-}
-
-export const PolylineEventContext = React.createContext<PolylineEventManager | null>(null);
+export const MarkerEventContext = React.createContext<EventManager<MarkerEventCallbacks> | null>(null);
+export const CircleEventContext = React.createContext<EventManager<OverlayEventCallbacks> | null>(null);
+export const PolygonEventContext = React.createContext<EventManager<OverlayEventCallbacks> | null>(null);
+export const PolylineEventContext = React.createContext<EventManager<OverlayEventCallbacks> | null>(null);
 
 /**
  * 高德地图视图组件，提供地图操作API和覆盖物管理功能
@@ -150,37 +57,29 @@ export const PolylineEventContext = React.createContext<PolylineEventManager | n
 const ExpoGaodeMapView = React.forwardRef<MapViewRef, MapViewProps>((props, ref) => {
   const nativeRef = React.useRef<NativeMapViewRef>(null);
   const internalRef = React.useRef<MapViewRef | null>(null);
-  const markerEventManager = React.useRef(new MarkerEventManager()).current;
-  const circleEventManager = React.useRef(new CircleEventManager()).current;
-  const polygonEventManager = React.useRef(new PolygonEventManager()).current;
-  const polylineEventManager = React.useRef(new PolylineEventManager()).current;
-  
-  // 处理 Marker 事件
-  const handleMarkerPress = React.useCallback((event: any) => {
+  const markerEventManager = React.useMemo(() => new EventManager<MarkerEventCallbacks>(), []);
+  const circleEventManager = React.useMemo(() => new EventManager<OverlayEventCallbacks>(), []);
+  const polygonEventManager = React.useMemo(() => new EventManager<OverlayEventCallbacks>(), []);
+  const polylineEventManager = React.useMemo(() => new EventManager<OverlayEventCallbacks>(), []);
+  const handleMarkerPress = (event: any) => {
     const markerId = event.nativeEvent?.markerId;
-    if (markerId) {
-      markerEventManager.trigger(markerId, 'onPress');
-    }
+    if (markerId) markerEventManager.trigger(markerId, 'onPress');
     props.onMarkerPress?.(event);
-  }, [props.onMarkerPress]);
+  };
   
-  const handleMarkerDragStart = React.useCallback((event: any) => {
+  const handleMarkerDragStart = (event: any) => {
     const markerId = event.nativeEvent?.markerId;
-    if (markerId) {
-      markerEventManager.trigger(markerId, 'onDragStart');
-    }
+    if (markerId) markerEventManager.trigger(markerId, 'onDragStart');
     props.onMarkerDragStart?.(event);
-  }, [props.onMarkerDragStart]);
+  };
   
-  const handleMarkerDrag = React.useCallback((event: any) => {
+  const handleMarkerDrag = (event: any) => {
     const markerId = event.nativeEvent?.markerId;
-    if (markerId) {
-      markerEventManager.trigger(markerId, 'onDrag');
-    }
+    if (markerId) markerEventManager.trigger(markerId, 'onDrag');
     props.onMarkerDrag?.(event);
-  }, [props.onMarkerDrag]);
+  };
   
-  const handleMarkerDragEnd = React.useCallback((event: any) => {
+  const handleMarkerDragEnd = (event: any) => {
     const markerId = event.nativeEvent?.markerId;
     if (markerId) {
       markerEventManager.trigger(markerId, 'onDragEnd', {
@@ -191,31 +90,25 @@ const ExpoGaodeMapView = React.forwardRef<MapViewRef, MapViewProps>((props, ref)
       });
     }
     props.onMarkerDragEnd?.(event);
-  }, [props.onMarkerDragEnd]);
+  };
   
-  const handleCirclePress = React.useCallback((event: any) => {
+  const handleCirclePress = (event: any) => {
     const circleId = event.nativeEvent?.circleId;
-    if (circleId) {
-      circleEventManager.trigger(circleId, 'onPress');
-    }
+    if (circleId) circleEventManager.trigger(circleId, 'onPress');
     props.onCirclePress?.(event);
-  }, [props.onCirclePress]);
+  };
   
-  const handlePolygonPress = React.useCallback((event: any) => {
+  const handlePolygonPress = (event: any) => {
     const polygonId = event.nativeEvent?.polygonId;
-    if (polygonId) {
-      polygonEventManager.trigger(polygonId, 'onPress');
-    }
+    if (polygonId) polygonEventManager.trigger(polygonId, 'onPress');
     props.onPolygonPress?.(event);
-  }, [props.onPolygonPress]);
+  };
   
-  const handlePolylinePress = React.useCallback((event: any) => {
+  const handlePolylinePress = (event: any) => {
     const polylineId = event.nativeEvent?.polylineId;
-    if (polylineId) {
-      polylineEventManager.trigger(polylineId, 'onPress');
-    }
+    if (polylineId) polylineEventManager.trigger(polylineId, 'onPress');
     props.onPolylinePress?.(event);
-  }, [props.onPolylinePress]);
+  };
 
   const apiRef: MapViewRef = React.useMemo(() => ({
     /**

package/src/components/overlays/Circle.tsx

@@ -45,6 +45,14 @@ export default function Circle(props: CircleProps) {
     };
   }, []);
 
+  React.useEffect(() => {
+    if (circleIdRef.current && eventManager) {
+      eventManager.register(circleIdRef.current, {
+        onPress: props.onPress,
+      });
+    }
+  }, [props.onPress]);
+
   React.useEffect(() => {
     if (circleIdRef.current && mapRef?.current) {
       mapRef.current.updateCircle(circleIdRef.current, props);

package/src/components/overlays/Marker.tsx

@@ -59,6 +59,17 @@ function MarkerImperative(props: MarkerProps) {
     };
   }, []);
 
+  React.useEffect(() => {
+    if (markerIdRef.current && eventManager) {
+      eventManager.register(markerIdRef.current, {
+        onPress: props.onPress,
+        onDragStart: props.onDragStart,
+        onDrag: props.onDrag,
+        onDragEnd: props.onDragEnd,
+      });
+    }
+  }, [props.onPress, props.onDragStart, props.onDrag, props.onDragEnd]);
+
   React.useEffect(() => {
     if (markerIdRef.current && mapRef?.current) {
       const processedProps = { ...props };

package/src/components/overlays/Polygon.tsx

@@ -74,6 +74,14 @@ export default function Polygon(props: PolygonProps) {
     };
   }, []);
 
+  useEffect(() => {
+    if (polygonIdRef.current && eventManager) {
+      eventManager.register(polygonIdRef.current, {
+        onPress: props.onPress,
+      });
+    }
+  }, [props.onPress]);
+
   useEffect(() => {
     if (polygonIdRef.current && nativeRef?.current) {
       nativeRef.current.updatePolygon(polygonIdRef.current, {

package/src/components/overlays/Polyline.tsx

@@ -73,5 +73,13 @@ export default function Polyline(props: PolylineProps) {
     };
   }, []);
 
+  React.useEffect(() => {
+    if (polylineIdRef.current && eventManager) {
+      eventManager.register(polylineIdRef.current, {
+        onPress: props.onPress,
+      });
+    }
+  }, [props.onPress]);
+
   return null;
 }

package/src/modules/AMapLocation.ts

@@ -11,83 +11,48 @@ import type {
   CoordinateType,
 } from '../types';
 
+
+/**
+ * 配置方法映射表
+ * @type {Record<keyof LocationOptions, string>}
+ * 
+ */
+const CONFIG_MAP: Record<keyof LocationOptions, string> = {
+  withReGeocode: 'setLocatingWithReGeocode',
+  accuracy: 'setDesiredAccuracy',
+  mode: 'setLocationMode',
+  onceLocation: 'setOnceLocation',
+  interval: 'setInterval',
+  timeout: 'setLocationTimeout',
+  reGeocodeTimeout: 'setReGeocodeTimeout',
+  distanceFilter: 'setDistanceFilter',
+  sensorEnable: 'setSensorEnable',
+  wifiScan: 'setWifiScan',
+  gpsFirst: 'setGpsFirst',
+  onceLocationLatest: 'setOnceLocationLatest',
+  geoLanguage: 'setGeoLanguage',
+  allowsBackgroundLocationUpdates: 'setAllowsBackgroundLocationUpdates',
+  pausesLocationUpdatesAutomatically: 'setPausesLocationUpdatesAutomatically',
+  locationCacheEnable: 'setLocationCacheEnable',
+  httpTimeout: 'setHttpTimeOut',
+  protocol: 'setLocationProtocol',
+};
+
 /**
- * 配置高德地图定位服务的各项参数
+ * 配置高德地图定位选项
  * @param {LocationOptions} options - 定位配置选项对象
- * @param {boolean} [options.withReGeocode] - 是否返回逆地理编码信息
- * @param {number} [options.accuracy] - 定位精度设置
- * @param {string} [options.mode] - 定位模式
- * @param {boolean} [options.onceLocation] - 是否单次定位
- * @param {number} [options.interval] - 定位间隔(毫秒)
- * @param {number} [options.timeout] - 定位超时时间(毫秒)
- * @param {number} [options.reGeocodeTimeout] - 逆地理编码超时时间(毫秒)
- * @param {number} [options.distanceFilter] - 位置更新最小距离(米)
- * @param {boolean} [options.sensorEnable] - 是否启用传感器
- * @param {boolean} [options.wifiScan] - 是否开启WiFi扫描
- * @param {boolean} [options.gpsFirst] - 是否优先使用GPS
- * @param {boolean} [options.onceLocationLatest] - 是否获取最近3秒内最精确的位置
- * @param {string} [options.geoLanguage] - 地理编码语言
- * @param {boolean} [options.allowsBackgroundLocationUpdates] - 是否允许后台定位
- * @param {boolean} [options.pausesLocationUpdatesAutomatically] - 是否自动暂停定位
- * @param {boolean} [options.locationCacheEnable] - 是否启用定位缓存
- * @param {number} [options.httpTimeout] - 网络请求超时时间(毫秒)
- * @param {string} [options.protocol] - 定位协议
+ * @throws {Error} 当传入的配置方法不存在或不可调用时抛出错误
  */
 export function configure(options: LocationOptions): void {
-  if (options.withReGeocode !== undefined) {
-    ExpoGaodeMapModule.setLocatingWithReGeocode?.(options.withReGeocode);
-  }
-  if (options.accuracy !== undefined) {
-    ExpoGaodeMapModule.setDesiredAccuracy?.(options.accuracy);
-  }
-  if (options.mode !== undefined) {
-    ExpoGaodeMapModule.setLocationMode?.(options.mode);
-  }
-  if (options.onceLocation !== undefined) {
-    ExpoGaodeMapModule.setOnceLocation?.(options.onceLocation);
-  }
-  if (options.interval !== undefined) {
-    ExpoGaodeMapModule.setInterval?.(options.interval);
-  }
-  if (options.timeout !== undefined) {
-    ExpoGaodeMapModule.setLocationTimeout?.(options.timeout);
-  }
-  if (options.reGeocodeTimeout !== undefined) {
-    ExpoGaodeMapModule.setReGeocodeTimeout?.(options.reGeocodeTimeout);
-  }
-  if (options.distanceFilter !== undefined) {
-    ExpoGaodeMapModule.setDistanceFilter?.(options.distanceFilter);
-  }
-  if (options.sensorEnable !== undefined) {
-    ExpoGaodeMapModule.setSensorEnable?.(options.sensorEnable);
-  }
-  if (options.wifiScan !== undefined) {
-    ExpoGaodeMapModule.setWifiScan?.(options.wifiScan);
-  }
-  if (options.gpsFirst !== undefined) {
-    ExpoGaodeMapModule.setGpsFirst?.(options.gpsFirst);
-  }
-  if (options.onceLocationLatest !== undefined) {
-    ExpoGaodeMapModule.setOnceLocationLatest?.(options.onceLocationLatest);
-  }
-  if (options.geoLanguage !== undefined) {
-    ExpoGaodeMapModule.setGeoLanguage?.(options.geoLanguage);
-  }
-  if (options.allowsBackgroundLocationUpdates !== undefined) {
-    ExpoGaodeMapModule.setAllowsBackgroundLocationUpdates?.(options.allowsBackgroundLocationUpdates);
-  }
-  if (options.pausesLocationUpdatesAutomatically !== undefined) {
-    ExpoGaodeMapModule.setPausesLocationUpdatesAutomatically?.(options.pausesLocationUpdatesAutomatically);
-  }
-  if (options.locationCacheEnable !== undefined) {
-    ExpoGaodeMapModule.setLocationCacheEnable?.(options.locationCacheEnable);
-  }
-  if (options.httpTimeout !== undefined) {
-    ExpoGaodeMapModule.setHttpTimeOut?.(options.httpTimeout);
-  }
-  if (options.protocol !== undefined) {
-    ExpoGaodeMapModule.setLocationProtocol?.(options.protocol);
-  }
+  Object.entries(options).forEach(([key, value]) => {
+    if (value !== undefined) {
+      const methodName = CONFIG_MAP[key as keyof LocationOptions];
+      const method = ExpoGaodeMapModule[methodName as keyof typeof ExpoGaodeMapModule];
+      if (typeof method === 'function') {
+        (method as any).call(ExpoGaodeMapModule, value);
+      }
+    }
+  });
 }
 
 

package/src/types/location.types.ts

@@ -324,7 +324,6 @@ export interface LocationOptions {
 
   /**
    * 是否允许后台定位
-   * @platform ios
    * @default false
    */
   allowsBackgroundLocationUpdates?: boolean;

package/src/utils/EventManager.ts

@@ -0,0 +1,23 @@
+/**
+ * 通用事件管理器
+ * 用于管理地图覆盖物的事件回调
+ */
+export class EventManager<T extends Record<string, any>> {
+  private callbacks = new Map<string, T>();
+  
+  register(id: string, callbacks: T) {
+    this.callbacks.set(id, callbacks);
+  }
+  
+  unregister(id: string) {
+    this.callbacks.delete(id);
+  }
+  
+  trigger<K extends keyof T>(id: string, eventType: K, data?: any) {
+    const callbacks = this.callbacks.get(id);
+    const callback = callbacks?.[eventType];
+    if (typeof callback === 'function') {
+      callback(data);
+    }
+  }
+}