react-native-maps 1.21.0-alpha.4 → 1.21.0-alpha.41

package/ios/AirMaps/RNMapsMarkerView.h

@@ -0,0 +1,24 @@
+//
+//  RNMapsMarker.h
+//  AirMaps
+//
+//  Created by Salah Ghanim on 23.11.24.
+//  Copyright © 2024 react-native-maps. All rights reserved.
+//
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^LoadCompletionHandler)(UIView *view);
+
+@class AIRMapMarker;
+@interface RNMapsMarkerView : RCTViewComponentView
+- (AIRMapMarker*) marker;
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif

package/ios/AirMaps/RNMapsMarkerView.mm

@@ -0,0 +1,422 @@
+//
+//  RNMapsMarker.m
+//  AirMaps
+//
+//  Created by Salah Ghanim on 23.11.24.
+//  Copyright © 2024 react-native-maps. All rights reserved.
+//
+
+#import "RNMapsMarkerView.h"
+#import "AirMap.h"
+#import "AIRMapMarker.h"
+#import "AIRMapMarkerManager.h"
+#import <react/renderer/components/RNMapsSpecs/ComponentDescriptors.h>
+#import <react/renderer/components/RNMapsSpecs/EventEmitters.h>
+#import <react/renderer/components/RNMapsSpecs/Props.h>
+#import <react/renderer/components/RNMapsSpecs/RCTComponentViewHelpers.h>
+#import "RCTFabricComponentsPlugins.h"
+#import <React/RCTConversions.h>
+#import "UIView+AirMap.h"
+
+using namespace facebook::react;
+
+@interface RNMapsMarkerView () <RCTRNMapsMarkerViewProtocol>
+@end
+
+@implementation RNMapsMarkerView {
+    AIRMapMarker *_view;
+    AIRMapMarkerManager* _legacyMapManager;
+}
+
+- (AIRMapMarker *) marker {
+    return _view;
+}
+- (void) prepareForRecycle
+{
+    [super prepareForRecycle];
+    [_view removeFromSuperview];
+    _view = nil;
+    _legacyMapManager = nil;
+}
+
+#pragma mark - JS Commands
+
+
+#pragma mark - Native commands
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+    RCTRNMapsMarkerHandleCommand(self, commandName, args);
+}
+
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+    return concreteComponentDescriptorProvider<RNMapsMarkerComponentDescriptor>();
+}
+
+- (void) animateToCoordinates:(double)latitude longitude:(double)longitude duration:(NSInteger)duration
+{
+    [_view animateToCoordinate:CLLocationCoordinate2DMake(latitude, longitude) duration:duration/1000];
+}
+
+- (void) showCallout
+{
+    [_view.map selectAnnotation:_view animated:YES];
+}
+
+- (void) hideCallout
+{
+    [_view.map deselectAnnotation:_view animated:YES];
+
+}
+
+- (void) setCoordinates:(double)latitude longitude:(double)longitude
+{
+    [_view setCoordinate:CLLocationCoordinate2DMake(latitude, longitude)];
+}
+
+
+
+- (void) prepareMarkerView
+{
+    if (_legacyMapManager && _view) return;
+    static const auto defaultProps = std::make_shared<const RNMapsMarkerProps>();
+    _props = defaultProps;
+    _legacyMapManager = [[AIRMapMarkerManager alloc] init];
+    _view = (AIRMapMarker *)[_legacyMapManager view];
+    
+    
+    _view.onPress = [self](NSDictionary* dictionary) {
+        if (_eventEmitter) {
+            // Extract values from the NSDictionary
+            NSDictionary* coordinateDict = dictionary[@"coordinate"];
+            NSDictionary* positionDict = dictionary[@"position"];
+
+            // Populate the OnCalloutPressPoint struct
+            facebook::react::RNMapsMarkerEventEmitter::OnPressPosition point = {
+                .x = [coordinateDict[@"x"] doubleValue],
+                .y = [coordinateDict[@"y"] doubleValue],
+            };
+
+
+            facebook::react::RNMapsMarkerEventEmitter::OnPressCoordinate coordinate = {
+                .latitude = [coordinateDict[@"latitude"] doubleValue],
+                .longitude = [coordinateDict[@"longitude"] doubleValue],
+            };
+
+            auto eventEmitter = std::static_pointer_cast<RNMapsMarkerEventEmitter const>(_eventEmitter);
+            facebook::react::RNMapsMarkerEventEmitter::OnPress data = {
+                .action = std::string([dictionary[@"action"] UTF8String]),
+                .id = std::string([dictionary[@"id"] UTF8String]),
+                .position = point,
+                .coordinate = coordinate,
+            };
+            eventEmitter->onPress(data);
+        }
+    };
+    
+    _view.onDeselect = [self](NSDictionary* dictionary) {
+        if (_eventEmitter) {
+            // Extract values from the NSDictionary
+            NSDictionary* coordinateDict = dictionary[@"coordinate"];
+            NSDictionary* positionDict = dictionary[@"position"];
+
+            // Populate the OnCalloutPressPoint struct
+            facebook::react::RNMapsMarkerEventEmitter::OnDeselectPosition point = {
+                .x = [coordinateDict[@"x"] doubleValue],
+                .y = [coordinateDict[@"y"] doubleValue],
+            };
+
+
+            facebook::react::RNMapsMarkerEventEmitter::OnDeselectCoordinate coordinate = {
+                .latitude = [coordinateDict[@"latitude"] doubleValue],
+                .longitude = [coordinateDict[@"longitude"] doubleValue],
+            };
+
+            auto eventEmitter = std::static_pointer_cast<RNMapsMarkerEventEmitter const>(_eventEmitter);
+            facebook::react::RNMapsMarkerEventEmitter::OnDeselect data = {
+                .action = std::string([dictionary[@"action"] UTF8String]),
+                .id = std::string([dictionary[@"id"] UTF8String]),
+                .position = point,
+                .coordinate = coordinate,
+            };
+            eventEmitter->onDeselect(data);
+        }
+    };
+    
+    _view.onDrag = [self](NSDictionary* dictionary) {
+        if (_eventEmitter) {
+            // Extract values from the NSDictionary
+            NSDictionary* coordinateDict = dictionary[@"coordinate"];
+
+
+            facebook::react::RNMapsMarkerEventEmitter::OnDragCoordinate coordinate = {
+                .latitude = [coordinateDict[@"latitude"] doubleValue],
+                .longitude = [coordinateDict[@"longitude"] doubleValue],
+            };
+
+            auto eventEmitter = std::static_pointer_cast<RNMapsMarkerEventEmitter const>(_eventEmitter);
+            facebook::react::RNMapsMarkerEventEmitter::OnDrag data = {
+                .id = std::string([dictionary[@"id"] UTF8String]),
+                .coordinate = coordinate,
+            };
+            eventEmitter->onDrag(data);
+        }
+    };
+    _view.onDragStart = [self](NSDictionary* dictionary) {
+        if (_eventEmitter) {
+            // Extract values from the NSDictionary
+            NSDictionary* coordinateDict = dictionary[@"coordinate"];
+
+            facebook::react::RNMapsMarkerEventEmitter::OnDragStartCoordinate coordinate = {
+                .latitude = [coordinateDict[@"latitude"] doubleValue],
+                .longitude = [coordinateDict[@"longitude"] doubleValue],
+            };
+
+            auto eventEmitter = std::static_pointer_cast<RNMapsMarkerEventEmitter const>(_eventEmitter);
+            facebook::react::RNMapsMarkerEventEmitter::OnDragStart data = {
+                .id = std::string([dictionary[@"id"] UTF8String]),
+                .coordinate = coordinate,
+            };
+            eventEmitter->onDragStart(data);
+        }
+    };
+    
+    _view.onDragEnd = [self](NSDictionary* dictionary) {
+        if (_eventEmitter) {
+            // Extract values from the NSDictionary
+            NSDictionary* coordinateDict = dictionary[@"coordinate"];
+
+
+            facebook::react::RNMapsMarkerEventEmitter::OnDragEndCoordinate coordinate = {
+                .latitude = [coordinateDict[@"latitude"] doubleValue],
+                .longitude = [coordinateDict[@"longitude"] doubleValue],
+            };
+
+            auto eventEmitter = std::static_pointer_cast<RNMapsMarkerEventEmitter const>(_eventEmitter);
+            facebook::react::RNMapsMarkerEventEmitter::OnDragEnd data = {
+                .id = std::string([dictionary[@"id"] UTF8String]),
+                .coordinate = coordinate,
+            };
+            eventEmitter->onDragEnd(data);
+        }
+    };
+    
+    _view.onSelect = [self](NSDictionary* dictionary) {
+        if (_eventEmitter) {
+            // Extract values from the NSDictionary
+            NSDictionary* coordinateDict = dictionary[@"coordinate"];
+            NSDictionary* positionDict = dictionary[@"position"];
+
+            // Populate the OnCalloutPressPoint struct
+            facebook::react::RNMapsMarkerEventEmitter::OnSelectPosition point = {
+                .x = [coordinateDict[@"x"] doubleValue],
+                .y = [coordinateDict[@"y"] doubleValue],
+            };
+
+
+            facebook::react::RNMapsMarkerEventEmitter::OnSelectCoordinate coordinate = {
+                .latitude = [coordinateDict[@"latitude"] doubleValue],
+                .longitude = [coordinateDict[@"longitude"] doubleValue],
+            };
+
+            auto eventEmitter = std::static_pointer_cast<RNMapsMarkerEventEmitter const>(_eventEmitter);
+            facebook::react::RNMapsMarkerEventEmitter::OnSelect data = {
+                .action = std::string([dictionary[@"action"] UTF8String]),
+                .id = std::string([dictionary[@"id"] UTF8String]),
+                .position = point,
+                .coordinate = coordinate,
+            };
+            eventEmitter->onSelect(data);
+        }
+    };
+    
+    
+    _view.onCalloutPress = [self](NSDictionary* dictionary) {
+        if (_eventEmitter) {
+            // Extract values from the NSDictionary
+            NSDictionary* pointDict = dictionary[@"point"];
+            NSDictionary* frameDict = dictionary[@"frame"];
+
+            // Populate the OnCalloutPressPoint struct
+            facebook::react::RNMapsMarkerEventEmitter::OnCalloutPressPoint point = {
+                .x = [pointDict[@"x"] doubleValue],
+                .y = [pointDict[@"y"] doubleValue],
+            };
+
+
+            facebook::react::RNMapsMarkerEventEmitter::OnCalloutPressFrame frame = {
+                .x = [frameDict[@"x"] doubleValue],
+                .y = [frameDict[@"x"] doubleValue],
+                .width = [frameDict[@"width"] doubleValue],
+                .height = [frameDict[@"height"] doubleValue],
+            };
+
+            auto eventEmitter = std::static_pointer_cast<RNMapsMarkerEventEmitter const>(_eventEmitter);
+            facebook::react::RNMapsMarkerEventEmitter::OnCalloutPress data = {
+                .action = std::string([dictionary[@"action"] UTF8String]),
+                .id = std::string([dictionary[@"id"] UTF8String]),
+                .frame = frame,
+                .point = point,
+            };
+            eventEmitter->onCalloutPress(data);
+        }
+    };
+    
+}
+
+- (void)mountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index{
+    if (!_view){
+        [self prepareMarkerView];
+    }
+    id<RCTComponent> paperView = [childComponentView getPaperViewFromChildComponentView];
+    if (paperView){
+        [_view insertReactSubview:paperView atIndex:index];
+    } else  {
+        [_view insertReactSubview:childComponentView atIndex:index];
+    }
+}
+
+- (void) unmountChildComponentView:(UIView<RCTComponentViewProtocol> *)childComponentView index:(NSInteger)index
+{
+    id<RCTComponent> paperView = [childComponentView getPaperViewFromChildComponentView];
+    if (paperView){
+        [_view removeReactSubview:paperView];
+    } else {
+        [_view removeReactSubview:childComponentView];
+    }
+}
+- (instancetype)initWithFrame:(CGRect)frame
+{
+    if (self = [super initWithFrame:frame]) {
+        [self prepareMarkerView];
+    }
+    
+    return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+    [self prepareMarkerView];
+    const auto &oldViewProps = *std::static_pointer_cast<RNMapsMarkerProps const>(_props);
+    const auto &newViewProps = *std::static_pointer_cast<RNMapsMarkerProps const>(props);
+    BOOL completionHandlerCalled = false;
+    
+#define REMAP_MAPVIEW_PROP(name)                    \
+if (oldViewProps.name != newViewProps.name) {   \
+_view.name = newViewProps.name;             \
+}
+    
+#define REMAP_MAPVIEW_STRING_PROP(name)                             \
+if (oldViewProps.name != newViewProps.name) {                   \
+_view.name = RCTNSStringFromString(newViewProps.name);      \
+}
+    
+#define REMAP_MAPVIEW_COLOR_PROP(name)                                   \
+if (oldViewProps.name != newViewProps.name) {                        \
+_view.name = RCTUIColorFromSharedColor(newViewProps.name);       \
+}
+    
+#define REMAP_MAPVIEW_POINT_PROP(name)                               \
+if (newViewProps.name.x != oldViewProps.name.x ||                \
+newViewProps.name.y != oldViewProps.name.y) {                \
+_view.name = CGPointMake(newViewProps.name.x, newViewProps.name.y); \
+}
+    
+    if (newViewProps.zIndex != oldViewProps.zIndex){
+        if (newViewProps.zIndex.has_value()){
+            _view.zIndex = newViewProps.zIndex.value();
+        } else {
+            // default
+            _view.zIndex = 0;
+        }
+    }
+    if (newViewProps.image != oldViewProps.image){
+        if (newViewProps.image.uri.size()){
+            [_view setImageSrc:RCTNSStringFromString(newViewProps.image.uri)];
+            completionHandlerCalled = true;
+        } else {
+            [_view setImageSrc:nil];
+        }
+    }
+    
+    REMAP_MAPVIEW_PROP(useLegacyPinView)
+    
+    
+    REMAP_MAPVIEW_PROP(opacity)
+    REMAP_MAPVIEW_PROP(draggable)
+    REMAP_MAPVIEW_PROP(isPreselected)
+    
+    REMAP_MAPVIEW_COLOR_PROP(pinColor)
+
+    
+    REMAP_MAPVIEW_POINT_PROP(calloutOffset)
+    if (newViewProps.coordinate.latitude != oldViewProps.coordinate.latitude ||
+        newViewProps.coordinate.longitude != oldViewProps.coordinate.longitude) {
+        CLLocationCoordinate2D coordinates = CLLocationCoordinate2DMake(
+                                                                        newViewProps.coordinate.latitude,
+                                                                        newViewProps.coordinate.longitude);
+        _view.coordinate = coordinates;
+    }
+    
+    
+    if (newViewProps.description != oldViewProps.description){
+        _view.subtitle = RCTNSStringFromString(newViewProps.description);
+    }
+    REMAP_MAPVIEW_STRING_PROP(title)
+    REMAP_MAPVIEW_STRING_PROP(identifier)
+    if (newViewProps.titleVisibility != oldViewProps.titleVisibility){
+        switch (newViewProps.titleVisibility) {
+            case RNMapsMarkerTitleVisibility::Visible:
+                [_view setTitleVisibility:MKFeatureVisibilityVisible];
+                break;
+            case RNMapsMarkerTitleVisibility::Adaptive:
+                [_view setTitleVisibility:MKFeatureVisibilityAdaptive];
+                break;
+            case RNMapsMarkerTitleVisibility::Hidden:
+                [_view setTitleVisibility:MKFeatureVisibilityHidden];
+                break;
+        }
+    }
+    if (newViewProps.subtitleVisibility != oldViewProps.subtitleVisibility){
+        switch (newViewProps.subtitleVisibility) {
+            case RNMapsMarkerSubtitleVisibility::Visible:
+                [_view setSubtitleVisibility:MKFeatureVisibilityVisible];
+                break;
+            case RNMapsMarkerSubtitleVisibility::Adaptive:
+                [_view setSubtitleVisibility:MKFeatureVisibilityAdaptive];
+                break;
+            case RNMapsMarkerSubtitleVisibility::Hidden:
+                [_view setSubtitleVisibility:MKFeatureVisibilityHidden];
+                break;
+                
+        }
+    }
+    
+    if (newViewProps.displayPriority != oldViewProps.displayPriority){
+        switch (newViewProps.displayPriority) {
+            case RNMapsMarkerDisplayPriority::Required:
+                [_view setDisplayPriority:MKFeatureDisplayPriorityRequired];
+                break;
+            case RNMapsMarkerDisplayPriority::High:
+                [_view setDisplayPriority:MKFeatureDisplayPriorityDefaultHigh];
+                break;
+            case RNMapsMarkerDisplayPriority::Low:
+                [_view setDisplayPriority:MKFeatureDisplayPriorityDefaultLow];
+                break;
+                
+        }
+    }
+
+    
+    [super updateProps:props oldProps:oldProps];
+}
+
+
+@end
+
+Class<RCTComponentViewProtocol> RNMapsMarkerCls(void)
+{
+    return RNMapsMarkerView.class;
+}

