react-native-maps 1.21.0-alpha.79 → 1.21.0-alpha.80

package/android/src/main/java/com/rnmaps/maps/MapPolyline.java

@@ -4,161 +4,227 @@ import android.content.Context;
 
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.MapBuilder;
+import com.google.android.gms.maps.model.ButtCap;
 import com.google.android.gms.maps.model.Cap;
 import com.google.android.gms.maps.model.Dash;
 import com.google.android.gms.maps.model.Dot;
 import com.google.android.gms.maps.model.Gap;
+import com.google.android.gms.maps.model.JointType;
 import com.google.android.gms.maps.model.LatLng;
 import com.google.android.gms.maps.model.PatternItem;
 import com.google.android.gms.maps.model.Polyline;
 import com.google.android.gms.maps.model.PolylineOptions;
 import com.google.android.gms.maps.model.RoundCap;
+import com.google.android.gms.maps.model.SquareCap;
+import com.google.android.gms.maps.model.StrokeStyle;
+import com.google.android.gms.maps.model.StyleSpan;
 import com.google.maps.android.collections.PolylineManager;
+import com.rnmaps.fabric.event.OnPressEvent;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 public class MapPolyline extends MapFeature {
 
-  private PolylineOptions polylineOptions;
-  private Polyline polyline;
-
-  private List<LatLng> coordinates;
-  private int color;
-  private float width;
-  private boolean tappable;
-  private boolean geodesic;
-  private float zIndex;
-  private Cap lineCap = new RoundCap();
-  private ReadableArray patternValues;
-  private List<PatternItem> pattern;
-
-  public MapPolyline(Context context) {
-    super(context);
-  }
-
-  public void setCoordinates(ReadableArray coordinates) {
-    this.coordinates = new ArrayList<>(coordinates.size());
-    for (int i = 0; i < coordinates.size(); i++) {
-      ReadableMap coordinate = coordinates.getMap(i);
-      this.coordinates.add(i,
-          new LatLng(coordinate.getDouble("latitude"), coordinate.getDouble("longitude")));
-    }
-    if (polyline != null) {
-      polyline.setPoints(this.coordinates);
-    }
-  }
-
-  public void setColor(int color) {
-    this.color = color;
-    if (polyline != null) {
-      polyline.setColor(color);
-    }
-  }
-
-  public void setWidth(float width) {
-    this.width = width;
-    if (polyline != null) {
-      polyline.setWidth(width);
-    }
-  }
-
-  public void setZIndex(float zIndex) {
-    this.zIndex = zIndex;
-    if (polyline != null) {
-      polyline.setZIndex(zIndex);
-    }
-  }
-
-  public void setTappable(boolean tapabble) {
-    this.tappable = tapabble;
-    if (polyline != null) {
-      polyline.setClickable(tappable);
-    }
-  }
-
-  public void setGeodesic(boolean geodesic) {
-    this.geodesic = geodesic;
-    if (polyline != null) {
-      polyline.setGeodesic(geodesic);
-    }
-  }
-
-  public void setLineCap(Cap cap) {
-    this.lineCap = cap;
-    if (polyline != null) {
-      polyline.setStartCap(cap);
-      polyline.setEndCap(cap);
-    }
-    this.applyPattern();
-  }
-
-  public void setLineDashPattern(ReadableArray patternValues) {
-    this.patternValues = patternValues;
-    this.applyPattern();
-  }
-
-  private void applyPattern() {
-    if(patternValues == null) {
-      return;
-    }
-    this.pattern = new ArrayList<>(patternValues.size());
-    for (int i = 0; i < patternValues.size(); i++) {
-      float patternValue = (float) patternValues.getDouble(i);
-      boolean isGap = i % 2 != 0;
-      if(isGap) {
-        this.pattern.add(new Gap(patternValue));
-      }else {
-        PatternItem patternItem;
-        boolean isLineCapRound = this.lineCap instanceof RoundCap;
-        if(isLineCapRound) {
-          patternItem = new Dot();
-        }else {
-          patternItem = new Dash(patternValue);
-        }
-        this.pattern.add(patternItem);
-      }
-    }
-    if(polyline != null) {
-      polyline.setPattern(this.pattern);
-    }
-  }
-
-  public PolylineOptions getPolylineOptions() {
-    if (polylineOptions == null) {
-      polylineOptions = createPolylineOptions();
-    }
-    return polylineOptions;
-  }
-
-  private PolylineOptions createPolylineOptions() {
-    PolylineOptions options = new PolylineOptions();
-    options.addAll(coordinates);
-    options.color(color);
-    options.width(width);
-    options.geodesic(geodesic);
-    options.zIndex(zIndex);
-    options.startCap(lineCap);
-    options.endCap(lineCap);
-    options.pattern(this.pattern);
-    return options;
-  }
-
-  @Override
-  public Object getFeature() {
-    return polyline;
-  }
-
-  @Override
-  public void addToMap(Object collection) {
-    PolylineManager.Collection polylineCollection = (PolylineManager.Collection) collection;
-    polyline = polylineCollection.addPolyline(getPolylineOptions());
-    polyline.setClickable(this.tappable);
-  }
-
-  @Override
-  public void removeFromMap(Object collection) {
-    PolylineManager.Collection polylineCollection = (PolylineManager.Collection) collection;
-    polylineCollection.remove(polyline);
-  }
+    private PolylineOptions polylineOptions;
+    private Polyline polyline;
+
+    private List<LatLng> coordinates;
+    private int color;
+    private float width;
+    private boolean tappable;
+    private boolean geodesic;
+    private float zIndex;
+    private Cap lineCap = new RoundCap();
+    private ReadableArray patternValues;
+    private List<PatternItem> pattern;
+
+    public MapPolyline(Context context) {
+        super(context);
+    }
+
+    public void setCoordinates(ReadableArray coordinates) {
+        this.coordinates = new ArrayList<>(coordinates.size());
+        for (int i = 0; i < coordinates.size(); i++) {
+            ReadableMap coordinate = coordinates.getMap(i);
+            this.coordinates.add(i,
+                    new LatLng(coordinate.getDouble("latitude"), coordinate.getDouble("longitude")));
+        }
+        if (polyline != null) {
+            polyline.setPoints(this.coordinates);
+        }
+    }
+
+    public void setColor(int color) {
+        this.color = color;
+        if (polyline != null) {
+            polyline.setColor(color);
+        }
+    }
+
+    public void setStrokeColors(ReadableArray strokeColors) {
+        List<StyleSpan> spans = new ArrayList<>();
+        for (int i = 0; i < strokeColors.size(); i++) {
+            StrokeStyle stroke;
+
+            if (i == 0) {
+                stroke = StrokeStyle.colorBuilder(strokeColors.getInt(i)).build();
+            } else {
+                stroke = StrokeStyle.gradientBuilder(strokeColors.getInt(i - 1), strokeColors.getInt(i)).build();
+            }
+            spans.add(new StyleSpan(stroke));
+        }
+
+        polyline.setSpans(spans);
+    }
+
+    public void setWidth(float width) {
+        this.width = width;
+        if (polyline != null) {
+            polyline.setWidth(width);
+        }
+    }
+
+    public void setZIndex(float zIndex) {
+        this.zIndex = zIndex;
+        if (polyline != null) {
+            polyline.setZIndex(zIndex);
+        }
+    }
+
+    public void setTappable(boolean tapabble) {
+        this.tappable = tapabble;
+        if (polyline != null) {
+            polyline.setClickable(tappable);
+        }
+    }
+
+    public void setGeodesic(boolean geodesic) {
+        this.geodesic = geodesic;
+        if (polyline != null) {
+            polyline.setGeodesic(geodesic);
+        }
+    }
+
+    public void setLineCap(Cap cap) {
+        this.lineCap = cap;
+        if (polyline != null) {
+            polyline.setStartCap(cap);
+            polyline.setEndCap(cap);
+        }
+        this.applyPattern();
+    }
+
+    public void setLineDashPattern(ReadableArray patternValues) {
+        this.patternValues = patternValues;
+        this.applyPattern();
+    }
+
+    private void applyPattern() {
+        if (patternValues == null) {
+            return;
+        }
+        this.pattern = new ArrayList<>(patternValues.size());
+        for (int i = 0; i < patternValues.size(); i++) {
+            float patternValue = (float) patternValues.getDouble(i);
+            boolean isGap = i % 2 != 0;
+            if (isGap) {
+                this.pattern.add(new Gap(patternValue));
+            } else {
+                PatternItem patternItem;
+                boolean isLineCapRound = this.lineCap instanceof RoundCap;
+                if (isLineCapRound) {
+                    patternItem = new Dot();
+                } else {
+                    patternItem = new Dash(patternValue);
+                }
+                this.pattern.add(patternItem);
+            }
+        }
+        if (polyline != null) {
+            polyline.setPattern(this.pattern);
+        }
+    }
+
+    public PolylineOptions getPolylineOptions() {
+        if (polylineOptions == null) {
+            polylineOptions = createPolylineOptions();
+        }
+        return polylineOptions;
+    }
+
+    private PolylineOptions createPolylineOptions() {
+        PolylineOptions options = new PolylineOptions();
+        options.addAll(coordinates);
+        options.color(color);
+        options.width(width);
+        options.geodesic(geodesic);
+        options.zIndex(zIndex);
+        options.startCap(lineCap);
+        options.endCap(lineCap);
+        options.pattern(this.pattern);
+        return options;
+    }
+
+    @Override
+    public Object getFeature() {
+        return polyline;
+    }
+
+    @Override
+    public void addToMap(Object collection) {
+        PolylineManager.Collection polylineCollection = (PolylineManager.Collection) collection;
+        polyline = polylineCollection.addPolyline(getPolylineOptions());
+        polyline.setClickable(this.tappable);
+    }
+
+    @Override
+    public void removeFromMap(Object collection) {
+        PolylineManager.Collection polylineCollection = (PolylineManager.Collection) collection;
+        polylineCollection.remove(polyline);
+    }
+
+    public void setLineCap(String lineCap) {
+        Cap cap;
+        switch (lineCap) {
+            case "round":
+                cap = new RoundCap();
+                break;
+            case "square":
+                cap = new SquareCap();
+                break;
+            case "butt":
+            default:
+                cap = new ButtCap();
+                break;
+        }
+        setLineCap(cap);
+    }
+
+    public static Map<String, Object> getExportedCustomBubblingEventTypeConstants() {
+        MapBuilder.Builder<String, Object> builder = MapBuilder.builder();
+        builder.put(OnPressEvent.EVENT_NAME, MapBuilder.of("registrationName", OnPressEvent.EVENT_NAME));
+        return builder.build();
+    }
+
+    public void setLineJoin(String lineJoin) {
+        int type;
+        switch (lineJoin) {
+            case "round":
+                type = JointType.ROUND;
+                break;
+            case "bevel":
+                type = JointType.BEVEL;
+                break;
+            case "miter":
+            default:
+                type = JointType.DEFAULT;
+                break;
+        }
+        if (polyline != null) {
+            polyline.setJointType(type);
+        }
+    }
 }

