@rnmapbox/maps 10.0.0-beta.28

package/android/rctmgl/src/main/java-v10/com/mapbox/rctmgl/components/annotation/RCTMGLPointAnnotation.kt

@@ -0,0 +1,313 @@
+package com.mapbox.rctmgl.components.annotation
+
+import android.content.Context
+import android.graphics.Bitmap
+import com.mapbox.rctmgl.components.AbstractMapFeature
+import com.mapbox.maps.plugin.annotation.generated.PointAnnotation
+import com.mapbox.maps.MapboxMap
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.rctmgl.components.annotation.RCTMGLCallout
+import com.mapbox.rctmgl.utils.GeoJSONUtils
+import com.mapbox.rctmgl.events.constants.EventTypes
+import com.mapbox.maps.plugin.annotation.generated.PointAnnotationOptions
+import com.mapbox.maps.plugin.annotation.generated.PointAnnotationManager
+import com.mapbox.rctmgl.components.annotation.RCTMGLPointAnnotation
+import com.mapbox.maps.extension.style.layers.properties.generated.IconAnchor
+import com.mapbox.rctmgl.events.PointAnnotationClickEvent
+import android.graphics.PointF
+import android.view.View
+import com.mapbox.geojson.Point
+import com.mapbox.maps.ScreenCoordinate
+import com.mapbox.maps.Style
+import com.mapbox.rctmgl.events.PointAnnotationDragEvent
+import com.mapbox.rctmgl.utils.BitmapUtils
+import com.mapbox.rctmgl.utils.LatLng
+import java.util.*
+
+class RCTMGLPointAnnotation(private val mContext: Context, private val mManager: RCTMGLPointAnnotationManager) : AbstractMapFeature(mContext), View.OnLayoutChangeListener {
+    var marker: PointAnnotation? = null
+        private set
+    private var mMap: MapboxMap? = null
+    private var mMapView: RCTMGLMapView? = null
+    private val mHasChildren = false
+    private var mCoordinate: Point? = null
+    var iD: String? = null
+    private val mTitle: String? = null
+    private val mSnippet: String? = null
+    private var mAnchor: Array<Float>? = null
+    private val mIsSelected = false
+    private var mDraggable = false
+    private var mChildView: View? = null
+    private var mChildBitmap: Bitmap? = null
+    private var mChildBitmapId: String? = null
+    var calloutView: View? = null
+        private set
+    private var mCalloutSymbol: PointAnnotation? = null
+    private var mCalloutBitmap: Bitmap? = null
+    private var mCalloutBitmapId: String? = null
+    override fun addView(childView: View, childPosition: Int) {
+        if (childView is RCTMGLCallout) {
+            calloutView = childView
+        } else {
+            mChildView = childView
+        }
+        childView.addOnLayoutChangeListener(this)
+
+        mMapView?.offscreenAnnotationViewContainer()?.addView(childView)
+
+    }
+
+    override fun removeView(childView: View) {
+        if (mChildView != null) {
+            mMap?.getStyle(object : Style.OnStyleLoaded {
+                override fun onStyleLoaded(style: Style) {
+                    mChildBitmapId?.let { style.removeStyleImage(it) }
+                    mChildView = null
+                    calloutView = null
+                    mChildBitmap = null
+                    mChildBitmapId = null
+                    updateOptions()
+                }
+            })
+        }
+        mMapView?.offscreenAnnotationViewContainer()?.removeView(childView)
+    }
+
+    override fun addToMap(mapView: RCTMGLMapView) {
+        mMapView = mapView
+        mMap = mapView.getMapboxMap()
+        makeMarker()
+        if (mChildView != null) {
+            if (!mChildView!!.isAttachedToWindow) {
+                mMapView!!.offscreenAnnotationViewContainer().addView(mChildView)
+            }
+            addBitmapToStyle(mChildBitmap, mChildBitmapId)
+            updateOptions()
+        }
+        if (calloutView != null) {
+            if (!calloutView!!.isAttachedToWindow && mMapView != null) {
+                mMapView!!.offscreenAnnotationViewContainer().addView(calloutView)
+            }
+            addBitmapToStyle(mCalloutBitmap, mCalloutBitmapId)
+        }
+    }
+
+    override fun removeFromMap(mapView: RCTMGLMapView) {
+        val map = (if (mMapView != null) mMapView else mapView) ?: return
+        if (marker != null) {
+            map.pointAnnotationManager?.delete(marker!!)
+        }
+        if (mChildView != null) {
+            map.offscreenAnnotationViewContainer().removeView(mChildView)
+        }
+        if (calloutView != null) {
+            map.offscreenAnnotationViewContainer().removeView(calloutView)
+        }
+    }
+
+    override fun onLayoutChange(v: View, left: Int, top: Int, right: Int, bottom: Int, oldLeft: Int, oldTop: Int,
+                                oldRight: Int, oldBottom: Int) {
+        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 fun refreshBitmap(v: View, left: Int = v.left, top: Int = v.top, right: Int = v.right, bottom: Int = v.bottom) {
+        val bitmap = BitmapUtils.viewToBitmap(v, left, top, right, bottom)
+        val bitmapId = Integer.toString(v.id)
+        addBitmapToStyle(bitmap, bitmapId)
+        if (v is RCTMGLCallout) {
+            mCalloutBitmap = bitmap
+            mCalloutBitmapId = bitmapId
+        } else {
+            if (bitmap != null) {
+                mChildBitmap = bitmap
+                mChildBitmapId = bitmapId
+                updateOptions()
+            }
+        }
+    }
+
+    val latLng: LatLng?
+        get() = mCoordinate?.let { GeoJSONUtils.toLatLng(it) }
+    val mapboxID: Long
+        get() = if (marker == null) -1 else marker!!.id
+
+    fun setCoordinate(point: Point) {
+        mCoordinate = point
+        if (marker != null) {
+            marker!!.point = point
+            mMapView?.pointAnnotationManager?.update(marker!!)
+        }
+        if (mCalloutSymbol != null) {
+            mCalloutSymbol!!.point = point
+            mMapView?.pointAnnotationManager?.update(mCalloutSymbol!!)
+        }
+    }
+
+    fun setAnchor(x: Float, y: Float) {
+        mAnchor = arrayOf(x, y)
+        if (marker != null) {
+            updateAnchor()
+            mMapView?.pointAnnotationManager?.update(marker!!)
+        }
+    }
+
+    fun setDraggable(draggable: Boolean) {
+        mDraggable = draggable
+        if (marker != null) {
+            marker!!.isDraggable = draggable
+            mMapView?.pointAnnotationManager?.update(marker!!)
+        }
+    }
+
+    fun onSelect(shouldSendEvent: Boolean) {
+        if (calloutView != null) {
+            makeCallout()
+        }
+        if (shouldSendEvent) {
+            mManager.handleEvent(makeEvent(true))
+        }
+    }
+
+    fun onDeselect() {
+        mManager.handleEvent(makeEvent(false))
+        if (mCalloutSymbol != null) {
+            mMapView?.pointAnnotationManager?.delete(mCalloutSymbol!!)
+        }
+    }
+
+    fun onDragStart() {
+        mCoordinate = marker!!.point
+        mManager.handleEvent(makeDragEvent(EventTypes.ANNOTATION_DRAG_START))
+    }
+
+    fun onDrag() {
+        mCoordinate = marker!!.point
+        mManager.handleEvent(makeDragEvent(EventTypes.ANNOTATION_DRAG))
+    }
+
+    fun onDragEnd() {
+        mCoordinate = marker!!.point
+        mManager.handleEvent(makeDragEvent(EventTypes.ANNOTATION_DRAG_END))
+    }
+
+    fun makeMarker() {
+        val options = mCoordinate?.let {
+            PointAnnotationOptions()
+                .withPoint(it)
+                .withDraggable(mDraggable)
+                .withIconSize(1.0)
+                .withSymbolSortKey(10.0)
+        }
+        val symbolManager = mMapView?.pointAnnotationManager
+        if (symbolManager != null && options != null) {
+            marker = symbolManager.create(options)
+            updateOptions()
+        }
+    }
+
+    private fun updateOptions() {
+        if (marker != null) {
+            updateIconImage()
+            updateAnchor()
+            mMapView?.pointAnnotationManager?.update(marker!!)
+        }
+    }
+
+    private fun updateIconImage() {
+        if (mChildView != null) {
+            if (mChildBitmapId != null) {
+                marker?.iconImage = mChildBitmapId
+            }
+        } else {
+            marker?.iconImage = MARKER_IMAGE_ID
+            marker?.iconAnchor = IconAnchor.BOTTOM
+        }
+    }
+
+    private fun updateAnchor() {
+        if (mAnchor != null && mChildView != null && mChildBitmap != null && marker != null) {
+            var w = mChildBitmap!!.width
+            var h = mChildBitmap!!.height
+            val scale = resources.displayMetrics.density
+            w = (w / scale).toInt()
+            h = (h / scale).toInt()
+            marker?.iconAnchor = IconAnchor.TOP_LEFT
+            marker?.iconOffset = Arrays.asList(w.toDouble() * mAnchor!![0] * -1.0, h.toDouble() * mAnchor!![1] * -1.0)
+        }
+    }
+
+    private fun makeCallout() {
+        var yOffset = -28f
+        if (mChildView != null) {
+            if (mChildBitmap != null) {
+                val scale = resources.displayMetrics.density
+                var h = mChildBitmap!!.height / 2
+                h = (h / scale).toInt()
+                yOffset = h.toFloat() * -1
+            }
+        }
+        val options = mCoordinate?.let {
+            mCalloutBitmapId?.let { _mCalloutBitmapId ->
+                PointAnnotationOptions()
+                    .withPoint(it)
+                    .withIconImage(_mCalloutBitmapId)
+                    .withIconSize(1.0)
+                    .withIconAnchor(IconAnchor.BOTTOM)
+                    .withIconOffset(Arrays.asList(0.0, yOffset.toDouble()))
+                    .withSymbolSortKey(11.0)
+                    .withDraggable(false)
+            }
+        }
+        val symbolManager = mMapView?.pointAnnotationManager
+        if (symbolManager != null && options != null) {
+            mCalloutSymbol = symbolManager.create(options)
+        }
+    }
+
+    private fun addBitmapToStyle(bitmap: Bitmap?, bitmapId: String?) {
+        if (mMap != null && bitmapId != null && bitmap != null) {
+            mMap!!.getStyle(object : Style.OnStyleLoaded {
+                override fun onStyleLoaded(style: Style) {
+                    style.addImage(bitmapId, bitmap)
+                }
+            })
+        }
+    }
+
+    private fun makeEvent(isSelect: Boolean): PointAnnotationClickEvent {
+        val type = if (isSelect) EventTypes.ANNOTATION_SELECTED else EventTypes.ANNOTATION_DESELECTED
+        val latLng = GeoJSONUtils.toLatLng(mCoordinate!!)
+        val screenPos = getScreenPosition(latLng)
+        return PointAnnotationClickEvent(this, latLng, ScreenCoordinate(screenPos.x.toDouble(), screenPos.y.toDouble()), type)
+    }
+
+    private fun makeDragEvent(type: String): PointAnnotationDragEvent {
+        val latLng = GeoJSONUtils.toLatLng(mCoordinate!!)
+        val screenPos = getScreenPosition(latLng)
+        return PointAnnotationDragEvent(this, latLng, screenPos, type)
+    }
+
+    private val displayDensity: Float
+        private get() = mContext.resources.displayMetrics.density
+
+    private fun getScreenPosition(latLng: LatLng): PointF {
+        val screenPos = mMap!!.pixelForCoordinate(latLng.point)
+        val density = displayDensity
+        return PointF((screenPos.x / density).toFloat(), (screenPos.y / density).toFloat())
+    }
+
+    fun refresh() {
+        if (mChildView != null) {
+            refreshBitmap(mChildView!!)
+        }
+    }
+
+    companion object {
+        private const val MARKER_IMAGE_ID = "MARKER_IMAGE_ID"
+    }
+}

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

@@ -0,0 +1,84 @@
+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;
+
+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-v10/com/mapbox/rctmgl/components/camera/CameraStop.kt

@@ -0,0 +1,228 @@
+package com.mapbox.rctmgl.components.camera
+
+import android.animation.Animator
+import android.content.Context
+import com.mapbox.maps.MapView
+import com.mapbox.maps.MapboxMap
+import com.mapbox.rctmgl.utils.GeoJSONUtils.toPointGeometry
+import com.mapbox.rctmgl.utils.GeoJSONUtils.toLatLng
+import com.mapbox.rctmgl.utils.GeoJSONUtils.toLatLngBounds
+import com.mapbox.rctmgl.utils.LatLngBounds
+import com.mapbox.rctmgl.components.mapview.RCTMGLMapView
+import com.mapbox.rctmgl.components.camera.CameraUpdateItem
+import com.mapbox.maps.CameraState
+import com.mapbox.maps.CameraOptions
+import com.mapbox.rctmgl.components.camera.CameraStop
+import com.facebook.react.bridge.ReadableMap
+import com.mapbox.rctmgl.utils.GeoJSONUtils
+import android.util.DisplayMetrics
+import com.mapbox.geojson.FeatureCollection
+import com.mapbox.maps.EdgeInsets
+import com.mapbox.rctmgl.components.camera.constants.CameraMode
+import com.mapbox.rctmgl.utils.LatLng
+
+/*
+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;
+ */   class CameraStop {
+    private var mBearing: Double? = null
+    private var mTilt: Double? = null
+    private var mZoom: Double? = null
+    private var mLatLng: LatLng? = null
+    private var mBounds: LatLngBounds? = null
+    private var mBoundsPaddingLeft = 0
+    private var mBoundsPaddingRight = 0
+    private var mBoundsPaddingBottom = 0
+    private var mBoundsPaddingTop = 0
+    private var mMode = CameraMode.EASE
+    private var mDuration = 2000
+    private var mCallback: Animator.AnimatorListener? = null
+    fun setBearing(bearing: Double) {
+        mBearing = bearing
+    }
+
+    fun setTilt(tilt: Double) {
+        mTilt = tilt
+    }
+
+    fun setZoom(zoom: Double) {
+        mZoom = zoom
+    }
+
+    fun setLatLng(latLng: LatLng?) {
+        mLatLng = latLng
+    }
+
+    fun setDuration(duration: Int) {
+        mDuration = duration
+    }
+
+    fun setCallback(callback: Animator.AnimatorListener?) {
+        mCallback = callback
+    }
+
+    fun setBounds(
+        bounds: LatLngBounds?,
+        paddingLeft: Int,
+        paddingRight: Int,
+        paddingTop: Int,
+        paddingBottom: Int
+    ) {
+        mBounds = bounds
+        mBoundsPaddingLeft = paddingLeft
+        mBoundsPaddingRight = paddingRight
+        mBoundsPaddingTop = paddingTop
+        mBoundsPaddingBottom = paddingBottom
+    }
+
+    fun setMode(@CameraMode.Mode mode: Int) {
+        mMode = mode
+    }
+
+    fun convert(value: IntArray): EdgeInsets {
+        return EdgeInsets(
+            value[0].toDouble(), value[1].toDouble(), value[2].toDouble(), value[3].toDouble()
+        )
+    }
+
+    fun toCameraUpdate(mapView: RCTMGLMapView): CameraUpdateItem {
+        val map = mapView.getMapboxMap()
+        val currentCamera = map.cameraState
+        val builder = CameraOptions.Builder()
+        builder.center(currentCamera.center)
+        builder.bearing(currentCamera.bearing)
+        builder.padding(currentCamera.padding)
+        builder.zoom(currentCamera.zoom)
+        if (mBearing != null) {
+            builder.bearing(mBearing)
+        }
+        if (mTilt != null) {
+            builder.pitch(mTilt)
+        }
+        if (mLatLng != null) {
+            builder.center(mLatLng!!.point)
+        } else if (mBounds != null) {
+            val tilt = if (mTilt != null) mTilt!! else currentCamera.pitch
+            val bearing = if (mBearing != null) mBearing!! else currentCamera.bearing
+
+            // Adding map padding to the camera padding which is the same behavior as
+            // mapbox native does on iOS
+            val contentInset = map.cameraState.padding
+            val paddingLeft =
+                java.lang.Double.valueOf(contentInset.left + mBoundsPaddingLeft).toInt()
+            val paddingTop = java.lang.Double.valueOf(contentInset.top + mBoundsPaddingTop).toInt()
+            val paddingRight =
+                java.lang.Double.valueOf(contentInset.right + mBoundsPaddingRight).toInt()
+            val paddingBottom =
+                java.lang.Double.valueOf(contentInset.bottom + mBoundsPaddingBottom).toInt()
+            val cameraPadding = intArrayOf(paddingLeft, paddingTop, paddingRight, paddingBottom)
+            val cameraPaddingClipped = clippedPadding(cameraPadding, mapView)
+            val boundsCamera = map.cameraForCoordinateBounds(
+                mBounds!!.toBounds(),
+                convert(cameraPaddingClipped),
+                bearing,
+                tilt
+            )
+            builder.center(boundsCamera.center)
+            builder.anchor(boundsCamera.anchor)
+            builder.zoom(boundsCamera.zoom)
+            builder.padding(boundsCamera.padding)
+        }
+        if (mZoom != null) {
+            builder.zoom(mZoom)
+        }
+        return CameraUpdateItem(map, builder.build(), mDuration, mCallback, mMode)
+    }
+
+    companion object {
+        @JvmStatic
+        fun fromReadableMap(
+            context: Context,
+            readableMap: ReadableMap,
+            callback: Animator.AnimatorListener?
+        ): CameraStop {
+            val stop = CameraStop()
+            if (readableMap.hasKey("pitch")) {
+                stop.setTilt(readableMap.getDouble("pitch"))
+            }
+            if (readableMap.hasKey("heading")) {
+                stop.setBearing(readableMap.getDouble("heading"))
+            }
+            if (readableMap.hasKey("centerCoordinate")) {
+                val target = toPointGeometry(readableMap.getString("centerCoordinate"))
+                stop.setLatLng(toLatLng(target!!))
+            }
+            if (readableMap.hasKey("zoom")) {
+                stop.setZoom(readableMap.getDouble("zoom"))
+            }
+            if (readableMap.hasKey("duration")) {
+                stop.setDuration(readableMap.getInt("duration"))
+            }
+            if (readableMap.hasKey("bounds")) {
+                var paddingTop = getBoundsPaddingByKey(readableMap, "paddingTop")
+                var paddingRight = getBoundsPaddingByKey(readableMap, "paddingRight")
+                var paddingBottom = getBoundsPaddingByKey(readableMap, "paddingBottom")
+                var paddingLeft = getBoundsPaddingByKey(readableMap, "paddingLeft")
+
+                // scale padding by pixel ratio
+                val metrics = context.resources.displayMetrics
+                paddingTop = java.lang.Float.valueOf(paddingTop * metrics.scaledDensity).toInt()
+                paddingRight = java.lang.Float.valueOf(paddingRight * metrics.scaledDensity).toInt()
+                paddingBottom =
+                    java.lang.Float.valueOf(paddingBottom * metrics.scaledDensity).toInt()
+                paddingLeft = java.lang.Float.valueOf(paddingLeft * metrics.scaledDensity).toInt()
+                val collection = FeatureCollection.fromJson(readableMap.getString("bounds")!!)
+                stop.setBounds(
+                    toLatLngBounds(collection), paddingLeft, paddingRight,
+                    paddingTop, paddingBottom
+                )
+            }
+            if (readableMap.hasKey("mode")) {
+                when (readableMap.getInt("mode")) {
+                    CameraMode.FLIGHT -> stop.setMode(CameraMode.FLIGHT)
+                    CameraMode.LINEAR -> stop.setMode(CameraMode.LINEAR)
+                    CameraMode.NONE -> stop.setMode(CameraMode.NONE)
+                    else -> stop.setMode(CameraMode.EASE)
+                }
+            }
+            stop.setCallback(callback)
+            return stop
+        }
+
+        private fun clippedPadding(padding: IntArray, mapView: RCTMGLMapView): IntArray {
+            val mapHeight = mapView.height
+            val mapWidth = mapView.width
+            val left = padding[0]
+            val top = padding[1]
+            val right = padding[2]
+            val bottom = padding[3]
+            var resultLeft = left
+            var resultTop = top
+            var resultRight = right
+            var resultBottom = bottom
+            if (top + bottom >= mapHeight) {
+                val totalPadding = (top + bottom).toDouble()
+                val extra =
+                    totalPadding - mapHeight + 1.0 // add 1 to compensate for floating point math
+                resultTop -= (top * extra / totalPadding).toInt()
+                resultBottom -= (bottom * extra / totalPadding).toInt()
+            }
+            if (left + right >= mapWidth) {
+                val totalPadding = (left + right).toDouble()
+                val extra =
+                    totalPadding - mapWidth + 1.0 // add 1 to compensate for floating point math
+                resultLeft -= (left * extra / totalPadding).toInt()
+                resultRight -= (right * extra / totalPadding).toInt()
+            }
+            return intArrayOf(resultLeft, resultTop, resultRight, resultBottom)
+        }
+
+        private fun getBoundsPaddingByKey(map: ReadableMap, key: String): Int {
+            return if (map.hasKey(key)) map.getInt(key) else 0
+        }
+    }
+}