package/ios/AirMaps/RNMapsMarkerViewManager.mm

@@ -0,0 +1,21 @@
+//
+//  RNMapsMarkerManager.m
+//  AirMaps
+//
+//  Created by Salah Ghanim on 23.11.24.
+//  Copyright © 2024 react-native-maps. All rights reserved.
+//
+
+#import <React/RCTLog.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTViewManager.h>
+
+@interface RNMapsMarkerViewManager : RCTViewManager
+@end
+
+@implementation RNMapsMarkerViewManager
+
+RCT_EXPORT_MODULE(RNMapsMarkerViewManager)
+
+
+@end

package/ios/AirMaps/UIView +AirMap.m

@@ -0,0 +1,20 @@
+//
+// Created by Leland Richardson on 12/27/15.
+// Copyright (c) 2015 Facebook. All rights reserved.
+//
+
+#import "UIView+AirMap.h"
+
+@implementation UIView (AirMap)
+
+- (UIView *) getPaperViewFromChildComponentView {
+    // Check if the childComponentView responds to the "adapter" selector
+    if ([self respondsToSelector:@selector(paperView)]) {
+        // Safely return the paperView
+        return [self valueForKey:@"paperView"];
+    }
+    // Return nil if paperView is not accessible
+    return nil;
+}
+
+@end