package/android/src/main/java/com/rnmaps/maps/MapPolylineManager.java

@@ -74,22 +74,7 @@ public class MapPolylineManager extends ViewGroupManager<MapPolyline> {
 
   @ReactProp(name = "lineCap")
   public void setlineCap(MapPolyline view, String lineCap) {
-    Cap cap = null;
-    switch (lineCap) {
-      case "butt":
-        cap = new ButtCap();
-        break;
-      case "round":
-        cap = new RoundCap();
-        break;
-      case "square":
-        cap = new SquareCap();
-        break;
-      default:
-        cap = new RoundCap();
-        break;
-    }
-    view.setLineCap(cap);
+      view.setLineCap(lineCap);
   }
 
   @ReactProp(name = "lineDashPattern")

package/android/src/main/java/com/rnmaps/maps/MapView.java

@@ -654,6 +654,7 @@ public void onCreate(LifecycleOwner owner) {
         builder.put(OnLongPressEvent.EVENT_NAME, MapBuilder.of("registrationName", OnLongPressEvent.EVENT_NAME));
         builder.put(OnRegionChangeStartEvent.EVENT_NAME, MapBuilder.of("registrationName", OnRegionChangeStartEvent.EVENT_NAME));
         builder.put(OnDoublePressEvent.EVENT_NAME, MapBuilder.of("registrationName", OnDoublePressEvent.EVENT_NAME));
+        builder.put(OnPanDragEvent.EVENT_NAME, MapBuilder.of("registrationName", OnPanDragEvent.EVENT_NAME));
         return builder.build();
     }
 
@@ -1612,8 +1613,7 @@ public void onCreate(LifecycleOwner owner) {
         Point point = new Point((int) ev.getX(), (int) ev.getY());
         LatLng coords = this.map.getProjection().fromScreenLocation(point);
         WritableMap event = makeClickEventData(coords);
-        // todo: use Fabric events
-        // manager.pushEvent(context, this, "onPanDrag", event);
+        dispatchEvent(event, OnPanDragEvent::new);
     }
 
     public void onDoublePress(MotionEvent ev) {
@@ -1621,7 +1621,6 @@ public void onCreate(LifecycleOwner owner) {
         Point point = new Point((int) ev.getX(), (int) ev.getY());
         LatLng coords = this.map.getProjection().fromScreenLocation(point);
         WritableMap event = makeClickEventData(coords);
-        // todo: use Fabric events
         dispatchEvent(event, OnDoublePressEvent::new);
 
     }

package/ios/generated/RNMapsSpecs/ComponentDescriptors.cpp

@@ -21,6 +21,7 @@ registry->add(concreteComponentDescriptorProvider<RNMapsGoogleMapViewComponentDe
 registry->add(concreteComponentDescriptorProvider<RNMapsGooglePolygonComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsMapViewComponentDescriptor>());
 registry->add(concreteComponentDescriptorProvider<RNMapsMarkerComponentDescriptor>());
+registry->add(concreteComponentDescriptorProvider<RNMapsPolylineComponentDescriptor>());
 }
 
 } // namespace facebook::react

package/ios/generated/RNMapsSpecs/ComponentDescriptors.h

@@ -21,6 +21,7 @@ using RNMapsGoogleMapViewComponentDescriptor = ConcreteComponentDescriptor<RNMap
 using RNMapsGooglePolygonComponentDescriptor = ConcreteComponentDescriptor<RNMapsGooglePolygonShadowNode>;
 using RNMapsMapViewComponentDescriptor = ConcreteComponentDescriptor<RNMapsMapViewShadowNode>;
 using RNMapsMarkerComponentDescriptor = ConcreteComponentDescriptor<RNMapsMarkerShadowNode>;
+using RNMapsPolylineComponentDescriptor = ConcreteComponentDescriptor<RNMapsPolylineShadowNode>;
 
 void RNMapsSpecs_registerComponentDescriptorsFromCodegen(
   std::shared_ptr<const ComponentDescriptorProviderRegistry> registry);

package/ios/generated/RNMapsSpecs/EventEmitters.cpp

@@ -915,4 +915,26 @@ $payload.setProperty(runtime, "id", $event.id);
   });
 }
 
