Add image caching to SmallImageCard

code/messaging/src/main/java/com/adobe/marketing/mobile/aepcomposeui/components/SmallImageCard.kt

@@ -33,7 +33,7 @@ import com.adobe.marketing.mobile.aepcomposeui.UIAction
 import com.adobe.marketing.mobile.aepcomposeui.UIEvent
 import com.adobe.marketing.mobile.aepcomposeui.observers.AepUIEventObserver
 import com.adobe.marketing.mobile.aepcomposeui.style.SmallImageUIStyle
-import com.adobe.marketing.mobile.aepcomposeui.utils.UIUtils
+import com.adobe.marketing.mobile.messaging.ContentCardImageManager
 
 /**
  * Composable function that renders a small image card UI.
@@ -58,13 +58,16 @@ fun SmallImageCard(
         if (imageUrl.isNullOrBlank()) {
             isLoading = false
         } else {
-            UIUtils.downloadImage(imageUrl) {
+            val contentCardImageManager = ContentCardImageManager()
+
+            contentCardImageManager.getContentCardImageBitmap(imageUrl) {
                 it.onSuccess { bitmap ->
                     imageBitmap = bitmap
                     isLoading = false
                 }
                 it.onFailure {
-                    // TODO once we have a default image, we can use that here
+                    // todo - confirm default image bitmap to be used here
+                    // imageBitmap = contentCardManager.getDefaultImageBitmap()
                     isLoading = false
                 }
             }

code/messaging/src/main/java/com/adobe/marketing/mobile/messaging/ContentCardImageManager.kt

@@ -0,0 +1,155 @@
+/*
+  Copyright 2024 Adobe. All rights reserved.
+  This file is licensed to you under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License. You may obtain a copy
+  of the License at http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software distributed under
+  the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+  OF ANY KIND, either express or implied. See the License for the specific language
+  governing permissions and limitations under the License.
+*/
+
+package com.adobe.marketing.mobile.messaging
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import com.adobe.marketing.mobile.aepcomposeui.utils.UIUtils
+import com.adobe.marketing.mobile.messaging.MessagingConstants.CONTENT_CARD_CACHE_SUBDIRECTORY
+import com.adobe.marketing.mobile.services.Log
+import com.adobe.marketing.mobile.services.ServiceProvider
+import com.adobe.marketing.mobile.services.caching.CacheEntry
+import com.adobe.marketing.mobile.services.caching.CacheExpiry
+import com.adobe.marketing.mobile.services.caching.CacheResult
+import com.adobe.marketing.mobile.services.caching.CacheService
+import java.io.InputStream
+import java.nio.ByteBuffer
+
+class ContentCardImageManager() {
+    private val SELF_TAG: String = "ContentCardManager"
+    private val cacheService: CacheService? = ServiceProvider.getInstance().cacheService
+    private val defaultCacheName: String = CONTENT_CARD_CACHE_SUBDIRECTORY
+
+    /**
+     * Fetches the image from cache if present in cache, else downloads the image from the given URL and caches it for future calls.
+     *
+     * @param imageUrl the url of the image to be fetched
+     * @param cacheName(optional) the name of the cache for fetching or caching the image, default value used if cache name is not provided
+     * @param completion is a completion callback. Result.success() method is invoked with the image bitmap fetched. In case of any failure, Result.failure() method is invoked with a throwable
+     * */
+    fun getContentCardImageBitmap(imageUrl: String, cacheName: String? = defaultCacheName, completion: (Result<Bitmap>) -> Unit) {
+        val resolvedCacheName: String = cacheName ?: defaultCacheName
+        if (isImageCached(imageUrl, resolvedCacheName)) {
+            getImageBitmapFromCache(imageUrl, resolvedCacheName, completion)
+        } else {
+            downloadAndCacheImageBitmap(imageUrl, resolvedCacheName, completion)
+        }
+    }
+
+    /**
+     * Checks whether the image at given url is present in the cache or not.
+     *
+     * @param imageUrl the url of the image
+     * @param cacheName the name of the cache for fetching or caching the image
+     * @return `True` if the image is found in cache, `False` otherwise
+     * */
+    private fun isImageCached(imageUrl: String, cacheName: String): Boolean {
+        return (cacheService?.get(cacheName, imageUrl) != null)
+    }
+
+    /**
+     * Fetches the image from the cache.
+     *
+     * @param imageUrl the url of the image to be fetched
+     * @param cacheName the name of the cache for fetching the image
+     * @param completion is a completion callback. Result.success() method is invoked with the image bitmap fetched. In case of any failure, Result.failure() method is invoked with a throwable
+     * */
+    private fun getImageBitmapFromCache(imageUrl: String, cacheName: String, completion: (Result<Bitmap>) -> Unit) {
+        val cachedImageBitmap: CacheResult? = cacheService?.get(cacheName, imageUrl)
+        val inputStream = cachedImageBitmap?.data
+
+        // Convert the InputStream to a Bitmap
+        if (inputStream != null) {
+            try {
+                completion(Result.success(BitmapFactory.decodeStream(inputStream)))
+            } catch (e: Exception) {
+                Log.warning(
+                    MessagingConstants.LOG_TAG,
+                    SELF_TAG,
+                    "getImageBitmapFromCache: Unable to read cached data into a bitmap due to error: $e"
+                )
+                completion(Result.failure(e))
+            }
+        } else {
+            Log.warning(
+                MessagingConstants.LOG_TAG,
+                SELF_TAG,
+                "getImageBitmapFromCache: Unable to read cached data as the inputStream is null"
+            )
+            completion(Result.failure(Exception("Unable to read cached bitmap data as the inputStream is null for the url: $imageUrl, cacheName: $cacheName")))
+        }
+    }
+
+    /**
+     * Downloads the image from the given url and caches it.
+     *
+     * @param imageUrl the url of the image to be downloaded
+     * @param completion is a completion callback. Result.success() method is invoked with the image bitmap downloaded. In case of any failure, Result.failure() method is invoked with a throwable
+     * */
+    private fun downloadAndCacheImageBitmap(imageUrl: String, cacheName: String, completion: (Result<Bitmap>) -> Unit) {
+        UIUtils.downloadImage(imageUrl) {
+            it.onSuccess { bitmap ->
+                val isImageCacheSuccessful = cacheImage(bitmap, imageUrl, cacheName)
+                if (!isImageCacheSuccessful) {
+                    Log.warning(
+                        MessagingConstants.LOG_TAG,
+                        SELF_TAG,
+                        "Image downloaded but failed to cache the image from url: $imageUrl"
+                    )
+                }
+                completion(Result.success(bitmap))
+            }
+            it.onFailure { failure ->
+                Log.warning(
+                    MessagingConstants.LOG_TAG,
+                    SELF_TAG,
+                    "Unable to download image from url: $imageUrl"
+                )
+                completion(Result.failure(failure))
+            }
+        }
+    }
+
+    /**
+     * Caches the given image.
+     *
+     * @param imageBitmap image to be cached
+     * @param imageName the unique `key` for storing the image in cache
+     * @param cacheName name of the cache where cache entry is to be created
+     *
+     * @return `True` if image is caches successfully, `False` otherwise
+     * */
+    private fun cacheImage(imageBitmap: Bitmap, imageName: String, cacheName: String): Boolean {
+        try {
+            val imageInputStream: InputStream = imageBitmap.let { bitmap ->
+                val byteArray = ByteArray(bitmap.byteCount)
+                val buffer = ByteBuffer.wrap(byteArray)
+                bitmap.copyPixelsToBuffer(buffer)
+                buffer.rewind() // Reset the buffer position to the beginning
+                byteArray.inputStream() // Create InputStream from byte array
+            }
+
+            val cacheEntry = CacheEntry(imageInputStream, CacheExpiry.never(), null)
+            cacheService?.set(cacheName, imageName, cacheEntry)
+
+            return true
+        } catch (ex: java.lang.Exception) {
+            Log.warning(
+                MessagingConstants.LOG_TAG,
+                SELF_TAG,
+                "cacheImage - An unexpected error occurred while caching the downloaded image: \n %s",
+                ex.localizedMessage
+            )
+            return false
+        }
+    }
+}