package/ios/AirMaps/UIView+AirMap.h

@@ -0,0 +1,11 @@
+//
+// Created by Salah Ghanim on 29/12/2024.
+// Copyright (c) 2015 Facebook. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+
+@interface UIView (AirMap)
+- (UIView *) getPaperViewFromChildComponentView;
+
+@end

package/lib/MapMarker.d.ts

@@ -2,6 +2,7 @@ import * as React from 'react';
 import { Animated, ViewProps, ImageURISource, ImageRequireSource } from 'react-native';
 import { MapManagerCommand, NativeComponent, ProviderContext, UIManagerCommand } from './decorateMapComponent';
 import { MapMarkerNativeComponentType } from './MapMarkerNativeComponent';
+import type { AppleMarkerPriority } from './specs/NativeComponentMarker';
 import { CalloutPressEvent, LatLng, MarkerDeselectEvent, MarkerDragEvent, MarkerDragStartEndEvent, MarkerPressEvent, MarkerSelectEvent, Point } from './sharedTypes';
 import { Modify } from './sharedTypesInternal';
 type AppleMarkerVisibility = 'hidden' | 'adaptive' | 'visible';
@@ -42,7 +43,7 @@ export type MapMarkerProps = ViewProps & {
      *
      * @default {x: 0.0, y: 0.0}
      * @platform iOS: Apple Maps only. For Google Maps, see the `calloutAnchor` prop
-     * @platform Android: Not supported. See see the `calloutAnchor` prop
+     * @platform Android: Not supported. see the `calloutAnchor` prop
      */
     calloutOffset?: Point;
     /**
@@ -54,7 +55,7 @@ export type MapMarkerProps = ViewProps & {
      *
      * @default {x: 0.0, y: 0.0}
      * @platform iOS: Apple Maps only. For Google Maps, see the `anchor` prop
-     * @platform Android: Not supported. See see the `anchor` prop
+     * @platform Android: Not supported. see the `anchor` prop
      */
     centerOffset?: Point;
     /**
@@ -261,6 +262,17 @@ export type MapMarkerProps = ViewProps & {
      * @platform Android: Supported
      */
     zIndex?: number;
+    /**
+     Constants that indicates the display priority for annotations.
+     @default required
+     @platform iOS: Apple Maps only.
+     @platform Android: Not supported
+  
+      Required: A constant indicating that the item is required.
+      High: A constant indicating that the item’s display priority is high.
+      Low: A constant indicating that the item’s display priority is Low.
+     */
+    displayPriority?: AppleMarkerPriority;
     /**
      * Visibility of the title text rendered beneath Marker balloon
      * @platform iOS: Apple Maps only
@@ -295,6 +307,7 @@ export declare class MapMarker extends React.Component<MapMarkerProps> {
     getUIManagerCommand: (name: string) => UIManagerCommand;
     static Animated: Animated.AnimatedComponent<typeof MapMarker>;
     private marker;
+    private fabricMarker?;
     constructor(props: MapMarkerProps);
     setNativeProps(props: Partial<NativeProps>): void;
     showCallout(): void;

package/lib/MapMarker.js

@@ -28,12 +28,15 @@ const React = __importStar(require("react"));
 const react_native_1 = require("react-native");
 const decorateMapComponent_1 = __importStar(require("./decorateMapComponent"));
 const MapMarkerNativeComponent_1 = require("./MapMarkerNativeComponent");
+const NativeComponentMarker_1 = require("./specs/NativeComponentMarker");
+const ProviderConstants_1 = require("./ProviderConstants");
 class MapMarker extends React.Component {
     getNativeComponent;
     getMapManagerCommand;
     getUIManagerCommand;
     static Animated;
     marker;
+    fabricMarker = undefined;
     constructor(props) {
         super(props);
         this.marker = React.createRef();
@@ -49,27 +52,59 @@ class MapMarker extends React.Component {
     }
     showCallout() {
         if (this.marker.current) {
-            MapMarkerNativeComponent_1.Commands.showCallout(this.marker.current);
+            if (this.fabricMarker) {
+                // @ts-ignore
+                NativeComponentMarker_1.Commands.showCallout(this.marker.current);
+            }
+            else {
+                MapMarkerNativeComponent_1.Commands.showCallout(this.marker.current);
+            }
         }
     }
     hideCallout() {
         if (this.marker.current) {
-            MapMarkerNativeComponent_1.Commands.hideCallout(this.marker.current);
+            if (this.fabricMarker) {
+                // @ts-ignore
+                NativeComponentMarker_1.Commands.hideCallout(this.marker.current);
+            }
+            else {
+                MapMarkerNativeComponent_1.Commands.hideCallout(this.marker.current);
+            }
         }
     }
     setCoordinates(coordinate) {
         if (this.marker.current) {
-            MapMarkerNativeComponent_1.Commands.setCoordinates(this.marker.current, coordinate);
+            if (this.fabricMarker) {
+                NativeComponentMarker_1.Commands.setCoordinates(
+                // @ts-ignore
+                this.marker.current, coordinate.latitude, coordinate.longitude);
+            }
+            else {
+                MapMarkerNativeComponent_1.Commands.setCoordinates(this.marker.current, coordinate);
+            }
         }
     }
     redrawCallout() {
         if (this.marker.current) {
-            MapMarkerNativeComponent_1.Commands.redrawCallout(this.marker.current);
+            if (this.fabricMarker) {
+                // @ts-ignore
+                NativeComponentMarker_1.Commands.redrawCallout(this.marker.current);
+            }
+            else {
+                MapMarkerNativeComponent_1.Commands.redrawCallout(this.marker.current);
+            }
         }
     }
     animateMarkerToCoordinate(coordinate, duration = 500) {
         if (this.marker.current) {
-            MapMarkerNativeComponent_1.Commands.animateMarkerToCoordinate(this.marker.current, coordinate, duration);
+            if (this.fabricMarker) {
+                NativeComponentMarker_1.Commands.animateToCoordinates(
+                // @ts-ignore
+                this.marker.current, coordinate.latitude, coordinate.longitude, duration);
+            }
+            else {
+                MapMarkerNativeComponent_1.Commands.animateMarkerToCoordinate(this.marker.current, coordinate, duration);
+            }
         }
     }
     redraw() {
@@ -79,10 +114,9 @@ class MapMarker extends React.Component {
     }
     render() {
         const { stopPropagation = false } = this.props;
-        let image;
-        if (this.props.image) {
-            image = react_native_1.Image.resolveAssetSource(this.props.image) || {};
-            image = image.uri || this.props.image;
+        if (this.fabricMarker === undefined) {
+            const provider = this.context;
+            this.fabricMarker = provider !== ProviderConstants_1.PROVIDER_GOOGLE && react_native_1.Platform.OS === 'ios';
         }
         let icon;
         if (this.props.icon) {
@@ -90,6 +124,16 @@ class MapMarker extends React.Component {
             icon = icon.uri;
         }
         const AIRMapMarker = this.getNativeComponent();
+        let image;
+        if (this.props.image) {
+            if (this.fabricMarker) {
+                image = this.props.image;
+            }
+            else {
+                image = react_native_1.Image.resolveAssetSource(this.props.image) || {};
+                image = image.uri || this.props.image;
+            }
+        }
         return (<AIRMapMarker {...this.props} ref={this.marker} image={image} icon={icon} style={[styles.marker, this.props.style]} onPress={event => {
                 if (stopPropagation) {
                     event.stopPropagation();

package/lib/MapMarkerNativeComponent.js

@@ -9,9 +9,7 @@ exports.Commands = (0, codegenNativeCommands_1.default)({
     supportedCommands: [
         'showCallout',
         'hideCallout',
-        'redrawCallout',
         'animateMarkerToCoordinate',
-        'redraw',
         'setCoordinates',
     ],
 });

package/lib/MapOverlay.d.ts

@@ -70,7 +70,7 @@ type OverlayPressEvent = NativeSyntheticEvent<{
      */
     action: 'overlay-press' | 'image-overlay-press';
     /**
-     * @platform iOS: Apple maps
+     * @platform iOS: Apple Maps
      */
     name?: string;
     /**