+
+void RNMapsPolylineEventEmitter::onPress(OnPress $event) const {
+  dispatchEvent("press", [$event=std::move($event)](jsi::Runtime &runtime) {
+    auto $payload = jsi::Object(runtime);
+    $payload.setProperty(runtime, "action", $event.action);
+$payload.setProperty(runtime, "id", $event.id);
+{
+  auto coordinate = jsi::Object(runtime);
+  coordinate.setProperty(runtime, "latitude", $event.coordinate.latitude);
+  coordinate.setProperty(runtime, "longitude", $event.coordinate.longitude);
+  $payload.setProperty(runtime, "coordinate", coordinate);
+}
+{
+  auto position = jsi::Object(runtime);
+  position.setProperty(runtime, "x", $event.position.x);
+  position.setProperty(runtime, "y", $event.position.y);
+  $payload.setProperty(runtime, "position", position);
+}
+    return $payload;
+  });
+}
+
 } // namespace facebook::react

package/ios/generated/RNMapsSpecs/EventEmitters.h

@@ -784,4 +784,26 @@ class RNMapsMarkerEventEmitter : public ViewEventEmitter {
 
   void onSelect(OnSelect value) const;
 };
+class RNMapsPolylineEventEmitter : public ViewEventEmitter {
+ public:
+  using ViewEventEmitter::ViewEventEmitter;
+
+  struct OnPressCoordinate {
+      double latitude;
+    double longitude;
+    };
+
+  struct OnPressPosition {
+      double x;
+    double y;
+    };
+
+  struct OnPress {
+      std::string action;
+    std::string id;
+    OnPressCoordinate coordinate;
+    OnPressPosition position;
+    };
+  void onPress(OnPress value) const;
+};
 } // namespace facebook::react