code/messaging/src/main/java/com/adobe/marketing/mobile/messaging/MessagingConstants.java

@@ -21,6 +21,8 @@ public final class MessagingConstants {
     static final String CACHE_BASE_DIR = "messaging";
     static final String PROPOSITIONS_CACHE_SUBDIRECTORY = "propositions";
     static final String IMAGES_CACHE_SUBDIRECTORY = "images";
+    static final String CONTENT_CARD_CACHE_SUBDIRECTORY = "contentCardImages";
+    static final String CONTENT_CARD_TEST_CACHE_SUBDIRECTORY = "contentCardTestImages";
     static final String HTTP_HEADER_IF_MODIFIED_SINCE = "If-Modified-Since";
     static final String HTTP_HEADER_LAST_MODIFIED = "Last-Modified";
     static final String HTTP_HEADER_IF_NONE_MATCH = "If-None-Match";

code/messaging/src/test/java/com/adobe/marketing/mobile/messaging/ContentCardImageManagerTests.kt

@@ -0,0 +1,188 @@
+/*
+  Copyright 2025 Adobe. All rights reserved.
+  This file is licensed to you under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License. You may obtain a copy
+  of the License at http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software distributed under
+  the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+  OF ANY KIND, either express or implied. See the License for the specific language
+  governing permissions and limitations under the License.
+*/
+
+package com.adobe.marketing.mobile.messaging
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import com.adobe.marketing.mobile.messaging.MessagingConstants.CONTENT_CARD_TEST_CACHE_SUBDIRECTORY
+import com.adobe.marketing.mobile.services.HttpConnecting
+import com.adobe.marketing.mobile.services.NetworkCallback
+import com.adobe.marketing.mobile.services.Networking
+import com.adobe.marketing.mobile.services.ServiceProvider
+import com.adobe.marketing.mobile.services.caching.CacheExpiry
+import com.adobe.marketing.mobile.services.caching.CacheResult
+import com.adobe.marketing.mobile.services.caching.CacheService
+import org.junit.After
+import org.junit.Before
+import org.junit.runner.RunWith
+import org.mockito.Mock
+import org.mockito.MockedStatic
+import org.mockito.Mockito
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.mockStatic
+import org.mockito.Mockito.`when`
+import org.mockito.MockitoAnnotations
+import org.mockito.kotlin.any
+import org.mockito.kotlin.whenever
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.InputStream
+import java.net.HttpURLConnection
+import kotlin.test.Test
+import kotlin.test.assertNotNull
+import kotlin.test.fail
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [33])
+class ContentCardImageManagerTests {
+
+    @Mock private lateinit var mockCacheService: CacheService
+
+    @Mock
+    private lateinit var mockServiceProvider: ServiceProvider
+    private lateinit var mockedStaticServiceProvider: MockedStatic<ServiceProvider>
+
+    @Mock
+    private lateinit var mockNetworkService: Networking
+
+    private lateinit var contentCardImageManager: ContentCardImageManager
+    private lateinit var testCachePath: String
+    private lateinit var testImageBitmapName: String
+    private val imageUrl = "https://fastly.picsum.photos/id/43/400/300.jpg?hmac=fAPJ5p1wbFahFpnqtg004Nny-vTEADhmMxMkwLUSfw0"
+
+    @Before
+    fun setup() {
+        MockitoAnnotations.openMocks(this)
+        mockedStaticServiceProvider = mockStatic(ServiceProvider::class.java)
+        mockedStaticServiceProvider.`when`<Any> { ServiceProvider.getInstance() }.thenReturn(mockServiceProvider)
+        whenever(mockCacheService.set(any(), any(), any())).thenReturn(true)
+        `when`(mockServiceProvider.networkService).thenReturn(mockNetworkService)
+
+        contentCardImageManager = ContentCardImageManager()
+        testCachePath = CONTENT_CARD_TEST_CACHE_SUBDIRECTORY
+        testImageBitmapName = "sampleBitmapContentCard"
+    }
+
+    @After
+    fun tearDown() {
+        mockedStaticServiceProvider.close()
+        Mockito.validateMockitoUsage()
+    }
+
+    @Test
+    fun get_image_first_time_when_not_in_cache() {
+        // Mocking Cache to bypass cache check
+        whenever(
+            mockCacheService.get(
+                any(),
+                any()
+            )
+        ).thenReturn(null)
+
+        // setup for bitmap download simulation
+        val mockBitmap: Bitmap = mock(Bitmap::class.java)
+        `when`(mockBitmap.width).thenReturn(100)
+        `when`(mockBitmap.height).thenReturn(100)
+
+        val mockedStaticBitmapFactory = mockStatic(BitmapFactory::class.java)
+        mockedStaticBitmapFactory.`when`<Bitmap?> { BitmapFactory.decodeStream(Mockito.any()) }
+            .thenReturn(mockBitmap)
+
+        val simulatedResponse = simulateNetworkResponse(HttpURLConnection.HTTP_OK, bitmapToInputStream(mockBitmap), emptyMap())
+        `when`(mockNetworkService.connectAsync(Mockito.any(), Mockito.any())).thenAnswer {
+            val callback = it.getArgument<NetworkCallback>(1)
+            callback.call(simulatedResponse)
+        }
+
+        contentCardImageManager.getContentCardImageBitmap(
+            imageUrl, testCachePath,
+            {
+                it.onSuccess { bitmap ->
+                    assertNotNull(bitmap)
+                }
+                it.onFailure {
+                    fail("Test failed as unable to fetch image from cache")
+                }
+            }
+        )
+
+        mockedStaticBitmapFactory.close()
+    }
+
+    @Test
+    fun getContentCardImageBitmap_getCachedImage() {
+
+        // setup for bitmap decoding simulation
+        val mockBitmap: Bitmap = mock(Bitmap::class.java)
+        `when`(mockBitmap.width).thenReturn(100)
+        `when`(mockBitmap.height).thenReturn(100)
+
+        val mockedStaticBitmapFactory = mockStatic(BitmapFactory::class.java)
+        mockedStaticBitmapFactory.`when`<Bitmap?> { BitmapFactory.decodeStream(Mockito.any()) }
+            .thenReturn(mockBitmap)
+
+        // Mocking Cache to return a valid cache result
+        whenever(
+            mockCacheService.get(
+                any(),
+                any()
+            )
+        ).thenReturn(object : CacheResult {
+            override fun getData(): InputStream {
+                return bitmapToInputStream(mockBitmap)
+            }
+            override fun getExpiry(): CacheExpiry {
+                return CacheExpiry.never()
+            }
+            override fun getMetadata(): Map<String, String> {
+                return emptyMap()
+            }
+        })
+
+        contentCardImageManager.getContentCardImageBitmap(
+            imageUrl, testCachePath,
+            {
+                it.onSuccess { bitmap ->
+                    assertNotNull(bitmap)
+                }
+                it.onFailure {
+                    fail("Test failed as unable to fetch image from cache")
+                }
+            }
+        )
+
+        mockedStaticBitmapFactory.close()
+    }
+
+    private fun bitmapToInputStream(bitmap: Bitmap): ByteArrayInputStream {
+        val outputStream = ByteArrayOutputStream()
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
+        val byteArray = outputStream.toByteArray()
+        return ByteArrayInputStream(byteArray)
+    }
+
+    private fun simulateNetworkResponse(
+        responseCode: Int,
+        responseStream: InputStream?,
+        metadata: Map<String, String>
+    ): HttpConnecting {
+        val mockResponse = mock(HttpConnecting::class.java)
+        `when`(mockResponse.responseCode).thenReturn(responseCode)
+        `when`(mockResponse.inputStream).thenReturn(responseStream)
+        `when`(mockResponse.getResponsePropertyValue(org.mockito.kotlin.any())).then {
+            return@then metadata[it.getArgument(0)]
+        }
+        return mockResponse
+    }
+}