@rnmapbox/maps 10.0.0-beta.28

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/annotation/RCTMGLPointAnnotation.java

@@ -0,0 +1,360 @@
+package com.mapbox.rctmgl.components.annotation;
+
+import android.content.Context;
+import android.graphics.PointF;
+import android.graphics.Bitmap;
+import android.view.View;
+import androidx.annotation.NonNull;
+
+import com.mapbox.geojson.Point;
+import com.mapbox.mapboxsdk.geometry.LatLng;
+import com.mapbox.mapboxsdk.maps.Style;
+import com.mapbox.mapboxsdk.plugins.annotation.Symbol;
+import com.mapbox.mapboxsdk.plugins.annotation.SymbolManager;
+import com.mapbox.mapboxsdk.plugins.annotation.SymbolOptions;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.rctmgl.components.AbstractMapFeature;
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView;
+import com.mapbox.rctmgl.events.PointAnnotationClickEvent;
+import com.mapbox.rctmgl.events.PointAnnotationDragEvent;
+import com.mapbox.rctmgl.events.constants.EventTypes;
+import com.mapbox.rctmgl.utils.GeoJSONUtils;
+import com.mapbox.rctmgl.utils.BitmapUtils;
+
+public class RCTMGLPointAnnotation extends AbstractMapFeature implements View.OnLayoutChangeListener {
+    private Context mContext;
+    private RCTMGLPointAnnotationManager mManager;
+    private Symbol mAnnotation;
+    private MapboxMap mMap;
+    private RCTMGLMapView mMapView;
+
+    private boolean mHasChildren;
+
+    private Point mCoordinate;
+
+    private String mID;
+    private String mTitle;
+    private String mSnippet;
+
+    private Float[] mAnchor;
+    private boolean mIsSelected;
+    private boolean mDraggable;
+
+    private View mChildView;
+    private Bitmap mChildBitmap;
+    private String mChildBitmapId;
+
+    private View mCalloutView;
+    private Symbol mCalloutSymbol;
+    private Bitmap mCalloutBitmap;
+    private String mCalloutBitmapId;
+
+    private static final String MARKER_IMAGE_ID = "MARKER_IMAGE_ID";
+
+    public RCTMGLPointAnnotation(Context context, RCTMGLPointAnnotationManager manager) {
+        super(context);
+        mContext = context;
+        mManager = manager;
+    }
+
+    @Override
+    public void addView(View childView, int childPosition) {
+        if (childView instanceof RCTMGLCallout) {
+            mCalloutView = childView;
+        } else {
+            mChildView = childView;
+        }
+        childView.addOnLayoutChangeListener(this);
+        if (mMapView != null) {
+            mMapView.offscreenAnnotationViewContainer().addView(childView);
+        }
+    }
+
+    @Override
+    public void removeView(View childView) {
+        if (mChildView != null) {
+            mMap.getStyle(new Style.OnStyleLoaded() {
+                @Override
+                public void onStyleLoaded(@NonNull Style style) {
+                    style.removeImage(mChildBitmapId);
+                    mChildView = null;
+                    mCalloutView = null;
+                    mChildBitmap = null;
+                    mChildBitmapId = null;
+                    updateOptions();
+                }
+            });
+        }
+        if (mMapView != null) {
+            mMapView.offscreenAnnotationViewContainer().removeView(childView);
+        }
+    }
+
+    @Override
+    public void addToMap(RCTMGLMapView mapView) {
+        mMapView = mapView;
+        mMap = mapView.getMapboxMap();
+        makeMarker();
+
+        if (mChildView != null) {
+            if (!mChildView.isAttachedToWindow()) {
+                mMapView.offscreenAnnotationViewContainer().addView(mChildView);
+            }
+            addBitmapToStyle(mChildBitmap, mChildBitmapId);
+            updateOptions();
+        }
+        if (mCalloutView != null) {
+            if (!mCalloutView.isAttachedToWindow()) {
+                mMapView.offscreenAnnotationViewContainer().addView(mCalloutView);
+            }
+            addBitmapToStyle(mCalloutBitmap, mCalloutBitmapId);
+        }
+    }
+
+    @Override
+    public void removeFromMap(RCTMGLMapView mapView) {
+        RCTMGLMapView map = (mMapView != null) ? mMapView : mapView;
+        if (map == null) {
+            return;
+        }
+
+        if (mAnnotation != null) {
+            map.getSymbolManager().delete(mAnnotation);
+        }
+        if (mChildView != null) {
+            map.offscreenAnnotationViewContainer().removeView(mChildView);
+        }
+        if (mCalloutView != null) {
+            map.offscreenAnnotationViewContainer().removeView(mCalloutView);
+        }
+    }
+
+    @Override
+    public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop,
+            int oldRight, int oldBottom) {
+        if (left == 0 && top == 0 && right == 0 && bottom == 0) {
+            return;
+        }
+        if (left != oldLeft || right != oldRight || top != oldTop || bottom != oldBottom) {
+            refreshBitmap(v, left, top, right, bottom);
+        }
+    }
+
+    private void refreshBitmap(View v, int left, int top, int right, int bottom) {
+        Bitmap bitmap = BitmapUtils.viewToBitmap(v, left, top, right, bottom);
+        String bitmapId = Integer.toString(v.getId());
+        addBitmapToStyle(bitmap, bitmapId);
+        if (v instanceof RCTMGLCallout) {
+            mCalloutBitmap = bitmap;
+            mCalloutBitmapId = bitmapId;
+        } else {
+            if (bitmap != null) {
+                mChildBitmap = bitmap;
+                mChildBitmapId = bitmapId;
+                updateOptions();
+            }
+        }
+    }
+
+    private void refreshBitmap(View v) {
+        refreshBitmap(v, v.getLeft(), v.getTop(), v.getRight(), v.getBottom());
+    }
+
+    public LatLng getLatLng() {
+        return GeoJSONUtils.toLatLng(mCoordinate);
+    }
+
+    public long getMapboxID() {
+        return mAnnotation == null ? -1 : mAnnotation.getId();
+    }
+
+    public String getID() {
+        return mID;
+    }
+
+    public void setID(String id) {
+        mID = id;
+    }
+
+    public View getCalloutView() {
+        return mCalloutView;
+    }
+
+    public void setCoordinate(Point point) {
+        mCoordinate = point;
+
+        if (mAnnotation != null) {
+            mAnnotation.setLatLng(GeoJSONUtils.toLatLng(point));
+            mMapView.getSymbolManager().update(mAnnotation);
+        }
+        if (mCalloutSymbol != null) {
+            mCalloutSymbol.setLatLng(GeoJSONUtils.toLatLng(point));
+            mMapView.getSymbolManager().update(mCalloutSymbol);
+        }
+    }
+
+    public void setAnchor(float x, float y) {
+        mAnchor = new Float[]{x, y};
+
+        if (mAnnotation != null) {
+            updateAnchor();
+            mMapView.getSymbolManager().update(mAnnotation);
+        }
+    }
+
+    public void setDraggable(Boolean draggable) {
+        mDraggable = draggable;
+        if (mAnnotation != null) {
+            mAnnotation.setDraggable(draggable);
+            mMapView.getSymbolManager().update(mAnnotation);
+        }
+    }
+
+    public Symbol getMarker() {
+        return mAnnotation;
+    }
+
+    public void onSelect(boolean shouldSendEvent) {
+        if (mCalloutView != null) {
+            makeCallout();
+        }
+        if (shouldSendEvent) {
+            mManager.handleEvent(makeEvent(true));
+        }
+    }
+
+    public void onDeselect() {
+        mManager.handleEvent(makeEvent(false));
+        if (mCalloutSymbol != null) {
+            mMapView.getSymbolManager().delete(mCalloutSymbol);
+        }
+    }
+
+    public void onDragStart() {
+        LatLng latLng = mAnnotation.getLatLng();
+        mCoordinate = Point.fromLngLat(latLng.getLongitude(), latLng.getLatitude());
+        mManager.handleEvent(makeDragEvent(EventTypes.ANNOTATION_DRAG_START));
+    }
+
+    public void onDrag() {
+        LatLng latLng = mAnnotation.getLatLng();
+        mCoordinate = Point.fromLngLat(latLng.getLongitude(), latLng.getLatitude());
+        mManager.handleEvent(makeDragEvent(EventTypes.ANNOTATION_DRAG));
+    }
+
+    public void onDragEnd() {
+        LatLng latLng = mAnnotation.getLatLng();
+        mCoordinate = Point.fromLngLat(latLng.getLongitude(), latLng.getLatitude());
+        mManager.handleEvent(makeDragEvent(EventTypes.ANNOTATION_DRAG_END));
+    }
+
+    public void makeMarker() {
+        SymbolOptions options = new SymbolOptions()
+            .withLatLng(GeoJSONUtils.toLatLng(mCoordinate))
+            .withDraggable(mDraggable)
+            .withIconSize(1.0f)
+            .withSymbolSortKey(10.0f);
+        SymbolManager symbolManager = mMapView.getSymbolManager();
+        if (symbolManager != null) {
+            mAnnotation = symbolManager.create(options);
+            updateOptions();
+        }
+    }
+
+    private void updateOptions() {
+        if (mAnnotation != null) {
+            updateIconImage();
+            updateAnchor();
+            mMapView.getSymbolManager().update(mAnnotation);
+        }
+    }
+
+    private void updateIconImage() {
+        if (mChildView != null) {
+            if (mChildBitmapId != null) {
+                mAnnotation.setIconImage(mChildBitmapId);
+            }
+        } else {
+            mAnnotation.setIconImage(MARKER_IMAGE_ID);
+            mAnnotation.setIconAnchor("bottom");
+        }
+    }
+
+    private void updateAnchor() {
+        if (mAnchor != null && mChildView != null && mChildBitmap != null) {
+            int w = mChildBitmap.getWidth();
+            int h = mChildBitmap.getHeight();
+            final float scale = getResources().getDisplayMetrics().density;
+            w = (int) (w / scale);
+            h = (int) (h / scale);
+            mAnnotation.setIconAnchor("top-left");
+            mAnnotation.setIconOffset(new PointF(w * mAnchor[0] * -1, h * mAnchor[1] * -1));
+        }
+    }
+
+    private void makeCallout() {
+        float yOffset = -28f;
+        if (mChildView != null) {
+            if (mChildBitmap != null) {
+                float scale = getResources().getDisplayMetrics().density;
+                int h = (int) mChildBitmap.getHeight() / 2;
+                h = (int) (h / scale);
+                yOffset = (float) h * -1;
+            }
+        }
+        SymbolOptions options = new SymbolOptions()
+            .withLatLng(GeoJSONUtils.toLatLng(mCoordinate))
+            .withIconImage(mCalloutBitmapId)
+            .withIconSize(1.0f)
+            .withIconAnchor("bottom")
+            .withIconOffset(new Float[] {0f, yOffset})
+            .withSymbolSortKey(11.0f)
+            .withDraggable(false);
+        SymbolManager symbolManager = mMapView.getSymbolManager();
+        if (symbolManager != null) {
+            mCalloutSymbol = symbolManager.create(options);
+        }
+    }
+
+    private void addBitmapToStyle(final Bitmap bitmap, final String bitmapId) {
+        if (mMap != null && bitmapId != null && bitmap != null) {
+            mMap.getStyle(new Style.OnStyleLoaded() {
+                @Override
+                public void onStyleLoaded(@NonNull Style style) {
+                    style.addImage(bitmapId, bitmap);
+                }
+            });
+        }
+    }
+
+    private PointAnnotationClickEvent makeEvent(boolean isSelect) {
+        String type = isSelect ? EventTypes.ANNOTATION_SELECTED : EventTypes.ANNOTATION_DESELECTED;
+        LatLng latLng = GeoJSONUtils.toLatLng(mCoordinate);
+        PointF screenPos = getScreenPosition(latLng);
+        return new PointAnnotationClickEvent(this, latLng, screenPos, type);
+    }
+
+    private PointAnnotationDragEvent makeDragEvent(String type) {
+        LatLng latLng = GeoJSONUtils.toLatLng(mCoordinate);
+        PointF screenPos = getScreenPosition(latLng);
+        return new PointAnnotationDragEvent(this, latLng, screenPos, type);
+    }
+
+    private float getDisplayDensity() {
+        return mContext.getResources().getDisplayMetrics().density;
+    }
+
+    private PointF getScreenPosition(LatLng latLng) {
+        PointF screenPos = mMap.getProjection().toScreenLocation(latLng);
+        float density = getDisplayDensity();
+        screenPos.x /= density;
+        screenPos.y /= density;
+        return screenPos;
+    }
+
+    public void refresh() {
+        if (mChildView != null) {
+            refreshBitmap(mChildView);
+        }
+    }
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/annotation/RCTMGLPointAnnotationManager.java