package/ios/generated/RNMapsSpecs/Props.cpp

@@ -151,5 +151,20 @@ RNMapsMarkerProps::RNMapsMarkerProps(
     subtitleVisibility(convertRawProp(context, rawProps, "subtitleVisibility", sourceProps.subtitleVisibility, {RNMapsMarkerSubtitleVisibility::Adaptive})),
     useLegacyPinView(convertRawProp(context, rawProps, "useLegacyPinView", sourceProps.useLegacyPinView, {false}))
       {}
+RNMapsPolylineProps::RNMapsPolylineProps(
+    const PropsParserContext &context,
+    const RNMapsPolylineProps &sourceProps,
+    const RawProps &rawProps): ViewProps(context, sourceProps, rawProps),
+
+    coordinates(convertRawProp(context, rawProps, "coordinates", sourceProps.coordinates, {})),
+    geodesic(convertRawProp(context, rawProps, "geodesic", sourceProps.geodesic, {false})),
+    lineCap(convertRawProp(context, rawProps, "lineCap", sourceProps.lineCap, {RNMapsPolylineLineCap::Butt})),
+    lineDashPattern(convertRawProp(context, rawProps, "lineDashPattern", sourceProps.lineDashPattern, {})),
+    lineJoin(convertRawProp(context, rawProps, "lineJoin", sourceProps.lineJoin, {RNMapsPolylineLineJoin::Miter})),
+    strokeColor(convertRawProp(context, rawProps, "strokeColor", sourceProps.strokeColor, {})),
+    strokeColors(convertRawProp(context, rawProps, "strokeColors", sourceProps.strokeColors, {})),
+    strokeWidth(convertRawProp(context, rawProps, "strokeWidth", sourceProps.strokeWidth, {0.0})),
+    tappable(convertRawProp(context, rawProps, "tappable", sourceProps.tappable, {false}))
+      {}
 
 } // namespace facebook::react

