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

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

@@ -1,13 +1,17 @@
 package com.rnmaps.fabric;
 
 
+import android.util.Log;
 import android.view.View;
 
+import androidx.annotation.NonNull;
 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.ThemedReactContext;
 import com.facebook.react.uimanager.ViewGroupManager;
 import com.facebook.react.uimanager.ViewManagerDelegate;
@@ -15,23 +19,31 @@ import com.facebook.react.viewmanagers.RNMapsMapViewManagerInterface;
 import com.facebook.react.viewmanagers.RNMapsMapViewManagerDelegate;
 import com.google.android.gms.maps.GoogleMap;
 import com.google.android.gms.maps.GoogleMapOptions;
+import com.google.android.gms.maps.MapsInitializer;
+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<MapView> implements RNMapsMapViewManagerInterface<MapView> {
+public class MapViewManager extends ViewGroupManager<MapViewWrapper> implements RNMapsMapViewManagerInterface<MapViewWrapper> {
+
+    private GoogleMapOptions options;
+    private boolean rendererInitialized = false;
+    private final RNMapsMapViewManagerDelegate<MapViewWrapper, MapViewManager> delegate =
+            new RNMapsMapViewManagerDelegate<>(this);
 
 
-    public MapViewManager(ReactApplicationContext context){
+    public MapViewManager(ReactApplicationContext context) {
         super(context);
+        options = new GoogleMapOptions();
     }
-    private GoogleMapOptions options;
-    private final RNMapsMapViewManagerDelegate<MapView, MapViewManager> delegate =
-            new RNMapsMapViewManagerDelegate<>(this);
+
 
     @Override
-    public ViewManagerDelegate<MapView> getDelegate() {
+    public ViewManagerDelegate<MapViewWrapper> getDelegate() {
         return delegate;
     }
 
@@ -41,8 +53,9 @@ public class MapViewManager extends ViewGroupManager<MapView> implements RNMapsM
     }
 
     @Override
-    public MapView createViewInstance(ThemedReactContext context) {
-        return new MapView(context, options);
+    public MapViewWrapper createViewInstance(ThemedReactContext context) {
+        Log.e(MapViewManager.class.getName(), "createViewInstance");
+        return new MapViewWrapper(context);
     }
 
 
@@ -54,6 +67,14 @@ public class MapViewManager extends ViewGroupManager<MapView> implements RNMapsM
         return MapView.getExportedCustomBubblingEventTypeConstants();
     }
 
+
+    @Override
+    public LayoutShadowNode createShadowNodeInstance() {
+        // A custom shadow node is needed in order to pass back the width/height of the map to the
+        // view manager so that it can start applying camera moves with bounds.
+        return new SizeReportingShadowNode();
+    }
+
     @Nullable
     @Override
     public Map<String, Object> getExportedCustomDirectEventTypeConstants() {
@@ -61,288 +82,396 @@ public class MapViewManager extends ViewGroupManager<MapView> implements RNMapsM
     }
 
     @Override
-    public void setCacheEnabled(MapView view, boolean value) {
+    public void setCacheEnabled(MapViewWrapper view, boolean value) {
         view.setCacheEnabled(value);
     }
 
     @Override
-    public void setCamera(MapView view, @Nullable ReadableMap value) {
+    public void setCamera(MapViewWrapper view, @Nullable ReadableMap value) {
         view.setCamera(value);
     }
 
     @Override
-    public void setCompassOffset(MapView view, @Nullable ReadableMap value) {
-
+    public void setCompassOffset(MapViewWrapper view, @Nullable ReadableMap value) {
+        // not supported
     }
 
     @Override
-    public void setFollowsUserLocation(MapView view, boolean value) {
-
+    public void setFollowsUserLocation(MapViewWrapper view, boolean value) {
+        // not supported
     }
 
     @Override
-    public void setPoiClickEnabled(MapView view, boolean value) {
+    public void setPoiClickEnabled(MapViewWrapper view, boolean value) {
         view.setPoiClickEnabled(value);
     }
 
     @Override
-    public void setInitialCamera(MapView view, @Nullable ReadableMap value) {
-        view.setInitialCamera(value);
+    public void setInitialCamera(MapViewWrapper view, @Nullable ReadableMap value) {
+        CameraPosition camera = MapView.cameraPositionFromMap(value);
+        if (camera != null){
+            options.camera(camera);
+            view.setInitialCameraSet(true);
+        }
+    }
+
+    @Override
+    protected MapViewWrapper recycleView(@NonNull ThemedReactContext var1, @NonNull MapViewWrapper wrapper){
+        wrapper.prepareToRecycleView();
+        return wrapper;
     }
 
+
     @Override
-    public void setInitialRegion(MapView view, @Nullable ReadableMap value) {
+    public void setInitialRegion(MapViewWrapper view, @Nullable ReadableMap value) {
         view.setInitialRegion(value);
     }
 
     @Override
-    public void setKmlSrc(MapView view, @Nullable String value) {
+    public void setKmlSrc(MapViewWrapper view, @Nullable String value) {
         view.setKmlSrc(value);
     }
 
     @Override
-    public void setLegalLabelInsets(MapView view, @Nullable ReadableMap value) {
-
+    public void setLegalLabelInsets(MapViewWrapper view, @Nullable ReadableMap value) {
+        // not supported
     }
 
     @Override
-    public void setLiteMode(MapView view, boolean value) {
-
+    public void setLiteMode(MapViewWrapper view, boolean value) {
+        options.liteMode(value);
     }
 
     @Override
-    public void setGoogleMapId(MapView view, @Nullable String value) {
-
+    public void setGoogleMapId(MapViewWrapper view, @Nullable String value) {
+        options.mapId(value);
     }
 
     @Override
-    public void setGoogleRenderer(MapView view, @Nullable String value) {
+    public void setGoogleRenderer(MapViewWrapper view, @Nullable String value) {
+        if (!rendererInitialized) {
+            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));
+            rendererInitialized = true;
+        }
 
     }
 
     @Override
-    public void setLoadingBackgroundColor(MapView view, @Nullable Integer value) {
-
+    public void setLoadingBackgroundColor(MapViewWrapper view, @Nullable Integer value) {
+        view.setLoadingBackgroundColor(value);
     }
 
     @Override
-    public void setLoadingEnabled(MapView view, boolean value) {
-
+    public void setLoadingEnabled(MapViewWrapper view, boolean value) {
+        view.setLoadingEnabled(value);
     }
 
     @Override
-    public void setLoadingIndicatorColor(MapView view, @Nullable Integer value) {
+    public void setLoadingIndicatorColor(MapViewWrapper view, @Nullable Integer value) {
+        view.setLoadingIndicatorColor(value);
+    }
 
+    @Override
+    public void setMapPadding(MapViewWrapper view, @Nullable ReadableMap padding) {
+        view.setMapPadding(padding);
     }
 
     @Override
-    public void setMapPadding(MapView view, @Nullable ReadableMap value) {
+    public void addView(MapViewWrapper parent, View child, int index) {
+        parent.getMapView().addFeature(child, index);
+        Log.e("MapViewManager", "addView  " + child.getId() + " at index: " + index);
 
     }
-
     @Override
-    public void addView(MapView parent, View child, int index) {
-        parent.addFeature(child, index);
+    public void addViews(MapViewWrapper parent, List<View> views){
+        for (View view : views){
+            parent.getMapView().addView(view);
+            Log.e("MapViewManager", "addViews  " + view.getId());
+        }
+
     }
 
+
     @Override
-    public void setMapType(MapView view, @Nullable String value) {
+    public void setMapType(MapViewWrapper view, @Nullable String value) {
+        int mapType;
         //hybrid | none | satellite | standard | terrain
-        if ("hybrid".equals(value)){
-            view.setMapType(GoogleMap.MAP_TYPE_HYBRID);
-        } else if ("none".equals(value)){
-            view.setMapType(GoogleMap.MAP_TYPE_NONE);
-        } else if ("satellite".equals(value)){
-            view.setMapType(GoogleMap.MAP_TYPE_SATELLITE);
-        } else if ("standard".equals(value)){
-            view.setMapType(GoogleMap.MAP_TYPE_NORMAL);
-        } else if ("terrain".equals(value)){
-            view.setMapType(GoogleMap.MAP_TYPE_TERRAIN);
+        if ("hybrid".equals(value)) {
+            mapType = GoogleMap.MAP_TYPE_HYBRID;
+        } else if ("none".equals(value)) {
+            mapType = GoogleMap.MAP_TYPE_NONE;
+        } else if ("satellite".equals(value)) {
+            mapType = GoogleMap.MAP_TYPE_SATELLITE;
+        } else if ("standard".equals(value)) {
+            mapType = GoogleMap.MAP_TYPE_NORMAL;
+        } 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);
         }
     }
 
     @Override
-    public void setMaxDelta(MapView view, double value) {
-
+    public void setMaxDelta(MapViewWrapper view, double value) {
+        // not supported
     }
 
     @Override
-    public void setMaxZoom(MapView view, float value) {
-
+    public void setMaxZoom(MapViewWrapper view, float value) {
+        options.maxZoomPreference(value);
+        if (view.getMapView() != null) {
+            view.getMapView().setMaxZoomLevel(value);
+        }
     }
 
     @Override
-    public void setMinDelta(MapView view, double value) {
-
+    public void setMinDelta(MapViewWrapper view, double value) {
+        // not supported
     }
 
     @Override
-    public void setMinZoom(MapView view, float value) {
-
+    public void setMinZoom(MapViewWrapper view, float value) {
+        options.minZoomPreference(value);
+        if (view.getMapView() != null) {
+            view.getMapView().setMinZoomLevel(value);
+        }
     }
 
     @Override
-    public void setMoveOnMarkerPress(MapView view, boolean value) {
-
+    public void setMoveOnMarkerPress(MapViewWrapper view, boolean value) {
+            view.setMoveOnMarkerPress(value);
     }
 
     @Override
-    public void setHandlePanDrag(MapView view, boolean value) {
-
+    public void setHandlePanDrag(MapViewWrapper view, boolean value) {
+        view.setHandlePanDrag(value);
     }
 
     @Override
-    public void setPaddingAdjustmentBehavior(MapView view, @Nullable String value) {
-
+    public void setPaddingAdjustmentBehavior(MapViewWrapper view, @Nullable String value) {
+        // not supported
     }
 
     @Override
-    public void setPitchEnabled(MapView view, boolean value) {
-
+    public void setPitchEnabled(MapViewWrapper view, boolean value) {
+        options.tiltGesturesEnabled(value);
+        if (view.getMapView() != null) {
+            view.getMapView().setPitchEnabled(value);
+        }
     }
 
     @Override
-    public void setRegion(MapView view, @Nullable ReadableMap value) {
-
+    public void setRegion(MapViewWrapper view, @Nullable ReadableMap value) {
+        view.setRegion(value);
     }
 
     @Override
-    public void setRotateEnabled(MapView view, boolean value) {
-
+    public void setRotateEnabled(MapViewWrapper view, boolean value) {
+        options.rotateGesturesEnabled(value);
+        if (view.getMapView() != null) {
+            view.getMapView().setRotateEnabled(value);
+        }
     }
 
     @Override
-    public void setScrollDuringRotateOrZoomEnabled(MapView view, boolean value) {
-
+    public void setScrollDuringRotateOrZoomEnabled(MapViewWrapper view, boolean value) {
+        options.scrollGesturesEnabledDuringRotateOrZoom(value);
+        if (view.getMapView() != null) {
+            view.getMapView().setScrollDuringRotateOrZoomEnabled(value);
+        }
     }
 
     @Override
-    public void setScrollEnabled(MapView view, boolean value) {
-
+    public void setScrollEnabled(MapViewWrapper view, boolean value) {
+        options.scrollGesturesEnabled(value);
+        if (view.getMapView() != null) {
+            view.getMapView().setScrollEnabled(value);
+        }
     }
 
     @Override
-    public void setShowsBuildings(MapView view, boolean value) {
-
+    public void setShowsBuildings(MapViewWrapper view, boolean value) {
+        view.setShowsBuildings(value);
     }
 
     @Override
-    public void setShowsCompass(MapView view, boolean value) {
-
+    public void setShowsCompass(MapViewWrapper view, boolean value) {
+        options.compassEnabled(value);
+        view.setShowsCompass(value);
     }
 
     @Override
-    public void setShowsIndoorLevelPicker(MapView view, boolean value) {
-
+    public void setShowsIndoorLevelPicker(MapViewWrapper view, boolean value) {
+        view.setShowsIndoorLevelPicker(value);
     }
 
     @Override
-    public void setShowsIndoors(MapView view, boolean value) {
-
+    public void setShowsIndoors(MapViewWrapper view, boolean value) {
+        view.setShowsIndoors(value);
     }
 
     @Override
-    public void setShowsMyLocationButton(MapView view, boolean value) {
-
+    public void setShowsMyLocationButton(MapViewWrapper view, boolean value) {
+        view.setShowsMyLocationButton(value);
     }
 
     @Override
-    public void setShowsScale(MapView view, boolean value) {
-
+    public void setShowsScale(MapViewWrapper view, boolean value) {
+        // not supported
     }
 
     @Override
-    public void setShowsUserLocation(MapView view, boolean value) {
-
+    public void setShowsUserLocation(MapViewWrapper view, boolean value) {
+        view.setShowsUserLocation(value);
     }
 
     @Override
-    public void setTintColor(MapView view, @Nullable Integer value) {
-
+    public void setTintColor(MapViewWrapper view, @Nullable Integer value) {
+        // not supported
     }
 
     @Override
-    public void setToolbarEnabled(MapView view, boolean value) {
-
+    public void setToolbarEnabled(MapViewWrapper view, boolean value) {
+        options.mapToolbarEnabled(value);
+        if (view.getMapView() != null) {
+            view.getMapView().setToolbarEnabled(value);
+        }
     }
 
     @Override
-    public void setUserInterfaceStyle(MapView view, @Nullable String value) {
-
+    public void setUserInterfaceStyle(MapViewWrapper view, @Nullable String value) {
+        // todo update google maps SDK and add support for MapColorScheme
     }
 
     @Override
-    public void setUserLocationAnnotationTitle(MapView view, @Nullable String value) {
-
+    public void setUserLocationAnnotationTitle(MapViewWrapper view, @Nullable String value) {
+        // not supported
     }
 
     @Override
-    public void setUserLocationCalloutEnabled(MapView view, boolean value) {
-
+    public void setUserLocationCalloutEnabled(MapViewWrapper view, boolean value) {
+        // not supported
     }
 
     @Override
-    public void setUserLocationFastestInterval(MapView view, int value) {
-
+    public void setUserLocationFastestInterval(MapViewWrapper view, int value) {
+        view.setUserLocationFastestInterval(value);
     }
 
     @Override
-    public void setUserLocationPriority(MapView view, @Nullable String value) {
+    public void setUserLocationPriority(MapViewWrapper view, @Nullable String value) {
+        view.setUserLocationPriority(value);
+    }
 
+    @Override
+    public void setUserLocationUpdateInterval(MapViewWrapper view, int value) {
+        view.setUserLocationUpdateInterval(value);
     }
 
     @Override
-    public void setUserLocationUpdateInterval(MapView view, int value) {
+    public void setZoomControlEnabled(MapViewWrapper view, boolean value) {
+        options.zoomControlsEnabled(value);
+        if (view.getMapView() != null) {
+            view.setZoomControlEnabled(value);
+        }
+    }
 
+    @Override
+    public void setZoomEnabled(MapViewWrapper view, boolean value) {
+        options.zoomGesturesEnabled(value);
+        if (view.getMapView() != null) {
+            view.setZoomEnabled(value);
+        }
     }
 
     @Override
-    public void setZoomControlEnabled(MapView view, boolean value) {
+    public void setZoomTapEnabled(MapViewWrapper view, boolean value) {
+        // not supported
+    }
 
+    @Override
+    public void setCameraZoomRange(MapViewWrapper view, @Nullable ReadableMap value) {
+        // not supported
     }
 
     @Override
-    public void setZoomEnabled(MapView view, boolean value) {
+    public void animateToRegion(MapViewWrapper view, String regionJSON, int duration) {
 
     }
 
     @Override
-    public void setZoomTapEnabled(MapView view, boolean value) {
+    public void setCamera(MapViewWrapper view, String cameraJSON) {
 
     }
 
     @Override
-    public void setCameraZoomRange(MapView view, @Nullable ReadableMap value) {
+    public void animateCamera(MapViewWrapper view, String cameraJSON, int duration) {
 
     }
 
     @Override
-    public void animateToRegion(MapView view, String regionJSON, int duration) {
+    public void fitToElements(MapViewWrapper view, String edgePaddingJSON, boolean animated) {
 
     }
 
     @Override
-    public void setCamera(MapView view, String cameraJSON) {
+    public void fitToSuppliedMarkers(MapViewWrapper view, String markersJSON, String edgePaddingJSON, boolean animated) {
 
     }
 
     @Override
-    public void animateCamera(MapView view, String cameraJSON, int duration) {
+    public void fitToCoordinates(MapViewWrapper view, String coordinatesJSON, String edgePaddingJSON, boolean animated) {
 
     }
-
     @Override
-    public void fitToElements(MapView view, String edgePaddingJSON, boolean animated) {
+    public int getChildCount(MapViewWrapper parent) {
+        if (parent.getMapView() != null) {
+            return parent.getMapView().getChildCount();
+        }
+        return 0;
+    }
 
+    @Override
+    public View getChildAt(MapViewWrapper parent, int index) {
+        if (parent.getMapView() != null) {
+            return parent.getMapView().getChildAt(index);
+        }
+        return null;
     }
 
     @Override
-    public void fitToSuppliedMarkers(MapView view, String markersJSON, String edgePaddingJSON, boolean animated) {
+    public void removeViewAt(MapViewWrapper parent, int index) {
+        if (parent.getMapView() != null) {
+            parent.getMapView().removeViewAt(index);
+        }
+    }
 
+    public void removeView(MapViewWrapper parent, View view) {
+        if (parent.getMapView() != null) {
+            parent.getMapView().removeView(view);
+        }
     }
 
-    @Override
-    public void fitToCoordinates(MapView view, String coordinatesJSON, String edgePaddingJSON, boolean animated) {
 
+    @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) {
+        super.onDropViewInstance(view);
+        view.prepareToRecycleView();
     }
-}
+}

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

@@ -0,0 +1,369 @@
+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);
+    }
+
+}

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

@@ -42,7 +42,7 @@ public class MapManager extends ViewGroupManager<MapView> {
             "none", GoogleMap.MAP_TYPE_NONE
     );
 
-    private final Map<String, Integer> MY_LOCATION_PRIORITY = MapBuilder.of(
+    public static final Map<String, Integer> MY_LOCATION_PRIORITY = MapBuilder.of(
             "balanced", Priority.PRIORITY_BALANCED_POWER_ACCURACY,
             "high", Priority.PRIORITY_HIGH_ACCURACY,
             "low", Priority.PRIORITY_LOW_POWER,
@@ -240,47 +240,47 @@ public class MapManager extends ViewGroupManager<MapView> {
 
     @ReactProp(name = "showsBuildings", defaultBoolean = false)
     public void setShowBuildings(MapView view, boolean showBuildings) {
-        view.map.setBuildingsEnabled(showBuildings);
+        view.setShowBuildings(showBuildings);
     }
 
     @ReactProp(name = "showsIndoors", defaultBoolean = false)
     public void setShowIndoors(MapView view, boolean showIndoors) {
-        view.map.setIndoorEnabled(showIndoors);
+        view.setShowIndoors(showIndoors);
     }
 
     @ReactProp(name = "showsIndoorLevelPicker", defaultBoolean = false)
     public void setShowsIndoorLevelPicker(MapView view, boolean showsIndoorLevelPicker) {
-        view.map.getUiSettings().setIndoorLevelPickerEnabled(showsIndoorLevelPicker);
+        view.setShowsIndoorLevelPicker(showsIndoorLevelPicker);
     }
 
     @ReactProp(name = "showsCompass", defaultBoolean = false)
     public void setShowsCompass(MapView view, boolean showsCompass) {
-        view.map.getUiSettings().setCompassEnabled(showsCompass);
+        view.setShowsCompass(showsCompass);
     }
 
     @ReactProp(name = "scrollEnabled", defaultBoolean = false)
     public void setScrollEnabled(MapView view, boolean scrollEnabled) {
-        view.map.getUiSettings().setScrollGesturesEnabled(scrollEnabled);
+        view.setScrollEnabled(scrollEnabled);
     }
 
     @ReactProp(name = "zoomEnabled", defaultBoolean = false)
     public void setZoomEnabled(MapView view, boolean zoomEnabled) {
-        view.map.getUiSettings().setZoomGesturesEnabled(zoomEnabled);
+        view.setZoomEnabled(zoomEnabled);
     }
 
     @ReactProp(name = "zoomControlEnabled", defaultBoolean = true)
     public void setZoomControlEnabled(MapView view, boolean zoomControlEnabled) {
-        view.map.getUiSettings().setZoomControlsEnabled(zoomControlEnabled);
+        view.setZoomControlEnabled(zoomControlEnabled);
     }
 
     @ReactProp(name = "rotateEnabled", defaultBoolean = false)
     public void setRotateEnabled(MapView view, boolean rotateEnabled) {
-        view.map.getUiSettings().setRotateGesturesEnabled(rotateEnabled);
+        view.setRotateEnabled(rotateEnabled);
     }
 
     @ReactProp(name = "scrollDuringRotateOrZoomEnabled", defaultBoolean = true)
     public void setScrollDuringRotateOrZoomEnabled(MapView view, boolean scrollDuringRotateOrZoomEnabled) {
-        view.map.getUiSettings().setScrollGesturesEnabledDuringRotateOrZoom(scrollDuringRotateOrZoomEnabled);
+        view.setScrollDuringRotateOrZoomEnabled(scrollDuringRotateOrZoomEnabled);
     }
 
     @ReactProp(name = "cacheEnabled", defaultBoolean = false)
@@ -295,7 +295,7 @@ public class MapManager extends ViewGroupManager<MapView> {
 
     @ReactProp(name = "loadingEnabled", defaultBoolean = false)
     public void setLoadingEnabled(MapView view, boolean loadingEnabled) {
-        view.enableMapLoading(loadingEnabled);
+        view.setLoadingEnabled(loadingEnabled);
     }
 
     @ReactProp(name = "moveOnMarkerPress", defaultBoolean = true)
@@ -315,17 +315,17 @@ public class MapManager extends ViewGroupManager<MapView> {
 
     @ReactProp(name = "pitchEnabled", defaultBoolean = false)
     public void setPitchEnabled(MapView view, boolean pitchEnabled) {
-        view.map.getUiSettings().setTiltGesturesEnabled(pitchEnabled);
+        view.setPitchEnabled(pitchEnabled);
     }
 
     @ReactProp(name = "minZoomLevel")
     public void setMinZoomLevel(MapView view, float minZoomLevel) {
-        view.map.setMinZoomPreference(minZoomLevel);
+        view.setMinZoomLevel(minZoomLevel);
     }
 
     @ReactProp(name = "maxZoomLevel")
     public void setMaxZoomLevel(MapView view, float maxZoomLevel) {
-        view.map.setMaxZoomPreference(maxZoomLevel);
+        view.setMaxZoomLevel(maxZoomLevel);
     }
 
     @ReactProp(name = "kmlSrc")

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

@@ -37,14 +37,12 @@ import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.UIManagerHelper;
-import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.events.Event;
 import com.facebook.react.uimanager.events.EventDispatcher;
 import com.google.android.gms.maps.CameraUpdate;
 import com.google.android.gms.maps.CameraUpdateFactory;
 import com.google.android.gms.maps.GoogleMap;
 import com.google.android.gms.maps.GoogleMapOptions;
-import com.google.android.gms.maps.MapsInitializer;
 import com.google.android.gms.maps.OnMapReadyCallback;
 import com.google.android.gms.maps.Projection;
 import com.google.android.gms.maps.model.BitmapDescriptorFactory;
@@ -69,7 +67,6 @@ import com.google.maps.android.collections.PolylineManager;
 import com.google.maps.android.data.kml.KmlContainer;
 import com.google.maps.android.data.kml.KmlLayer;
 import com.google.maps.android.data.kml.KmlPlacemark;
-import com.google.maps.android.data.kml.KmlStyle;
 
 import org.xmlpull.v1.XmlPullParserException;
 
@@ -141,6 +138,18 @@ public class MapView extends com.google.android.gms.maps.MapView implements Goog
 
   private final ViewAttacherGroup attacherGroup;
   private LatLng tapLocation;
+  private Float maxZoomLevel;
+  private Float minZoomLevel;
+  private Boolean pitchEnabled;
+  private Boolean showsCompass;
+  private Boolean rotateEnabled;
+  private Boolean zoomEnabled;
+  private Boolean zoomControlEnabled;
+  private Boolean setShowBuildings;
+  private Boolean showsIndoorLevelPicker;
+  private Boolean showIndoors;
+  private Boolean scrollEnabled;
+  private Boolean scrollDuringRotateOrZoomEnabled;
 
   private static boolean contextHasBug(Context context) {
     return context == null ||
@@ -175,7 +184,6 @@ public class MapView extends com.google.android.gms.maps.MapView implements Goog
                  GoogleMapOptions googleMapOptions) {
     super(context, googleMapOptions);
     // todo add support for legacy renderer
-    MapsInitializer.initialize(context, MapsInitializer.Renderer.LATEST, renderer -> Log.d("AirMapRenderer", renderer.toString()));
     this.context = context;
     super.onCreate(null);
     super.onResume();
@@ -260,6 +268,42 @@ public class MapView extends com.google.android.gms.maps.MapView implements Goog
       return;
     }
     this.map = map;
+    if (maxZoomLevel != null){
+      setMaxZoomLevel(maxZoomLevel);
+    }
+    if (minZoomLevel != null){
+      setMinZoomLevel(minZoomLevel);
+    }
+    if (pitchEnabled != null){
+      setPitchEnabled(pitchEnabled);
+    }
+    if (showsCompass != null){
+      setShowsCompass(showsCompass);
+    }
+    if (rotateEnabled != null){
+      setRotateEnabled(rotateEnabled);
+    }
+    if (zoomEnabled != null){
+      setZoomEnabled(zoomEnabled);
+    }
+    if (zoomControlEnabled != null){
+      setZoomControlEnabled(zoomControlEnabled);
+    }
+    if (setShowBuildings != null){
+      setShowBuildings(setShowBuildings);
+    }
+    if (showsIndoorLevelPicker != null){
+      setShowsIndoorLevelPicker(showsIndoorLevelPicker);
+    }
+    if (showIndoors != null){
+      setShowIndoors(showIndoors);
+    }
+    if (scrollEnabled != null){
+      setScrollEnabled(scrollEnabled);
+    }
+    if (scrollDuringRotateOrZoomEnabled != null){
+      setScrollDuringRotateOrZoomEnabled(scrollDuringRotateOrZoomEnabled);
+    }
 
     markerManager = new MarkerManager(map);
     markerCollection = markerManager.newCollection();
@@ -588,6 +632,10 @@ public class MapView extends com.google.android.gms.maps.MapView implements Goog
     onDestroy();
   }
 
+  public void setInitialCameraSet(boolean initialCameraSet){
+    this.initialCameraSet = initialCameraSet;
+  }
+
   public void setInitialRegion(ReadableMap initialRegion) {
     this.initialRegion = initialRegion;
     // Theoretically onMapReady might be called before setInitialRegion
@@ -623,18 +671,23 @@ public class MapView extends com.google.android.gms.maps.MapView implements Goog
     }
     this.setPoiClickEnabled(poiClickEnabled);
   }
-
+public static LatLngBounds latLngBoundsFromRegion(ReadableMap region){
+  if (region == null) return null;
+
+  double lng = region.getDouble("longitude");
+  double lat = region.getDouble("latitude");
+  double lngDelta = region.getDouble("longitudeDelta");
+  double latDelta = region.getDouble("latitudeDelta");
+  return  new LatLngBounds(
+          new LatLng(lat - latDelta / 2, lng - lngDelta / 2), // southwest
+          new LatLng(lat + latDelta / 2, lng + lngDelta / 2)  // northeast
+  );
+}
   private void moveToRegion(ReadableMap region) {
-    if (region == null) return;
-
+    LatLngBounds bounds = latLngBoundsFromRegion(region);
+    if (bounds == null) return;
     double lng = region.getDouble("longitude");
     double lat = region.getDouble("latitude");
-    double lngDelta = region.getDouble("longitudeDelta");
-    double latDelta = region.getDouble("latitudeDelta");
-    LatLngBounds bounds = new LatLngBounds(
-            new LatLng(lat - latDelta / 2, lng - lngDelta / 2), // southwest
-            new LatLng(lat + latDelta / 2, lng + lngDelta / 2)  // northeast
-    );
     if (super.getHeight() <= 0 || super.getWidth() <= 0) {
       // in this case, our map has not been laid out yet, so we save the bounds in a local
       // variable, and make a guess of zoomLevel 10. Not to worry, though: as soon as layout
@@ -724,18 +777,24 @@ public static CameraPosition cameraPositionFromMap(ReadableMap camera){
   }
 
   public void setShowsMyLocationButton(boolean showMyLocationButton) {
-    if (hasPermissions() || !showMyLocationButton) {
-      map.getUiSettings().setMyLocationButtonEnabled(showMyLocationButton);
+    if (map != null) {
+      if (hasPermissions() || !showMyLocationButton) {
+        map.getUiSettings().setMyLocationButtonEnabled(showMyLocationButton);
+      }
     }
   }
 
   public void setToolbarEnabled(boolean toolbarEnabled) {
-    if (hasPermissions() || !toolbarEnabled) {
-      map.getUiSettings().setMapToolbarEnabled(toolbarEnabled);
+    if (map != null) {
+      if (hasPermissions() || !toolbarEnabled) {
+        map.getUiSettings().setMapToolbarEnabled(toolbarEnabled);
+      }
     }
   }
   public void setMapType(int mapType){
-    map.setMapType(mapType);
+    if (map != null) {
+      map.setMapType(mapType);
+    }
   }
 
   public void setCacheEnabled(boolean cacheEnabled) {
@@ -745,10 +804,12 @@ public static CameraPosition cameraPositionFromMap(ReadableMap camera){
 
   public void setPoiClickEnabled(boolean poiClickEnabled) {
     this.poiClickEnabled = poiClickEnabled;
-    map.setOnPoiClickListener(poiClickEnabled ? this : null);
+    if (map != null) {
+      map.setOnPoiClickListener(poiClickEnabled ? this : null);
+    }
   }
 
-  public void enableMapLoading(boolean loadingEnabled) {
+  public void setLoadingEnabled(boolean loadingEnabled) {
     if (loadingEnabled && !this.isMapLoaded) {
       this.getMapLoadingLayoutView().setVisibility(View.VISIBLE);
     }
@@ -757,6 +818,79 @@ public static CameraPosition cameraPositionFromMap(ReadableMap camera){
   public void setMoveOnMarkerPress(boolean moveOnPress) {
     this.moveOnMarkerPress = moveOnPress;
   }
+  public void setMaxZoomLevel(float maxZoomLevel){
+    this.maxZoomLevel = maxZoomLevel;
+    if (map != null) {
+      map.setMaxZoomPreference(maxZoomLevel);
+    }
+  }
+  public void setMinZoomLevel(float minZoomLevel){
+    this.minZoomLevel = minZoomLevel;
+    if (map != null) {
+      map.setMinZoomPreference(minZoomLevel);
+    }
+  }
+  public void setPitchEnabled(boolean pitchEnabled){
+    this.pitchEnabled = pitchEnabled;
+    if (map != null) {
+      map.getUiSettings().setTiltGesturesEnabled(pitchEnabled);
+    }
+  }
+  public void setShowsCompass(boolean showsCompass){
+    this.showsCompass = showsCompass;
+    if (map != null) {
+      map.getUiSettings().setCompassEnabled(showsCompass);
+    }
+  }
+  public void setRotateEnabled(boolean rotateEnabled){
+    this.rotateEnabled = rotateEnabled;
+    if (map != null) {
+      map.getUiSettings().setRotateGesturesEnabled(rotateEnabled);
+    }
+  }
+  public void setZoomEnabled(boolean zoomEnabled){
+    this.zoomEnabled = zoomEnabled;
+    if (map != null) {
+      map.getUiSettings().setZoomGesturesEnabled(zoomEnabled);
+    }
+  }
+  public void setZoomControlEnabled(boolean zoomControlEnabled){
+    this.zoomControlEnabled = zoomControlEnabled;
+    if (map != null) {
+      map.getUiSettings().setZoomControlsEnabled(zoomControlEnabled);
+    }
+  }
+  public void setScrollDuringRotateOrZoomEnabled(boolean scrollDuringRotateOrZoomEnabled){
+    this.scrollDuringRotateOrZoomEnabled = scrollDuringRotateOrZoomEnabled;
+    if (map != null) {
+      map.getUiSettings().setScrollGesturesEnabledDuringRotateOrZoom(scrollDuringRotateOrZoomEnabled);
+    }
+  }
+  public void setScrollEnabled(boolean scrollEnabled){
+    this.scrollEnabled = scrollEnabled;
+    if (map != null) {
+      map.getUiSettings().setScrollGesturesEnabled(scrollEnabled);
+    }
+  }
+  public void setShowIndoors(boolean showIndoors){
+    this.showIndoors = showIndoors;
+    if (map != null) {
+      map.setIndoorEnabled(showIndoors);
+    }
+  }
+  public void setShowsIndoorLevelPicker(boolean showsIndoorLevelPicker) {
+    this.showsIndoorLevelPicker = showsIndoorLevelPicker;
+    if (map != null) {
+      map.getUiSettings().setIndoorLevelPickerEnabled(showsIndoorLevelPicker);
+    }
+  }
+  public void setShowBuildings(boolean showBuildings) {
+    this.setShowBuildings = showBuildings;
+    if (map != null) {
+      map.setBuildingsEnabled(showBuildings);
+    }
+  }
+
 
   public void setLoadingBackgroundColor(Integer loadingBackgroundColor) {
     this.loadingBackgroundColor = loadingBackgroundColor;

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.53",
+  "version": "1.21.0-alpha.55",
   "license": "MIT",
   "scripts": {
     "lint": "eslint . --max-warnings 0",