Method get

valdi/src/java/com/snap/valdi/utils/BitmapPool.kt:91–148

* Returns a bitmap with the desired width and height. * The actual returned bitmap size might be smaller than the requested size. */

     * The actual returned bitmap size might be smaller than the requested size.
     */
    fun get(desiredWidth: Int, desiredHeight: Int): BitmapHandler? {
        if (desiredWidth == 0 || desiredHeight == 0) {
            return null
        }

        val resolvedWidth: Int
        val resolvedHeight: Int

        if (desiredWidth <= maxWidth && desiredHeight <= maxHeight) {
            resolvedWidth = desiredWidth
            resolvedHeight = desiredHeight
        } else {
            val desiredWidthF = desiredWidth.toFloat()
            val desiredHeightF = desiredHeight.toFloat()

            val xRatio = desiredWidthF / maxWidth.toFloat()
            val yRatio = desiredHeightF / maxHeight.toFloat()
            val ratio = max(xRatio, yRatio)

            resolvedWidth = (desiredWidthF / ratio).roundToInt()
            resolvedHeight = (desiredHeightF / ratio).roundToInt()
        }

        var resolvedCachedBitmap: CachedBitmap? = null

        synchronized(cachedBitmaps) {
            val it  = cachedBitmaps.iterator()
            while (it.hasNext()) {
                val cachedBitmap = it.next()

                // TODO(simon): We could leverage reconfigure() to allow re-using buffers which are
                // bigger than the requested size.
                if (cachedBitmap.getBitmap().width == resolvedWidth && cachedBitmap.getBitmap().height == resolvedHeight) {
                    cachedBitmap.retain()

                    it.remove()

                    resolvedCachedBitmap = cachedBitmap

                    break
                }
            }
        }

        if (resolvedCachedBitmap != null) {
            resolvedCachedBitmap!!.prepareForReuse()
            return resolvedCachedBitmap
        }

        return try {
//            logger.info("Allocating bitmap of size ${resolvedWidth}x${resolvedHeight}")
            val bitmap = Bitmap.createBitmap(resolvedWidth, resolvedHeight, bitmapConfig) ?: return null
            CachedBitmap(this, bitmap)
        } catch (exc: OutOfMemoryError) {
            logger.error("Failed to allocate bitmap of size ${resolvedWidth}x${resolvedHeight}: ${exc.message}")
            null
        }
    }