package/ios/generated/RNMapsSpecs/Props.h

@@ -1056,4 +1056,87 @@ class RNMapsMarkerProps final : public ViewProps {
   bool useLegacyPinView{false};
 };
 
+enum class RNMapsPolylineLineCap { Butt, Round, Square };
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, RNMapsPolylineLineCap &result) {
+  auto string = (std::string)value;
+  if (string == "butt") { result = RNMapsPolylineLineCap::Butt; return; }
+  if (string == "round") { result = RNMapsPolylineLineCap::Round; return; }
+  if (string == "square") { result = RNMapsPolylineLineCap::Square; return; }
+  abort();
+}
+
+static inline std::string toString(const RNMapsPolylineLineCap &value) {
+  switch (value) {
+    case RNMapsPolylineLineCap::Butt: return "butt";
+    case RNMapsPolylineLineCap::Round: return "round";
+    case RNMapsPolylineLineCap::Square: return "square";
+  }
+}
+enum class RNMapsPolylineLineJoin { Miter, Round, Bevel };
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, RNMapsPolylineLineJoin &result) {
+  auto string = (std::string)value;
+  if (string == "miter") { result = RNMapsPolylineLineJoin::Miter; return; }
+  if (string == "round") { result = RNMapsPolylineLineJoin::Round; return; }
+  if (string == "bevel") { result = RNMapsPolylineLineJoin::Bevel; return; }
+  abort();
+}
+
+static inline std::string toString(const RNMapsPolylineLineJoin &value) {
+  switch (value) {
+    case RNMapsPolylineLineJoin::Miter: return "miter";
+    case RNMapsPolylineLineJoin::Round: return "round";
+    case RNMapsPolylineLineJoin::Bevel: return "bevel";
+  }
+}
+struct RNMapsPolylineCoordinatesStruct {
+  double latitude{0.0};
+  double longitude{0.0};
+};
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, RNMapsPolylineCoordinatesStruct &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 RNMapsPolylineCoordinatesStruct &value) {
+  return "[Object RNMapsPolylineCoordinatesStruct]";
+}
+
+static inline void fromRawValue(const PropsParserContext& context, const RawValue &value, std::vector<RNMapsPolylineCoordinatesStruct> &result) {
+  auto items = (std::vector<RawValue>)value;
+  for (const auto &item : items) {
+    RNMapsPolylineCoordinatesStruct newItem;
+    fromRawValue(context, item, newItem);
+    result.emplace_back(newItem);
+  }
+}
+
+class RNMapsPolylineProps final : public ViewProps {
+ public:
+  RNMapsPolylineProps() = default;
+  RNMapsPolylineProps(const PropsParserContext& context, const RNMapsPolylineProps &sourceProps, const RawProps &rawProps);
+
+#pragma mark - Props
+
+  std::vector<RNMapsPolylineCoordinatesStruct> coordinates{};
+  bool geodesic{false};
+  RNMapsPolylineLineCap lineCap{RNMapsPolylineLineCap::Butt};
+  std::vector<double> lineDashPattern{};
+  RNMapsPolylineLineJoin lineJoin{RNMapsPolylineLineJoin::Miter};
+  SharedColor strokeColor{};
+  std::vector<SharedColor> strokeColors{};
+  Float strokeWidth{0.0};
+  bool tappable{false};
+};
+
 } // namespace facebook::react

