@rnmapbox/maps 10.0.15 → 10.1.0-beta.11

package/android/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotation.kt

@@ -0,0 +1,315 @@
+package com.rnmapbox.rnmbx.components.annotation
+
+import android.content.Context
+import android.graphics.Bitmap
+import com.rnmapbox.rnmbx.components.AbstractMapFeature
+import com.mapbox.maps.plugin.annotation.generated.PointAnnotation
+import com.mapbox.maps.MapboxMap
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.rnmapbox.rnmbx.components.annotation.RNMBXCallout
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils
+import com.rnmapbox.rnmbx.events.constants.EventTypes
+import com.mapbox.maps.plugin.annotation.generated.PointAnnotationOptions
+import com.mapbox.maps.plugin.annotation.generated.PointAnnotationManager
+import com.rnmapbox.rnmbx.components.annotation.RNMBXPointAnnotation
+import com.mapbox.maps.extension.style.layers.properties.generated.IconAnchor
+import com.rnmapbox.rnmbx.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.rnmapbox.rnmbx.components.RemovalReason
+import com.rnmapbox.rnmbx.events.PointAnnotationDragEvent
+import com.rnmapbox.rnmbx.utils.BitmapUtils
+import com.rnmapbox.rnmbx.utils.LatLng
+import java.util.*
+
+import com.rnmapbox.rnmbx.v11compat.annotation.*;
+
+class RNMBXPointAnnotation(private val mContext: Context, private val mManager: RNMBXPointAnnotationManager) : AbstractMapFeature(mContext), View.OnLayoutChangeListener {
+    var marker: PointAnnotation? = null
+        private set
+    private var mMap: MapboxMap? = 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 RNMBXCallout) {
+            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: RNMBXMapView) {
+        super.addToMap(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: RNMBXMapView, reason: RemovalReason): Boolean {
+        val map = (if (mMapView != null) mMapView else mapView) ?: return true
+        if (marker != null) {
+            map.pointAnnotationManager?.delete(marker!!)
+        }
+        if (mChildView != null) {
+            map.offscreenAnnotationViewContainer?.removeView(mChildView)
+        }
+        if (calloutView != null) {
+            map.offscreenAnnotationViewContainer?.removeView(calloutView)
+        }
+        return super.removeFromMap(mapView, reason)
+    }
+
+    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 RNMBXCallout) {
+            mCalloutBitmap = bitmap
+            mCalloutBitmapId = bitmapId
+        } else {
+            if (bitmap != null) {
+                mChildBitmap = bitmap
+                mChildBitmapId = bitmapId
+                updateOptions()
+            }
+        }
+    }
+
+    val latLng: LatLng?
+        get() = mCoordinate?.let { GeoJSONUtils.toLatLng(it) }
+    val mapboxID: AnnotationID
+        get() = if (marker == null) INVALID_ANNOTATION_ID 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/src/main/java/com/rnmapbox/rnmbx/components/annotation/RNMBXPointAnnotationManager.java