@@ -0,0 +1,88 @@
+package com.mapbox.rctmgl.components.annotation;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.MapBuilder;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+import com.mapbox.rctmgl.components.AbstractEventEmitter;
+import com.mapbox.rctmgl.events.constants.EventKeys;
+import com.mapbox.rctmgl.utils.GeoJSONUtils;
+
+import java.util.Map;
+
+/**
+ * Created by nickitaliano on 9/27/17.
+ */
+
+public class RCTMGLPointAnnotationManager extends AbstractEventEmitter<RCTMGLPointAnnotation> {
+    public static final String REACT_CLASS = "RCTMGLPointAnnotation";
+
+    public RCTMGLPointAnnotationManager(ReactApplicationContext reactApplicationContext) {
+        super(reactApplicationContext);
+    }
+
+    @Override
+    public Map<String, String> customEvents() {
+        return MapBuilder.<String, String>builder()
+                .put(EventKeys.POINT_ANNOTATION_SELECTED, "onMapboxPointAnnotationSelected")
+                .put(EventKeys.POINT_ANNOTATION_DESELECTED, "onMapboxPointAnnotationDeselected")
+                .put(EventKeys.POINT_ANNOTATION_DRAG_START, "onMapboxPointAnnotationDragStart")
+                .put(EventKeys.POINT_ANNOTATION_DRAG, "onMapboxPointAnnotationDrag")
+                .put(EventKeys.POINT_ANNOTATION_DRAG_END, "onMapboxPointAnnotationDragEnd")
+                .build();
+    }
+
+    //region React Methods
+    public static final int METHOD_REFRESH = 2;
+
+    @Nullable
+    @Override
+    public Map<String, Integer> getCommandsMap() {
+        return MapBuilder.<String, Integer>builder()
+                .put("refresh", METHOD_REFRESH)
+                .build();
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @Override
+    protected RCTMGLPointAnnotation createViewInstance(ThemedReactContext reactContext) {
+        return new RCTMGLPointAnnotation(reactContext, this);
+    }
+
+    @ReactProp(name="id")
+    public void setId(RCTMGLPointAnnotation annotation, String id) {
+        annotation.setID(id);
+    }
+
+    @ReactProp(name="coordinate")
+    public void setCoordinate(RCTMGLPointAnnotation annotation, String geoJSONStr) {
+        annotation.setCoordinate(GeoJSONUtils.toPointGeometry(geoJSONStr));
+    }
+
+    @ReactProp(name="anchor")
+    public void setAnchor(RCTMGLPointAnnotation annotation, ReadableMap map) {
+        annotation.setAnchor((float) map.getDouble("x"), (float) map.getDouble("y"));
+    }
+
+    @ReactProp(name="draggable")
+    public void setDraggable(RCTMGLPointAnnotation annotation, Boolean draggable) {
+        annotation.setDraggable(draggable);
+    }
+
+    @Override
+    public void receiveCommand(RCTMGLPointAnnotation annotation, int commandID, @Nullable ReadableArray args) {
+        switch (commandID) {
+            case METHOD_REFRESH:
+                annotation.refresh();
+                break;
+        }
+    }
+}

package/android/rctmgl/src/main/java-mapboxgl/common/com/mapbox/rctmgl/components/camera/CameraStop.java

@@ -0,0 +1,249 @@
+package com.mapbox.rctmgl.components.camera;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+import android.util.DisplayMetrics;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.mapbox.geojson.FeatureCollection;
+import com.mapbox.geojson.Point;
+import com.mapbox.mapboxsdk.camera.CameraPosition;
+import com.mapbox.mapboxsdk.camera.CameraUpdate;
+import com.mapbox.mapboxsdk.camera.CameraUpdateFactory;
+import com.mapbox.mapboxsdk.geometry.LatLng;
+import com.mapbox.mapboxsdk.geometry.LatLngBounds;
+import com.mapbox.mapboxsdk.maps.MapboxMap;
+import com.mapbox.rctmgl.components.camera.constants.CameraMode;
+import com.mapbox.rctmgl.utils.GeoJSONUtils;
+
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView;
+
+/**
+ * Created by nickitaliano on 9/5/17.
+ */
+
+public class CameraStop {
+    private Double mBearing;
+    private Double mTilt;
+    private Double mZoom;
+    private LatLng mLatLng;
+
+    private LatLngBounds mBounds;
+    private int mPaddingLeft = 0;
+    private int mPaddingRight = 0;
+    private int mPaddingBottom = 0;
+    private int mPaddingTop = 0;
+
+    private int mMode = CameraMode.EASE;
+    private int mDuration = 2000;
+    private MapboxMap.CancelableCallback mCallback;
+
+    public CameraStop() {
+    }
+
+    public void setBearing(double bearing) {
+        mBearing = bearing;
+    }
+
+    public void setTilt(double tilt) {
+        mTilt = tilt;
+    }
+
+    public void setZoom(double zoom) {
+        mZoom = zoom;
+    }
+
+    public void setLatLng(LatLng latLng) {
+        mLatLng = latLng;
+    }
+
+    public void setDuration(int duration) {
+        mDuration = duration;
+    }
+
+    public void setCallback(MapboxMap.CancelableCallback callback) {
+        mCallback = callback;
+    }
+
+    public void setBounds(LatLngBounds bounds) {
+        mBounds = bounds;
+    }
+
+    public void setPadding(int paddingLeft, int paddingRight, int paddingTop, int paddingBottom) {
+        mPaddingLeft = paddingLeft;
+        mPaddingRight = paddingRight;
+        mPaddingTop = paddingTop;
+        mPaddingBottom = paddingBottom;
+    }
+
+    public void setMode(@CameraMode.Mode int mode) {
+        mMode = mode;
+    }
+
+    public CameraUpdateItem toCameraUpdate(RCTMGLMapView mapView) {
+        MapboxMap map = mapView.getMapboxMap();
+        CameraPosition currentCamera = map.getCameraPosition();
+        CameraPosition.Builder builder = new CameraPosition.Builder(currentCamera);
+
+        // Adding map padding to the camera padding which is the same behavior as
+        // mapbox native does on iOS
+        double[] contentInset = mapView.getContentInset();
+
+        int paddingLeft = Double.valueOf(contentInset[0] + mPaddingLeft).intValue();
+        int paddingTop = Double.valueOf(contentInset[1] + mPaddingTop).intValue();
+        int paddingRight = Double.valueOf(contentInset[2] + mPaddingRight).intValue();
+        int paddingBottom = Double.valueOf(contentInset[3] + mPaddingBottom).intValue();
+
+        int[] cameraPadding = {paddingLeft, paddingTop, paddingRight, paddingBottom};
+        int[] cameraPaddingClipped = clippedPadding(cameraPadding, mapView);
+
+        boolean hasSetZoom = false;
+
+        if (mLatLng != null) {
+            builder.target(mLatLng);
+            builder.padding(
+                cameraPaddingClipped[0],
+                cameraPaddingClipped[1],
+                cameraPaddingClipped[2],
+                cameraPaddingClipped[3]
+            );
+        } else if (mBounds != null) {
+            double tilt = mTilt != null ? mTilt : currentCamera.tilt;
+            double bearing = mBearing != null ? mBearing : currentCamera.bearing;
+
+            CameraPosition boundsCamera = map.getCameraForLatLngBounds(mBounds, cameraPaddingClipped, bearing, tilt);
+            if (boundsCamera != null) {
+                builder.target(boundsCamera.target);
+                builder.zoom(boundsCamera.zoom);
+                builder.padding(boundsCamera.padding);
+            } else {
+                CameraUpdate update = CameraUpdateFactory.newLatLngBounds(
+                    mBounds,
+                    cameraPaddingClipped[0],
+                    cameraPaddingClipped[1],
+                    cameraPaddingClipped[2],
+                    cameraPaddingClipped[3]
+                );
+                return new CameraUpdateItem(map, update, mDuration, mCallback, mMode);
+            }
+            hasSetZoom = true;
+        }
+
+        if (mBearing != null) {
+            builder.bearing(mBearing);
+        }
+
+        if (mTilt != null) {
+            builder.tilt(mTilt);
+        }
+
+        if (mZoom != null && !hasSetZoom) {
+            builder.zoom(mZoom);
+        }
+
+        return new CameraUpdateItem(map, CameraUpdateFactory.newCameraPosition(builder.build()), mDuration, mCallback, mMode);
+    }
+
+    public static CameraStop fromReadableMap(Context context, @NonNull ReadableMap readableMap, MapboxMap.CancelableCallback callback) {
+        CameraStop stop = new CameraStop();
+
+        if (readableMap.hasKey("pitch")) {
+            stop.setTilt(readableMap.getDouble("pitch"));
+        }
+
+        if (readableMap.hasKey("heading")) {
+            stop.setBearing(readableMap.getDouble("heading"));
+        }
+
+        int paddingTop = getPaddingByKey(readableMap, "paddingTop");
+        int paddingRight = getPaddingByKey(readableMap, "paddingRight");
+        int paddingBottom = getPaddingByKey(readableMap, "paddingBottom");
+        int paddingLeft = getPaddingByKey(readableMap, "paddingLeft");
+
+        // scale padding by pixel ratio
+        DisplayMetrics metrics = context.getResources().getDisplayMetrics();
+        paddingTop = Float.valueOf(paddingTop * metrics.scaledDensity).intValue();
+        paddingRight = Float.valueOf(paddingRight * metrics.scaledDensity).intValue();
+        paddingBottom = Float.valueOf(paddingBottom * metrics.scaledDensity).intValue();
+        paddingLeft = Float.valueOf(paddingLeft * metrics.scaledDensity).intValue();
+
+        stop.setPadding(
+                paddingLeft,
+                paddingRight,
+                paddingTop,
+                paddingBottom
+        );
+
+        if (readableMap.hasKey("centerCoordinate")) {
+            Point target = GeoJSONUtils.toPointGeometry(readableMap.getString("centerCoordinate"));
+            stop.setLatLng(GeoJSONUtils.toLatLng(target));
+        }
+
+        if (readableMap.hasKey("zoom")) {
+            stop.setZoom(readableMap.getDouble("zoom"));
+        }
+
+        if (readableMap.hasKey("duration")) {
+            stop.setDuration(readableMap.getInt("duration"));
+        }
+
+        if (readableMap.hasKey("bounds")) {
+            FeatureCollection collection = FeatureCollection.fromJson(readableMap.getString("bounds"));
+            stop.setBounds(GeoJSONUtils.toLatLngBounds(collection));
+        }
+
+        if (readableMap.hasKey("mode")) {
+            switch (readableMap.getInt("mode")) {
+                case CameraMode.FLIGHT:
+                    stop.setMode(CameraMode.FLIGHT);
+                    break;
+                case CameraMode.LINEAR:
+                    stop.setMode(CameraMode.LINEAR);
+                    break;
+                case CameraMode.NONE:
+                    stop.setMode(CameraMode.NONE);
+                    break;
+                default:
+                    stop.setMode(CameraMode.EASE);
+            }
+        }
+
+        stop.setCallback(callback);
+        return stop;
+    }
+
+    private static int[] clippedPadding(int[] padding, RCTMGLMapView mapView) {
+        int mapHeight = mapView.getHeight();
+        int mapWidth = mapView.getWidth();
+
+        int left = padding[0];
+        int top = padding[1];
+        int right = padding[2];
+        int bottom = padding[3];
+
+        int resultLeft = left;
+        int resultTop = top;
+        int resultRight = right;
+        int resultBottom = bottom;
+
+        if (top + bottom >= mapHeight) {
+            double totalPadding = top + bottom;
+            double extra = totalPadding - mapHeight + 1.0; // add 1 to compensate for floating point math
+            resultTop -= (top * extra) / totalPadding;
+            resultBottom -= (bottom * extra) / totalPadding;
+        }
+
+        if (left + right >= mapWidth) {
+            double totalPadding = left + right;
+            double extra = totalPadding - mapWidth + 1.0; // add 1 to compensate for floating point math
+            resultLeft -= (left * extra) / totalPadding;
+            resultRight -= (right * extra) / totalPadding;
+        }
+
+        return new int[] {resultLeft, resultTop, resultRight, resultBottom};
+    }
+
+    private static int getPaddingByKey(ReadableMap map, String key) {
+        return map.hasKey(key) ? map.getInt(key) : 0;
+    }
+}