react-native-maps 1.21.0-alpha.55 → 1.21.0-alpha.56

package/android/src/main/java/com/rnmaps/fabric/MapViewManager.java

@@ -1,6 +1,8 @@
 package com.rnmaps.fabric;
 
 
+import static com.rnmaps.maps.MapManager.MY_LOCATION_PRIORITY;
+
 import android.util.Log;
 import android.view.View;
 
@@ -9,9 +11,10 @@ import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.LayoutShadowNode;
+import com.facebook.react.uimanager.ReactStylesDiffMap;
+import com.facebook.react.uimanager.StateWrapper;
 import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.ViewGroupManager;
 import com.facebook.react.uimanager.ViewManagerDelegate;
@@ -24,26 +27,23 @@ import com.google.android.gms.maps.model.CameraPosition;
 import com.rnmaps.maps.MapView;
 import com.rnmaps.maps.SizeReportingShadowNode;
 
-import java.util.List;
 import java.util.Map;
 
 @ReactModule(name = MapViewManager.REACT_CLASS)
-public class MapViewManager extends ViewGroupManager<MapViewWrapper> implements RNMapsMapViewManagerInterface<MapViewWrapper> {
+public class MapViewManager extends ViewGroupManager<MapView> implements RNMapsMapViewManagerInterface<MapView> {
 
-    private GoogleMapOptions options;
-    private boolean rendererInitialized = false;
-    private final RNMapsMapViewManagerDelegate<MapViewWrapper, MapViewManager> delegate =
+    private static boolean rendererInitialized = false;
+    private final RNMapsMapViewManagerDelegate<MapView, MapViewManager> delegate =
             new RNMapsMapViewManagerDelegate<>(this);
 
 
     public MapViewManager(ReactApplicationContext context) {
         super(context);
-        options = new GoogleMapOptions();
     }
 
 
     @Override
-    public ViewManagerDelegate<MapViewWrapper> getDelegate() {
+    public ViewManagerDelegate<MapView> getDelegate() {
         return delegate;
     }
 
@@ -53,9 +53,89 @@ public class MapViewManager extends ViewGroupManager<MapViewWrapper> implements
     }
 
     @Override
-    public MapViewWrapper createViewInstance(ThemedReactContext context) {
-        Log.e(MapViewManager.class.getName(), "createViewInstance");
-        return new MapViewWrapper(context);
+    public MapView createViewInstance(ThemedReactContext context) {
+        return new MapView(context, new GoogleMapOptions());
+    }
+
+    @Override
+    protected void setupViewRecycling() {
+        // override parent to block recycling / allow reliable GoogleMapsOptions passing
+    }
+
+    @Override
+    protected MapView createViewInstance(int reactTag, @NonNull ThemedReactContext reactContext, @Nullable ReactStylesDiffMap initialProps, @Nullable StateWrapper stateWrapper) {
+        MapView view = null;
+        GoogleMapOptions options = new GoogleMapOptions();
+        if (initialProps != null) {
+            setGoogleRenderer(null, initialProps.getString("googleRenderer"));
+            if (initialProps.hasKey("liteMode")) {
+                options.liteMode(initialProps.getBoolean("liteMode", false));
+            }
+            if (initialProps.hasKey("googleMapId")) {
+                String googleMapId = initialProps.getString("googleMapId");
+                options.mapId(googleMapId);
+            }
+            if (initialProps.getMap("initialCamera") != null) {
+                ReadableMap initialCamera = initialProps.getMap("initialCamera");
+                CameraPosition camera = MapView.cameraPositionFromMap(initialCamera);
+                if (camera != null) {
+                    options.camera(camera);
+                }
+            }
+            if (initialProps.hasKey("mapType")) {
+                if (initialProps.getString("mapType") != null) {
+                    options.mapType(mapTypeFromStrValue(initialProps.getString("mapType")));
+                }
+            }
+            if (initialProps.hasKey("minZoom")) {
+                if (initialProps.getInt("minZoom", 0) != 0) {
+                    options.minZoomPreference(initialProps.getInt("minZoom", 0));
+                }
+            }
+            if (initialProps.hasKey("maxZoom")) {
+                if (initialProps.getInt("maxZoom", 0) != 0) {
+                    options.maxZoomPreference(initialProps.getInt("maxZoom", 0));
+                }
+            }
+            if (initialProps.hasKey("pitchEnabled")) {
+                options.tiltGesturesEnabled(initialProps.getBoolean("pitchEnabled", true));
+            }
+            if (initialProps.hasKey("rotateEnabled")) {
+                options.rotateGesturesEnabled(initialProps.getBoolean("rotateEnabled", true));
+            }
+            if (initialProps.hasKey("scrollDuringRotateOrZoomEnabled")) {
+                options.scrollGesturesEnabledDuringRotateOrZoom(initialProps.getBoolean("scrollDuringRotateOrZoomEnabled", true));
+            }
+            if (initialProps.hasKey("scrollEnabled")) {
+                options.scrollGesturesEnabled(initialProps.getBoolean("scrollEnabled", true));
+            }
+            if (initialProps.hasKey("showsCompass")) {
+                options.compassEnabled(initialProps.getBoolean("showsCompass", true));
+            }
+            if (initialProps.hasKey("toolbarEnabled")) {
+                options.mapToolbarEnabled(initialProps.getBoolean("toolbarEnabled", true));
+            }
+            if (initialProps.hasKey("zoomControlEnabled")) {
+                options.zoomControlsEnabled(initialProps.getBoolean("zoomControlEnabled", true));
+            }
+            if (initialProps.hasKey("zoomEnabled")) {
+                options.zoomGesturesEnabled(initialProps.getBoolean("zoomEnabled", true));
+            }
+        }
+
+        view = new MapView(reactContext, options);
+        view.setId(reactTag);
+        this.addEventEmitters(reactContext, view);
+        if (initialProps != null) {
+            this.updateProperties(view, initialProps);
+        }
+        if (stateWrapper != null) {
+            Object extraData = this.updateState(view, initialProps, stateWrapper);
+            if (extraData != null) {
+                this.updateExtraData(view, extraData);
+            }
+        }
+        return view;
     }
 
 
@@ -82,76 +162,70 @@ public class MapViewManager extends ViewGroupManager<MapViewWrapper> implements
     }
 
     @Override
-    public void setCacheEnabled(MapViewWrapper view, boolean value) {
+    public void setCacheEnabled(MapView view, boolean value) {
         view.setCacheEnabled(value);
     }
 
     @Override
-    public void setCamera(MapViewWrapper view, @Nullable ReadableMap value) {
+    public void setCamera(MapView view, @Nullable ReadableMap value) {
         view.setCamera(value);
     }
 
     @Override
-    public void setCompassOffset(MapViewWrapper view, @Nullable ReadableMap value) {
+    public void setCompassOffset(MapView view, @Nullable ReadableMap value) {
         // not supported
     }
 
     @Override
-    public void setFollowsUserLocation(MapViewWrapper view, boolean value) {
+    public void setFollowsUserLocation(MapView view, boolean value) {
         // not supported
     }
 
     @Override
-    public void setPoiClickEnabled(MapViewWrapper view, boolean value) {
+    public void setPoiClickEnabled(MapView view, boolean value) {
         view.setPoiClickEnabled(value);
     }
 
     @Override
-    public void setInitialCamera(MapViewWrapper view, @Nullable ReadableMap value) {
+    public void setInitialCamera(MapView view, @Nullable ReadableMap value) {
         CameraPosition camera = MapView.cameraPositionFromMap(value);
-        if (camera != null){
-            options.camera(camera);
+        if (camera != null) {
             view.setInitialCameraSet(true);
         }
     }
 
-    @Override
-    protected MapViewWrapper recycleView(@NonNull ThemedReactContext var1, @NonNull MapViewWrapper wrapper){
-        wrapper.prepareToRecycleView();
-        return wrapper;
-    }
-
 
     @Override
-    public void setInitialRegion(MapViewWrapper view, @Nullable ReadableMap value) {
+    public void setInitialRegion(MapView view, @Nullable ReadableMap value) {
         view.setInitialRegion(value);
     }
 
     @Override
-    public void setKmlSrc(MapViewWrapper view, @Nullable String value) {
+    public void setKmlSrc(MapView view, @Nullable String value) {
         view.setKmlSrc(value);
     }
 
     @Override
-    public void setLegalLabelInsets(MapViewWrapper view, @Nullable ReadableMap value) {
+    public void setLegalLabelInsets(MapView view, @Nullable ReadableMap value) {
         // not supported
     }
 
     @Override
-    public void setLiteMode(MapViewWrapper view, boolean value) {
-        options.liteMode(value);
+    public void setLiteMode(MapView view, boolean value) {
+
     }
 
     @Override
-    public void setGoogleMapId(MapViewWrapper view, @Nullable String value) {
-        options.mapId(value);
+    public void setGoogleMapId(MapView view, @Nullable String value) {
+        // do nothing (initialProp)
+
     }
 
     @Override
-    public void setGoogleRenderer(MapViewWrapper view, @Nullable String value) {
+    public void setGoogleRenderer(MapView view, @Nullable String value) {
         if (!rendererInitialized) {
-            MapsInitializer.Renderer renderer =  MapsInitializer.Renderer.LATEST;
-            if ("LEGACY".equals(value)){
+            MapsInitializer.Renderer renderer = MapsInitializer.Renderer.LATEST;
+            if ("LEGACY".equals(value)) {
                 renderer = MapsInitializer.Renderer.LEGACY;
             }
             MapsInitializer.initialize(getReactApplicationContext(), renderer, r -> Log.d("AirMapRenderer", "Init with renderer: " + r));
@@ -161,43 +235,61 @@ public class MapViewManager extends ViewGroupManager<MapViewWrapper> implements
     }
 
     @Override
-    public void setLoadingBackgroundColor(MapViewWrapper view, @Nullable Integer value) {
+    public void setLoadingBackgroundColor(MapView view, @Nullable Integer value) {
         view.setLoadingBackgroundColor(value);
     }
 
     @Override
-    public void setLoadingEnabled(MapViewWrapper view, boolean value) {
+    public void setLoadingEnabled(MapView view, boolean value) {
         view.setLoadingEnabled(value);
     }
 
     @Override
-    public void setLoadingIndicatorColor(MapViewWrapper view, @Nullable Integer value) {
+    public void setLoadingIndicatorColor(MapView view, @Nullable Integer value) {
         view.setLoadingIndicatorColor(value);
     }
 
     @Override
-    public void setMapPadding(MapViewWrapper view, @Nullable ReadableMap padding) {
-        view.setMapPadding(padding);
-    }
+    public void setMapPadding(MapView view, @Nullable ReadableMap padding) {
+        int left = 0;
+        int top = 0;
+        int right = 0;
+        int bottom = 0;
+        double density = (double) view.getResources().getDisplayMetrics().density;
 
-    @Override
-    public void addView(MapViewWrapper parent, View child, int index) {
-        parent.getMapView().addFeature(child, index);
-        Log.e("MapViewManager", "addView  " + child.getId() + " at index: " + index);
+        if (padding != null) {
+            if (padding.hasKey("left")) {
+                left = (int) (padding.getDouble("left") * density);
+            }
 
-    }
-    @Override
-    public void addViews(MapViewWrapper parent, List<View> views){
-        for (View view : views){
-            parent.getMapView().addView(view);
-            Log.e("MapViewManager", "addViews  " + view.getId());
+            if (padding.hasKey("top")) {
+                top = (int) (padding.getDouble("top") * density);
+            }
+
+            if (padding.hasKey("right")) {
+                right = (int) (padding.getDouble("right") * density);
+            }
+
+            if (padding.hasKey("bottom")) {
+                bottom = (int) (padding.getDouble("bottom") * density);
+            }
         }
 
+        view.applyBaseMapPadding(left, top, right, bottom);
+        view.map.setPadding(left, top, right, bottom);
     }
 
+    @Override
+    public void addView(MapView parent, View child, int index) {
+        parent.addFeature(child, index);
+    }
 
     @Override
-    public void setMapType(MapViewWrapper view, @Nullable String value) {
+    public void setMapType(MapView view, @Nullable String value) {
+        view.setMapType(mapTypeFromStrValue(value));
+    }
+
+    private static int mapTypeFromStrValue(String value) {
         int mapType;
         //hybrid | none | satellite | standard | terrain
         if ("hybrid".equals(value)) {
@@ -211,267 +303,199 @@ public class MapViewManager extends ViewGroupManager<MapViewWrapper> implements
         } else if ("terrain".equals(value)) {
             mapType = GoogleMap.MAP_TYPE_TERRAIN;
         } else {
-          mapType = GoogleMap.MAP_TYPE_NORMAL;
-        }
-        options.mapType(mapType);
-        if (view.getMapView() != null){
-            view.getMapView().setMapType(mapType);
+            mapType = GoogleMap.MAP_TYPE_NORMAL;
         }
+        return mapType;
     }
 
     @Override
-    public void setMaxDelta(MapViewWrapper view, double value) {
+    public void setMaxDelta(MapView view, double value) {
         // not supported
     }
 
     @Override
-    public void setMaxZoom(MapViewWrapper view, float value) {
-        options.maxZoomPreference(value);
-        if (view.getMapView() != null) {
-            view.getMapView().setMaxZoomLevel(value);
-        }
+    public void setMaxZoom(MapView view, float value) {
+        view.setMaxZoomLevel(value);
     }
 
     @Override
-    public void setMinDelta(MapViewWrapper view, double value) {
+    public void setMinDelta(MapView view, double value) {
         // not supported
     }
 
     @Override
-    public void setMinZoom(MapViewWrapper view, float value) {
-        options.minZoomPreference(value);
-        if (view.getMapView() != null) {
-            view.getMapView().setMinZoomLevel(value);
-        }
+    public void setMinZoom(MapView view, float value) {
+        view.setMinZoomLevel(value);
     }
 
     @Override
-    public void setMoveOnMarkerPress(MapViewWrapper view, boolean value) {
-            view.setMoveOnMarkerPress(value);
+    public void setMoveOnMarkerPress(MapView view, boolean value) {
+        view.setMoveOnMarkerPress(value);
     }
 
     @Override
-    public void setHandlePanDrag(MapViewWrapper view, boolean value) {
+    public void setHandlePanDrag(MapView view, boolean value) {
         view.setHandlePanDrag(value);
     }
 
     @Override
-    public void setPaddingAdjustmentBehavior(MapViewWrapper view, @Nullable String value) {
+    public void setPaddingAdjustmentBehavior(MapView view, @Nullable String value) {
         // not supported
     }
 
     @Override
-    public void setPitchEnabled(MapViewWrapper view, boolean value) {
-        options.tiltGesturesEnabled(value);
-        if (view.getMapView() != null) {
-            view.getMapView().setPitchEnabled(value);
-        }
+    public void setPitchEnabled(MapView view, boolean value) {
+        view.setPitchEnabled(value);
     }
 
     @Override
-    public void setRegion(MapViewWrapper view, @Nullable ReadableMap value) {
+    public void setRegion(MapView view, @Nullable ReadableMap value) {
         view.setRegion(value);
     }
 
     @Override
-    public void setRotateEnabled(MapViewWrapper view, boolean value) {
-        options.rotateGesturesEnabled(value);
-        if (view.getMapView() != null) {
-            view.getMapView().setRotateEnabled(value);
-        }
+    public void setRotateEnabled(MapView view, boolean value) {
+        view.setRotateEnabled(value);
     }
 
     @Override
-    public void setScrollDuringRotateOrZoomEnabled(MapViewWrapper view, boolean value) {
-        options.scrollGesturesEnabledDuringRotateOrZoom(value);
-        if (view.getMapView() != null) {
-            view.getMapView().setScrollDuringRotateOrZoomEnabled(value);
-        }
+    public void setScrollDuringRotateOrZoomEnabled(MapView view, boolean value) {
+        view.setScrollDuringRotateOrZoomEnabled(value);
     }
 
     @Override
-    public void setScrollEnabled(MapViewWrapper view, boolean value) {
-        options.scrollGesturesEnabled(value);
-        if (view.getMapView() != null) {
-            view.getMapView().setScrollEnabled(value);
-        }
+    public void setScrollEnabled(MapView view, boolean value) {
+        view.setScrollEnabled(value);
     }
 
     @Override
-    public void setShowsBuildings(MapViewWrapper view, boolean value) {
-        view.setShowsBuildings(value);
+    public void setShowsBuildings(MapView view, boolean value) {
+        view.setShowBuildings(value);
     }
 
     @Override
-    public void setShowsCompass(MapViewWrapper view, boolean value) {
-        options.compassEnabled(value);
+    public void setShowsCompass(MapView view, boolean value) {
         view.setShowsCompass(value);
     }
 
     @Override
-    public void setShowsIndoorLevelPicker(MapViewWrapper view, boolean value) {
+    public void setShowsIndoorLevelPicker(MapView view, boolean value) {
         view.setShowsIndoorLevelPicker(value);
     }
 
     @Override
-    public void setShowsIndoors(MapViewWrapper view, boolean value) {
-        view.setShowsIndoors(value);
+    public void setShowsIndoors(MapView view, boolean value) {
+        view.setShowIndoors(value);
     }
 
     @Override
-    public void setShowsMyLocationButton(MapViewWrapper view, boolean value) {
+    public void setShowsMyLocationButton(MapView view, boolean value) {
         view.setShowsMyLocationButton(value);
     }
 
     @Override
-    public void setShowsScale(MapViewWrapper view, boolean value) {
+    public void setShowsScale(MapView view, boolean value) {
         // not supported
     }
 
     @Override
-    public void setShowsUserLocation(MapViewWrapper view, boolean value) {
+    public void setShowsUserLocation(MapView view, boolean value) {
         view.setShowsUserLocation(value);
     }
 
     @Override
-    public void setTintColor(MapViewWrapper view, @Nullable Integer value) {
+    public void setTintColor(MapView view, @Nullable Integer value) {
         // not supported
     }
 
     @Override
-    public void setToolbarEnabled(MapViewWrapper view, boolean value) {
-        options.mapToolbarEnabled(value);
-        if (view.getMapView() != null) {
-            view.getMapView().setToolbarEnabled(value);
-        }
+    public void setToolbarEnabled(MapView view, boolean value) {
+        view.setToolbarEnabled(value);
     }
 
     @Override
-    public void setUserInterfaceStyle(MapViewWrapper view, @Nullable String value) {
+    public void setUserInterfaceStyle(MapView view, @Nullable String value) {
         // todo update google maps SDK and add support for MapColorScheme
     }
 
     @Override
-    public void setUserLocationAnnotationTitle(MapViewWrapper view, @Nullable String value) {
+    public void setUserLocationAnnotationTitle(MapView view, @Nullable String value) {
         // not supported
     }
 
     @Override
-    public void setUserLocationCalloutEnabled(MapViewWrapper view, boolean value) {
+    public void setUserLocationCalloutEnabled(MapView view, boolean value) {
         // not supported
     }
 
     @Override
-    public void setUserLocationFastestInterval(MapViewWrapper view, int value) {
+    public void setUserLocationFastestInterval(MapView view, int value) {
         view.setUserLocationFastestInterval(value);
     }
 
     @Override
-    public void setUserLocationPriority(MapViewWrapper view, @Nullable String value) {
-        view.setUserLocationPriority(value);
+    public void setUserLocationPriority(MapView view, @Nullable String value) {
+        view.setUserLocationPriority(MY_LOCATION_PRIORITY.get(value));
     }
 
     @Override
-    public void setUserLocationUpdateInterval(MapViewWrapper view, int value) {
+    public void setUserLocationUpdateInterval(MapView view, int value) {
         view.setUserLocationUpdateInterval(value);
     }
 
     @Override
-    public void setZoomControlEnabled(MapViewWrapper view, boolean value) {
-        options.zoomControlsEnabled(value);
-        if (view.getMapView() != null) {
-            view.setZoomControlEnabled(value);
-        }
+    public void setZoomControlEnabled(MapView view, boolean value) {
+        view.setZoomControlEnabled(value);
     }
 
     @Override
-    public void setZoomEnabled(MapViewWrapper view, boolean value) {
-        options.zoomGesturesEnabled(value);
-        if (view.getMapView() != null) {
-            view.setZoomEnabled(value);
-        }
+    public void setZoomEnabled(MapView view, boolean value) {
+        view.setZoomEnabled(value);
     }
 
     @Override
-    public void setZoomTapEnabled(MapViewWrapper view, boolean value) {
+    public void setZoomTapEnabled(MapView view, boolean value) {
         // not supported
     }
 
     @Override
-    public void setCameraZoomRange(MapViewWrapper view, @Nullable ReadableMap value) {
+    public void setCameraZoomRange(MapView view, @Nullable ReadableMap value) {
         // not supported
     }
 
     @Override
-    public void animateToRegion(MapViewWrapper view, String regionJSON, int duration) {
-
-    }
-
-    @Override
-    public void setCamera(MapViewWrapper view, String cameraJSON) {
+    public void animateToRegion(MapView view, String regionJSON, int duration) {
 
     }
 
     @Override
-    public void animateCamera(MapViewWrapper view, String cameraJSON, int duration) {
+    public void setCamera(MapView view, String cameraJSON) {
 
     }
 
     @Override
-    public void fitToElements(MapViewWrapper view, String edgePaddingJSON, boolean animated) {
+    public void animateCamera(MapView view, String cameraJSON, int duration) {
 
     }
 
     @Override
-    public void fitToSuppliedMarkers(MapViewWrapper view, String markersJSON, String edgePaddingJSON, boolean animated) {
+    public void fitToElements(MapView view, String edgePaddingJSON, boolean animated) {
 
     }
 
     @Override
-    public void fitToCoordinates(MapViewWrapper view, String coordinatesJSON, String edgePaddingJSON, boolean animated) {
-
-    }
-    @Override
-    public int getChildCount(MapViewWrapper parent) {
-        if (parent.getMapView() != null) {
-            return parent.getMapView().getChildCount();
-        }
-        return 0;
-    }
+    public void fitToSuppliedMarkers(MapView view, String markersJSON, String edgePaddingJSON, boolean animated) {
 
-    @Override
-    public View getChildAt(MapViewWrapper parent, int index) {
-        if (parent.getMapView() != null) {
-            return parent.getMapView().getChildAt(index);
-        }
-        return null;
     }
 
     @Override
-    public void removeViewAt(MapViewWrapper parent, int index) {
-        if (parent.getMapView() != null) {
-            parent.getMapView().removeViewAt(index);
-        }
-    }
+    public void fitToCoordinates(MapView view, String coordinatesJSON, String edgePaddingJSON, boolean animated) {
 
-    public void removeView(MapViewWrapper parent, View view) {
-        if (parent.getMapView() != null) {
-            parent.getMapView().removeView(view);
-        }
     }
 
-
-    @Override
-    protected void onAfterUpdateTransaction(@NonNull MapViewWrapper view) {
-        super.onAfterUpdateTransaction(view);
-        setGoogleRenderer(view, null);
-        view.initializeMapView(options);
-        options = new GoogleMapOptions();
-        Log.e("MapViewManager", "onAfterUpdateTransaction tag: " + view.getId());
-    }
     @Override
-    public void onDropViewInstance(MapViewWrapper view) {
+    public void onDropViewInstance(MapView view) {
         super.onDropViewInstance(view);
-        view.prepareToRecycleView();
+        view.onDestroy();
     }
 }

package/package.json

@@ -5,7 +5,7 @@
   "main": "lib/index.js",
   "author": "Leland Richardson <leland.m.richardson@gmail.com>",
   "homepage": "https://github.com/react-native-maps/react-native-maps#readme",
-  "version": "1.21.0-alpha.55",
+  "version": "1.21.0-alpha.56",
   "license": "MIT",
   "scripts": {
     "lint": "eslint . --max-warnings 0",

package/android/src/main/java/com/rnmaps/fabric/MapViewWrapper.java

@@ -1,369 +0,0 @@
-package com.rnmaps.fabric;
-
-import static com.rnmaps.maps.MapManager.MY_LOCATION_PRIORITY;
-
-import android.annotation.SuppressLint;
-import android.content.Context;
-import android.view.View;
-import android.widget.FrameLayout;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
-import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.uimanager.ThemedReactContext;
-import com.google.android.gms.maps.GoogleMapOptions;
-import com.rnmaps.maps.MapView;
-
-@SuppressLint("ViewConstructor")
-public class MapViewWrapper extends FrameLayout {
-    private MapView mapView;
-    private Boolean cacheEnabled;
-    private Boolean initialCameraSet;
-
-    private Boolean showsBuildings;
-    private Boolean poiClickEnabled;
-    private Boolean moveOnMarkerPress;
-    private Boolean handlePanDrag;
-    private Boolean showsIndoorLevelPicker;
-    private Boolean showIndoors;
-    private Boolean showsMyLocationButton;
-    private Boolean showsUserLocation;
-    private Boolean loadingEnabled;
-
-    private ReadableMap camera;
-
-    private ReadableMap initialRegion;
-
-    private String kmlSrc;
-    private ReadableMap region;
-    private ReadableMap mapPadding;
-
-    private Integer userLocationPriority;
-    private Integer userLocationFastestInterval;
-    private Integer userLocationUpdateInterval;
-    private Integer loadingIndicatorColor;
-
-
-    public MapViewWrapper(@NonNull Context context) {
-        super(context);
-        setLayoutParams(new LayoutParams(
-                LayoutParams.MATCH_PARENT,
-                LayoutParams.MATCH_PARENT
-        ));
-    }
-
-
-    public MapView getMapView() {
-        return mapView;
-    }
-    public void initializeMapView(GoogleMapOptions options) {
-        if (mapView == null) {
-            mapView = new MapView((ThemedReactContext) getContext(), options);
-            mapView.setLayoutParams(new LayoutParams(
-                    LayoutParams.MATCH_PARENT,
-                    LayoutParams.MATCH_PARENT
-            ));
-            addView(mapView);
-            if (cacheEnabled != null){
-                setCacheEnabled(cacheEnabled);
-            }
-            if (showsBuildings != null){
-                setShowsBuildings(showsBuildings);
-            }
-            if (poiClickEnabled != null){
-                setPoiClickEnabled(poiClickEnabled);
-            }
-            if (moveOnMarkerPress != null){
-                setMoveOnMarkerPress(moveOnMarkerPress);
-            }
-            if (handlePanDrag != null){
-                setHandlePanDrag(handlePanDrag);
-            }
-            if (showsIndoorLevelPicker != null){
-                setShowsIndoorLevelPicker(showsIndoorLevelPicker);
-            }
-            if (showIndoors != null){
-                setShowsIndoors(showIndoors);
-            }
-
-            if (showsMyLocationButton != null){
-                setShowsMyLocationButton(showsMyLocationButton);
-            }
-            if (showsUserLocation != null) {
-                setShowsUserLocation(showsUserLocation);
-            }
-            if (loadingEnabled != null) {
-                setLoadingEnabled(loadingEnabled);
-            }
-            if (camera != null){
-                setCamera(camera);
-            }
-            if (kmlSrc != null){
-                setKmlSrc(kmlSrc);
-            }
-            if (region != null){
-                setRegion(region);
-            }
-            if (mapPadding != null){
-                setMapPadding(mapPadding);
-            }
-            if (userLocationPriority != null) {
-                mapView.setUserLocationPriority(userLocationPriority);
-            }
-            if (userLocationFastestInterval != null) {
-                setUserLocationFastestInterval(userLocationFastestInterval);
-            }
-            if (userLocationUpdateInterval != null) {
-                setUserLocationUpdateInterval(userLocationUpdateInterval);
-            }
-            if (loadingIndicatorColor != null) {
-                setLoadingIndicatorColor(loadingIndicatorColor);
-            }
-            if (initialRegion != null){
-                mapView.setInitialRegion(initialRegion);
-            }
-            if (initialCameraSet != null){
-                mapView.setInitialCameraSet(initialCameraSet);
-            }
-        }
-    }
-
-    protected void onDetachedFromWindow() {
-        super.onDetachedFromWindow();
-        if (mapView != null) {
-            mapView.onDestroy();
-            removeView(mapView);
-            mapView = null;
-        }
-    }
-
-    public void setInitialCameraSet(boolean initialCameraSet) {
-        this.initialCameraSet = initialCameraSet;
-    }
-
-    public void setInitialRegion(ReadableMap initialRegion) {
-        this.initialRegion = initialRegion;
-        if (getMapView() != null){
-            getMapView().setInitialRegion(initialRegion);
-        }
-    }
-
-    public void setCacheEnabled(boolean value) {
-        if (getMapView() != null) {
-            getMapView().setCacheEnabled(value);
-        } else {
-            cacheEnabled = value;
-        }
-    }
-
-
-    public void setCamera(@Nullable ReadableMap value) {
-        if (getMapView() != null) {
-            getMapView().setCamera(value);
-        } else {
-            camera = value;
-        }
-    }
-
-
-    public void setPoiClickEnabled(boolean value) {
-        if (getMapView() != null) {
-            getMapView().setPoiClickEnabled(value);
-        } else {
-            poiClickEnabled = value;
-        }
-    }
-   
-    public void prepareToRecycleView(){
-        mapView = null;
-        cacheEnabled = null;
-        initialCameraSet = null;
-        showsBuildings = null;
-        poiClickEnabled = null;
-        moveOnMarkerPress = null;
-        handlePanDrag = null;
-        showsIndoorLevelPicker = null;
-        showIndoors = null;
-        showsMyLocationButton = null;
-        showsUserLocation = null;
-        loadingEnabled = null;
-        camera = null;
-        initialRegion = null;
-        userLocationPriority = null;
-        userLocationFastestInterval = null;
-        userLocationUpdateInterval = null;
-        loadingIndicatorColor = null;
-        if (getMapView() != null) {
-            getMapView().onDestroy();
-        }
-        mapView = null;
-    }
-
-
-
-    public void setKmlSrc(@Nullable String value) {
-        if (getMapView() != null) {
-            getMapView().setKmlSrc(value);
-        }
-        kmlSrc = value;
-    }
-
-
-    public void setLoadingBackgroundColor(@Nullable Integer value) {
-        getMapView().setLoadingBackgroundColor(value);
-    }
-
-
-    public void setLoadingEnabled(boolean value) {
-        if (getMapView() != null) {
-            getMapView().setLoadingEnabled(value);
-        }
-        loadingEnabled = value;
-    }
-
-
-    public void setLoadingIndicatorColor(@Nullable Integer value) {
-        if (getMapView() != null) {
-            getMapView().setLoadingIndicatorColor(value);
-        }
-        loadingIndicatorColor = value;
-    }
-
-
-    public void setMapPadding(@Nullable ReadableMap padding) {
-        if (getMapView() != null) {
-            int left = 0;
-            int top = 0;
-            int right = 0;
-            int bottom = 0;
-            double density = (double) getMapView().getResources().getDisplayMetrics().density;
-
-            if (padding != null) {
-                if (padding.hasKey("left")) {
-                    left = (int) (padding.getDouble("left") * density);
-                }
-
-                if (padding.hasKey("top")) {
-                    top = (int) (padding.getDouble("top") * density);
-                }
-
-                if (padding.hasKey("right")) {
-                    right = (int) (padding.getDouble("right") * density);
-                }
-
-                if (padding.hasKey("bottom")) {
-                    bottom = (int) (padding.getDouble("bottom") * density);
-                }
-            }
-
-            getMapView().applyBaseMapPadding(left, top, right, bottom);
-            getMapView().map.setPadding(left, top, right, bottom);
-        }
-        this.mapPadding = padding;
-    }
-
-    public void setMoveOnMarkerPress(boolean value) {
-        if (getMapView() != null){
-            getMapView().setMoveOnMarkerPress(value);
-        }
-        moveOnMarkerPress = value;
-    }
-
-
-    public void setHandlePanDrag(boolean value) {
-        if (getMapView() != null) {
-            getMapView().setHandlePanDrag(value);
-        }
-        handlePanDrag = value;
-    }
-
-    public void setRegion(@Nullable ReadableMap value) {
-        if (getMapView() != null) {
-            getMapView().setRegion(value);
-        }
-        region = value;
-    }
-
-
-    public void setShowsBuildings(boolean value) {
-        showsBuildings = value;
-        if (getMapView() != null){
-            getMapView().setShowBuildings(value);
-        }
-    }
-
-
-    public void setShowsCompass(boolean value) {
-        if (getMapView() != null) {
-            getMapView().setShowsCompass(value);
-        }
-    }
-
-
-    public void setShowsIndoorLevelPicker(boolean value) {
-        if (getMapView() != null) {
-            getMapView().setShowsIndoorLevelPicker(value);
-        }
-        showsIndoorLevelPicker = value;
-    }
-
-
-    public void setShowsIndoors(boolean value) {
-        if (getMapView() != null){
-            getMapView().setShowIndoors(value);
-        }
-
-        showIndoors = value;
-    }
-
-
-    public void setShowsMyLocationButton(boolean value) {
-        if (getMapView() != null) {
-            getMapView().setShowsMyLocationButton(value);
-        }
-        showsMyLocationButton = value;
-    }
-
-    public void setShowsUserLocation(boolean value) {
-        if (getMapView() != null) {
-            getMapView().setShowsUserLocation(value);
-        }
-        showsUserLocation = value;
-    }
-
-    public void setUserLocationFastestInterval(int value) {
-        if (getMapView() != null) {
-            getMapView().setUserLocationFastestInterval(value);
-        }
-        userLocationFastestInterval = value;
-    }
-
-
-    public void setUserLocationPriority(@Nullable String value) {
-        if (mapView != null) {
-            mapView.setUserLocationPriority(MY_LOCATION_PRIORITY.get(value));
-        } else {
-            userLocationPriority = MY_LOCATION_PRIORITY.get(value);
-        }
-    }
-
-
-    public void setUserLocationUpdateInterval(int value) {
-        if (getMapView() != null) {
-            getMapView().setUserLocationUpdateInterval(value);
-        }
-        userLocationUpdateInterval = value;
-    }
-
-
-    public void setZoomControlEnabled(boolean value) {
-        getMapView().setZoomControlEnabled(value);
-    }
-
-
-    public void setZoomEnabled(boolean value) {
-        getMapView().setZoomEnabled(value);
-    }
-
-}