@@ -0,0 +1,84 @@
+package com.rnmapbox.rnmbx.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.rnmapbox.rnmbx.components.AbstractEventEmitter;
+import com.rnmapbox.rnmbx.events.constants.EventKeys;
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils;
+
+import java.util.Map;
+
+public class RNMBXPointAnnotationManager extends AbstractEventEmitter<RNMBXPointAnnotation> {
+    public static final String REACT_CLASS = "RNMBXPointAnnotation";
+
+    public RNMBXPointAnnotationManager(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 RNMBXPointAnnotation createViewInstance(ThemedReactContext reactContext) {
+        return new RNMBXPointAnnotation(reactContext, this);
+    }
+
+    @ReactProp(name="id")
+    public void setId(RNMBXPointAnnotation annotation, String id) {
+        annotation.setID(id);
+    }
+
+    @ReactProp(name="coordinate")
+    public void setCoordinate(RNMBXPointAnnotation annotation, String geoJSONStr) {
+        annotation.setCoordinate(GeoJSONUtils.toPointGeometry(geoJSONStr));
+    }
+
+    @ReactProp(name="anchor")
+    public void setAnchor(RNMBXPointAnnotation annotation, ReadableMap map) {
+        annotation.setAnchor((float) map.getDouble("x"), (float) map.getDouble("y"));
+    }
+
+    @ReactProp(name="draggable")
+    public void setDraggable(RNMBXPointAnnotation annotation, Boolean draggable) {
+        annotation.setDraggable(draggable);
+    }
+
+    @Override
+    public void receiveCommand(RNMBXPointAnnotation annotation, int commandID, @Nullable ReadableArray args) {
+        switch (commandID) {
+            case METHOD_REFRESH:
+                annotation.refresh();
+                break;
+        }
+    }
+}

package/android/src/main/java/com/rnmapbox/rnmbx/components/camera/CameraStop.kt

@@ -0,0 +1,243 @@
+package com.rnmapbox.rnmbx.components.camera
+
+import android.animation.Animator
+import android.content.Context
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils.toPointGeometry
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils.toLatLng
+import com.rnmapbox.rnmbx.utils.GeoJSONUtils.toLatLngBounds
+import com.rnmapbox.rnmbx.utils.LatLngBounds
+import com.rnmapbox.rnmbx.components.mapview.RNMBXMapView
+import com.mapbox.maps.CameraOptions
+import com.facebook.react.bridge.ReadableMap
+import com.mapbox.geojson.FeatureCollection
+import com.mapbox.maps.EdgeInsets
+import com.rnmapbox.rnmbx.components.camera.constants.CameraMode
+import com.rnmapbox.rnmbx.utils.LatLng
+
+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 mPaddingLeft: Int? = null
+    private var mPaddingRight: Int? = null
+    private var mPaddingBottom: Int? = null
+    private var mPaddingTop: Int? = null
+
+    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 setPadding(
+        paddingLeft: Int?,
+        paddingRight: Int?,
+        paddingTop: Int?,
+        paddingBottom: Int?
+    ) {
+        mPaddingLeft = paddingLeft
+        mPaddingRight = paddingRight
+        mPaddingTop = paddingTop
+        mPaddingBottom = paddingBottom
+    }
+
+    fun setBounds(
+        bounds: LatLngBounds?,
+        paddingLeft: Int?,
+        paddingRight: Int?,
+        paddingTop: Int?,
+        paddingBottom: Int?
+    ) {
+        mBounds = bounds
+        this.setPadding(paddingLeft, paddingRight, paddingTop, paddingBottom)
+    }
+
+    fun setMode(@CameraMode.Mode mode: Int) {
+        mMode = mode
+    }
+
+    private fun convert(value: IntArray): EdgeInsets {
+        val left = value[0].toDouble()
+        val top = value[1].toDouble()
+        val right = value[2].toDouble()
+        val bottom = value[3].toDouble()
+        return EdgeInsets(
+            top, left, bottom, right
+        )
+    }
+
+    fun toCameraUpdate(mapView: RNMBXMapView): CameraUpdateItem {
+        val map = mapView.getMapboxMap()
+        val currentCamera = map.cameraState
+        val builder = CameraOptions.Builder()
+        builder.center(currentCamera.center)
+        builder.bearing(currentCamera.bearing)
+
+        val currentPadding = currentCamera.padding
+
+        builder.padding(currentCamera.padding)
+        builder.zoom(currentCamera.zoom)
+        if (mBearing != null) {
+            builder.bearing(mBearing)
+        }
+        if (mTilt != null) {
+            builder.pitch(mTilt)
+        }
+
+        val paddingLeft: Int = mPaddingLeft ?: currentPadding.left.toInt()
+        val paddingTop: Int = mPaddingTop ?: currentPadding.top.toInt()
+        val paddingRight: Int = mPaddingRight ?: currentPadding.right.toInt()
+        val paddingBottom: Int = mPaddingBottom ?: currentPadding.bottom.toInt()
+        val cameraPadding = intArrayOf(paddingLeft, paddingTop, paddingRight, paddingBottom)
+        val cameraPaddingClipped = clippedPadding(cameraPadding, mapView)
+        val cameraPaddingEdgeInsets = convert(cameraPaddingClipped)
+
+        if (mLatLng != null) {
+            builder.center(mLatLng!!.point)
+            builder.padding(cameraPaddingEdgeInsets)
+        } else if (mBounds != null) {
+            val tilt = if (mTilt != null) mTilt!! else currentCamera.pitch
+            val bearing = if (mBearing != null) mBearing!! else currentCamera.bearing
+
+            val boundsCamera = map.cameraForCoordinateBounds(
+                mBounds!!.toBounds(),
+                cameraPaddingEdgeInsets,
+                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"))
+            }
+
+            val metrics = context.resources.displayMetrics
+            val paddingTop = getBoundsPaddingByKey(readableMap, metrics.density, "paddingTop")
+            val paddingRight = getBoundsPaddingByKey(readableMap, metrics.density, "paddingRight")
+            val paddingBottom = getBoundsPaddingByKey(readableMap, metrics.density, "paddingBottom")
+            val paddingLeft = getBoundsPaddingByKey(readableMap, metrics.density, "paddingLeft")
+
+            if (readableMap.hasKey("bounds")) {
+                val collection = FeatureCollection.fromJson(readableMap.getString("bounds")!!)
+                stop.setBounds(
+                    toLatLngBounds(collection), paddingLeft, paddingRight,
+                    paddingTop, paddingBottom
+                )
+            } else {
+                stop.setPadding(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: RNMBXMapView): 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, density: Float, key: String): Int? {
+            return if (map.hasKey(key)) {
+                (map.getInt(key) * density).toInt()
+            } else {
+                null
+            }
+        }
+    }
+}