package/ios/generated/RNMapsSpecs/RCTComponentViewHelpers.h

@@ -588,4 +588,8 @@ if ([commandName isEqualToString:@"redraw"]) {
 #endif
 }
 
+@protocol RCTRNMapsPolylineViewProtocol <NSObject>
+
+@end
+
 NS_ASSUME_NONNULL_END

package/ios/generated/RNMapsSpecs/ShadowNodes.cpp

@@ -17,5 +17,6 @@ extern const char RNMapsGoogleMapViewComponentName[] = "RNMapsGoogleMapView";
 extern const char RNMapsGooglePolygonComponentName[] = "RNMapsGooglePolygon";
 extern const char RNMapsMapViewComponentName[] = "RNMapsMapView";
 extern const char RNMapsMarkerComponentName[] = "RNMapsMarker";
+extern const char RNMapsPolylineComponentName[] = "RNMapsPolyline";
 
 } // namespace facebook::react

package/ios/generated/RNMapsSpecs/ShadowNodes.h

@@ -73,4 +73,15 @@ using RNMapsMarkerShadowNode = ConcreteViewShadowNode<
     RNMapsMarkerEventEmitter,
     RNMapsMarkerState>;
 
+JSI_EXPORT extern const char RNMapsPolylineComponentName[];
+
+/*
+ * `ShadowNode` for <RNMapsPolyline> component.
+ */
+using RNMapsPolylineShadowNode = ConcreteViewShadowNode<
+    RNMapsPolylineComponentName,
+    RNMapsPolylineProps,
+    RNMapsPolylineEventEmitter,
+    RNMapsPolylineState>;
+
 } // namespace facebook::react

package/ios/generated/RNMapsSpecs/States.h

@@ -74,4 +74,16 @@ public:
 #endif
 };
 
+class RNMapsPolylineState {
+public:
+  RNMapsPolylineState() = default;
+
+#ifdef ANDROID
+  RNMapsPolylineState(RNMapsPolylineState const &previousState, folly::dynamic data){};
+  folly::dynamic getDynamic() const {
+    return {};
+  };
+#endif
+};
+
 } // namespace facebook::react

package/lib/MapCallout.js

@@ -34,7 +34,6 @@ class MapCallout extends React.Component {
     render() {
         const { tooltip = false, alphaHitTest = false } = this.props;
         const AIRMapCallout = this.getNativeComponent();
-        console.log('renderCallout ' + AIRMapCallout);
         return (<AIRMapCallout {...this.props} tooltip={tooltip} alphaHitTest={alphaHitTest} style={[styles.callout, this.props.style]}/>);
     }
 }