Merge "Implement common ImageLoader in SystemUI" into udc-dev am: 0c5af73093 (9b5151b2) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/graphics/ImageLoader.kt

0 → 100644

+493 −0

Original line number	Original line	Diff line number	Diff line
			package com.android.systemui.graphics

			import android.annotation.AnyThread
			import android.annotation.DrawableRes
			import android.annotation.Px
			import android.annotation.SuppressLint
			import android.annotation.WorkerThread
			import android.content.Context
			import android.content.pm.PackageManager
			import android.content.res.Resources
			import android.content.res.Resources.NotFoundException
			import android.graphics.Bitmap
			import android.graphics.ImageDecoder
			import android.graphics.ImageDecoder.DecodeException
			import android.graphics.drawable.AdaptiveIconDrawable
			import android.graphics.drawable.BitmapDrawable
			import android.graphics.drawable.Drawable
			import android.graphics.drawable.Icon
			import android.util.Log
			import android.util.Size
			import androidx.core.content.res.ResourcesCompat
			import com.android.systemui.dagger.SysUISingleton
			import com.android.systemui.dagger.qualifiers.Background
			import java.io.IOException
			import javax.inject.Inject
			import kotlin.math.min
			import kotlinx.coroutines.CoroutineDispatcher
			import kotlinx.coroutines.withContext

			/**
			* Helper class to load images for SystemUI. It allows for memory efficient image loading with size
			* restriction and attempts to use hardware bitmaps when sensible.
			*/
			@SysUISingleton
			class ImageLoader
			@Inject
			constructor(
			private val defaultContext: Context,
			@Background private val backgroundDispatcher: CoroutineDispatcher
			) {

			/** Source of the image data. */
			sealed interface Source

			/**
			* Load image from a Resource ID. If the resource is part of another package or if it requires
			* tinting, pass in a correct [Context].
			*/
			data class Res(@DrawableRes val resId: Int, val context: Context?) : Source {
			constructor(@DrawableRes resId: Int) : this(resId, null)
			}

			/** Load image from a Uri. */
			data class Uri(val uri: android.net.Uri) : Source {
			constructor(uri: String) : this(android.net.Uri.parse(uri))
			}

			/** Load image from a [File]. */
			data class File(val file: java.io.File) : Source {
			constructor(path: String) : this(java.io.File(path))
			}

			/** Load image from an [InputStream]. */
			data class InputStream(val inputStream: java.io.InputStream, val context: Context?) : Source {
			constructor(inputStream: java.io.InputStream) : this(inputStream, null)
			}

			/**
			* Loads passed [Source] on a background thread and returns the [Bitmap].
			*
			* Maximum height and width can be passed as optional parameters - the image decoder will make
			* sure to keep the decoded drawable size within those passed constraints while keeping aspect
			* ratio.
			*
			* @param maxWidth Maximum width of the returned drawable (if able). 0 means no restriction. Set
			* to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param maxHeight Maximum height of the returned drawable (if able). 0 means no restriction.
			* Set to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param allocator Allocator to use for the loaded drawable - one of [ImageDecoder] allocator
			* ints. Use [ImageDecoder.ALLOCATOR_SOFTWARE] to force software bitmap.
			* @return loaded [Bitmap] or `null` if loading failed.
			*/
			@AnyThread
			suspend fun loadBitmap(
			source: Source,
			@Px maxWidth: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			@Px maxHeight: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			allocator: Int = ImageDecoder.ALLOCATOR_DEFAULT
			): Bitmap? =
			withContext(backgroundDispatcher) { loadBitmapSync(source, maxWidth, maxHeight, allocator) }

			/**
			* Loads passed [Source] synchronously and returns the [Bitmap].
			*
			* Maximum height and width can be passed as optional parameters - the image decoder will make
			* sure to keep the decoded drawable size within those passed constraints while keeping aspect
			* ratio.
			*
			* @param maxWidth Maximum width of the returned drawable (if able). 0 means no restriction. Set
			* to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param maxHeight Maximum height of the returned drawable (if able). 0 means no restriction.
			* Set to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param allocator Allocator to use for the loaded drawable - one of [ImageDecoder] allocator
			* ints. Use [ImageDecoder.ALLOCATOR_SOFTWARE] to force software bitmap.
			* @return loaded [Bitmap] or `null` if loading failed.
			*/
			@WorkerThread
			fun loadBitmapSync(
			source: Source,
			@Px maxWidth: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			@Px maxHeight: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			allocator: Int = ImageDecoder.ALLOCATOR_DEFAULT
			): Bitmap? {
			return try {
			loadBitmapSync(
			toImageDecoderSource(source, defaultContext),
			maxWidth,
			maxHeight,
			allocator
			)
			} catch (e: NotFoundException) {
			Log.w(TAG, "Couldn't load resource $source", e)
			null
			}
			}

			/**
			* Loads passed [ImageDecoder.Source] synchronously and returns the drawable.
			*
			* Maximum height and width can be passed as optional parameters - the image decoder will make
			* sure to keep the decoded drawable size within those passed constraints (while keeping aspect
			* ratio).
			*
			* @param maxWidth Maximum width of the returned drawable (if able). 0 means no restriction. Set
			* to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param maxHeight Maximum height of the returned drawable (if able). 0 means no restriction.
			* Set to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param allocator Allocator to use for the loaded drawable - one of [ImageDecoder] allocator
			* ints. Use [ImageDecoder.ALLOCATOR_SOFTWARE] to force software bitmap.
			* @return loaded [Bitmap] or `null` if loading failed.
			*/
			@WorkerThread
			fun loadBitmapSync(
			source: ImageDecoder.Source,
			@Px maxWidth: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			@Px maxHeight: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			allocator: Int = ImageDecoder.ALLOCATOR_DEFAULT
			): Bitmap? {
			return try {
			ImageDecoder.decodeBitmap(source) { decoder, info, _ ->
			configureDecoderForMaximumSize(decoder, info.size, maxWidth, maxHeight)
			decoder.allocator = allocator
			}
			} catch (e: IOException) {
			Log.w(TAG, "Failed to load source $source", e)
			return null
			} catch (e: DecodeException) {
			Log.w(TAG, "Failed to decode source $source", e)
			return null
			}
			}

			/**
			* Loads passed [Source] on a background thread and returns the [Drawable].
			*
			* Maximum height and width can be passed as optional parameters - the image decoder will make
			* sure to keep the decoded drawable size within those passed constraints (while keeping aspect
			* ratio).
			*
			* @param maxWidth Maximum width of the returned drawable (if able). 0 means no restriction. Set
			* to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param maxHeight Maximum height of the returned drawable (if able). 0 means no restriction.
			* Set to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param allocator Allocator to use for the loaded drawable - one of [ImageDecoder] allocator
			* ints. Use [ImageDecoder.ALLOCATOR_SOFTWARE] to force software bitmap.
			* @return loaded [Drawable] or `null` if loading failed.
			*/
			@AnyThread
			suspend fun loadDrawable(
			source: Source,
			@Px maxWidth: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			@Px maxHeight: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			allocator: Int = ImageDecoder.ALLOCATOR_DEFAULT
			): Drawable? =
			withContext(backgroundDispatcher) {
			loadDrawableSync(source, maxWidth, maxHeight, allocator)
			}

			/**
			* Loads passed [Icon] on a background thread and returns the drawable.
			*
			* Maximum height and width can be passed as optional parameters - the image decoder will make
			* sure to keep the decoded drawable size within those passed constraints (while keeping aspect
			* ratio).
			*
			* @param context Alternate context to use for resource loading (for e.g. cross-process use)
			* @param maxWidth Maximum width of the returned drawable (if able). 0 means no restriction. Set
			* to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param maxHeight Maximum height of the returned drawable (if able). 0 means no restriction.
			* Set to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param allocator Allocator to use for the loaded drawable - one of [ImageDecoder] allocator
			* ints. Use [ImageDecoder.ALLOCATOR_SOFTWARE] to force software bitmap.
			* @return loaded [Drawable] or `null` if loading failed.
			*/
			@AnyThread
			suspend fun loadDrawable(
			icon: Icon,
			context: Context = defaultContext,
			@Px maxWidth: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			@Px maxHeight: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			allocator: Int = ImageDecoder.ALLOCATOR_DEFAULT
			): Drawable? =
			withContext(backgroundDispatcher) {
			loadDrawableSync(icon, context, maxWidth, maxHeight, allocator)
			}

			/**
			* Loads passed [Source] synchronously and returns the drawable.
			*
			* Maximum height and width can be passed as optional parameters - the image decoder will make
			* sure to keep the decoded drawable size within those passed constraints (while keeping aspect
			* ratio).
			*
			* @param maxWidth Maximum width of the returned drawable (if able). 0 means no restriction. Set
			* to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param maxHeight Maximum height of the returned drawable (if able). 0 means no restriction.
			* Set to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param allocator Allocator to use for the loaded drawable - one of [ImageDecoder] allocator
			* ints. Use [ImageDecoder.ALLOCATOR_SOFTWARE] to force software bitmap.
			* @return loaded [Drawable] or `null` if loading failed.
			*/
			@WorkerThread
			@SuppressLint("UseCompatLoadingForDrawables")
			fun loadDrawableSync(
			source: Source,
			@Px maxWidth: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			@Px maxHeight: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			allocator: Int = ImageDecoder.ALLOCATOR_DEFAULT
			): Drawable? {
			return try {
			loadDrawableSync(
			toImageDecoderSource(source, defaultContext),
			maxWidth,
			maxHeight,
			allocator
			)
			?:
			// If we have a resource, retry fallback using the "normal" Resource loading system.
			// This will come into effect in cases like trying to load AnimatedVectorDrawable.
			if (source is Res) {
			val context = source.context ?: defaultContext
			ResourcesCompat.getDrawable(context.resources, source.resId, context.theme)
			} else {
			null
			}
			} catch (e: NotFoundException) {
			Log.w(TAG, "Couldn't load resource $source", e)
			null
			}
			}

			/**
			* Loads passed [ImageDecoder.Source] synchronously and returns the drawable.
			*
			* Maximum height and width can be passed as optional parameters - the image decoder will make
			* sure to keep the decoded drawable size within those passed constraints (while keeping aspect
			* ratio).
			*
			* @param maxWidth Maximum width of the returned drawable (if able). 0 means no restriction. Set
			* to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param maxHeight Maximum height of the returned drawable (if able). 0 means no restriction.
			* Set to [DEFAULT_MAX_SAFE_BITMAP_SIZE_PX] by default.
			* @param allocator Allocator to use for the loaded drawable - one of [ImageDecoder] allocator
			* ints. Use [ImageDecoder.ALLOCATOR_SOFTWARE] to force software bitmap.
			* @return loaded [Drawable] or `null` if loading failed.
			*/
			@WorkerThread
			fun loadDrawableSync(
			source: ImageDecoder.Source,
			@Px maxWidth: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			@Px maxHeight: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			allocator: Int = ImageDecoder.ALLOCATOR_DEFAULT
			): Drawable? {
			return try {
			ImageDecoder.decodeDrawable(source) { decoder, info, _ ->
			configureDecoderForMaximumSize(decoder, info.size, maxWidth, maxHeight)
			decoder.allocator = allocator
			}
			} catch (e: IOException) {
			Log.w(TAG, "Failed to load source $source", e)
			return null
			} catch (e: DecodeException) {
			Log.w(TAG, "Failed to decode source $source", e)
			return null
			}
			}

			/** Loads icon drawable while attempting to size restrict the drawable. */
			@WorkerThread
			fun loadDrawableSync(
			icon: Icon,
			context: Context = defaultContext,
			@Px maxWidth: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			@Px maxHeight: Int = DEFAULT_MAX_SAFE_BITMAP_SIZE_PX,
			allocator: Int = ImageDecoder.ALLOCATOR_DEFAULT
			): Drawable? {
			return when (icon.type) {
			Icon.TYPE_URI,
			Icon.TYPE_URI_ADAPTIVE_BITMAP -> {
			val source = ImageDecoder.createSource(context.contentResolver, icon.uri)
			loadDrawableSync(source, maxWidth, maxHeight, allocator)
			}
			Icon.TYPE_RESOURCE -> {
			val resources = resolveResourcesForIcon(context, icon)
			resources?.let {
			loadDrawableSync(
			ImageDecoder.createSource(it, icon.resId),
			maxWidth,
			maxHeight,
			allocator
			)
			}
			// Fallback to non-ImageDecoder load if the attempt failed (e.g. the resource
			// is a Vector drawable which ImageDecoder doesn't support.)
			?: icon.loadDrawable(context)
			}
			Icon.TYPE_BITMAP -> {
			BitmapDrawable(context.resources, icon.bitmap)
			}
			Icon.TYPE_ADAPTIVE_BITMAP -> {
			AdaptiveIconDrawable(null, BitmapDrawable(context.resources, icon.bitmap))
			}
			Icon.TYPE_DATA -> {
			loadDrawableSync(
			ImageDecoder.createSource(icon.dataBytes, icon.dataOffset, icon.dataLength),
			maxWidth,
			maxHeight,
			allocator
			)
			}
			else -> {
			// We don't recognize this icon, just fallback.
			icon.loadDrawable(context)
			}
			}?.let { drawable ->
			// Icons carry tint which we need to propagate down to a Drawable.
			tintDrawable(icon, drawable)
			drawable
			}
			}

			companion object {
			const val TAG = "ImageLoader"

			// 4096 is a reasonable default - most devices will support 4096x4096 texture size for
			// Canvas rendering and by default we SystemUI has no need to render larger bitmaps.
			// This prevents exceptions and crashes if the code accidentally loads larger Bitmap
			// and then attempts to render it on Canvas.
			// It can always be overridden by the parameters.
			const val DEFAULT_MAX_SAFE_BITMAP_SIZE_PX = 4096

			/**
			* This constant signals that ImageLoader shouldn't attempt to resize the passed bitmap in a
			* given dimension.
			*
			* Set both maxWidth and maxHeight to [DO_NOT_RESIZE] if you wish to prevent resizing.
			*/
			const val DO_NOT_RESIZE = 0

			/** Maps [Source] to [ImageDecoder.Source]. */
			private fun toImageDecoderSource(source: Source, defaultContext: Context) =
			when (source) {
			is Res -> {
			val context = source.context ?: defaultContext
			ImageDecoder.createSource(context.resources, source.resId)
			}
			is File -> ImageDecoder.createSource(source.file)
			is Uri -> ImageDecoder.createSource(defaultContext.contentResolver, source.uri)
			is InputStream -> {
			val context = source.context ?: defaultContext
			ImageDecoder.createSource(context.resources, source.inputStream)
			}
			}

			/**
			* This sets target size on the image decoder to conform to the maxWidth / maxHeight
			* parameters. The parameters are chosen to keep the existing drawable aspect ratio.
			*/
			@AnyThread
			private fun configureDecoderForMaximumSize(
			decoder: ImageDecoder,
			imgSize: Size,
			@Px maxWidth: Int,
			@Px maxHeight: Int
			) {
			if (maxWidth == DO_NOT_RESIZE && maxHeight == DO_NOT_RESIZE) {
			return
			}

			if (imgSize.width <= maxWidth && imgSize.height <= maxHeight) {
			return
			}

			// Determine the scale factor for each dimension so it fits within the set constraint
			val wScale =
			if (maxWidth <= 0) {
			1.0f
			} else {
			maxWidth.toFloat() / imgSize.width.toFloat()
			}

			val hScale =
			if (maxHeight <= 0) {
			1.0f
			} else {
			maxHeight.toFloat() / imgSize.height.toFloat()
			}

			// Scale down to the dimension that demands larger scaling (smaller scale factor).
			// Use the same scale for both dimensions to keep the aspect ratio.
			val scale = min(wScale, hScale)
			if (scale < 1.0f) {
			val targetWidth = (imgSize.width * scale).toInt()
			val targetHeight = (imgSize.height * scale).toInt()
			if (Log.isLoggable(TAG, Log.DEBUG)) {
			Log.d(TAG, "Configured image size to $targetWidth x $targetHeight")
			}

			decoder.setTargetSize(targetWidth, targetHeight)
			}
			}

			/**
			* Attempts to retrieve [Resources] class required to load the passed icon. Icons can
			* originate from other processes so we need to make sure we load them from the right
			* package source.
			*
			* @return [Resources] to load the icon drawble or null if icon doesn't carry a resource or
			* the resource package couldn't be resolved.
			*/
			@WorkerThread
			private fun resolveResourcesForIcon(context: Context, icon: Icon): Resources? {
			if (icon.type != Icon.TYPE_RESOURCE) {
			return null
			}

			val resources = icon.resources
			if (resources != null) {
			return resources
			}

			val resPackage = icon.resPackage
			if (
			resPackage == null \|\| resPackage.isEmpty() \|\| context.packageName.equals(resPackage)
			) {
			return context.resources
			}

			if ("android" == resPackage) {
			return Resources.getSystem()
			}

			val pm = context.packageManager
			try {
			val ai =
			pm.getApplicationInfo(
			resPackage,
			PackageManager.MATCH_UNINSTALLED_PACKAGES or
			PackageManager.GET_SHARED_LIBRARY_FILES
			)
			if (ai != null) {
			return pm.getResourcesForApplication(ai)
			} else {
			Log.w(TAG, "Failed to resolve application info for $resPackage")
			}
			} catch (e: PackageManager.NameNotFoundException) {
			Log.w(TAG, "Failed to resolve resource package", e)
			return null
			}
			return null
			}

			/** Applies tinting from [Icon] to the passed [Drawable]. */
			@AnyThread
			private fun tintDrawable(icon: Icon, drawable: Drawable) {
			if (icon.hasTint()) {
			drawable.mutate()
			drawable.setTintList(icon.tintList)
			drawable.setTintBlendMode(icon.tintBlendMode)
			}
			}
			}
			}

packages/SystemUI/tests/res/drawable-nodpi/romainguy_rockaway.jpg

0 → 100644

+405 KiB

Loading image diff...

packages/SystemUI/tests/src/com/android/systemui/graphics/ImageLoaderTest.kt

0 → 100644

+346 −0

File added.

Preview size limit exceeded, changes collapsed.