Introduce in-memory MediaModel cache

WooCommerce-Wear/src/main/java/com/woocommerce/android/wear/di/FluxCModule.kt

@@ -4,6 +4,7 @@ import dagger.Module
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
 import org.wordpress.android.fluxc.di.WCDatabaseModule
+import org.wordpress.android.fluxc.module.MediaModule
 import org.wordpress.android.fluxc.module.OkHttpClientModule
 import org.wordpress.android.fluxc.module.ReleaseNetworkModule
 
@@ -12,7 +13,8 @@ import org.wordpress.android.fluxc.module.ReleaseNetworkModule
     includes = [
         ReleaseNetworkModule::class,
         OkHttpClientModule::class,
-        WCDatabaseModule::class
+        WCDatabaseModule::class,
+        MediaModule::class
     ]
 )
 abstract class FluxCModule

WooCommerce/src/main/kotlin/com/woocommerce/android/di/FluxCModule.kt

@@ -4,6 +4,7 @@ import dagger.Module
 import dagger.hilt.InstallIn
 import dagger.hilt.components.SingletonComponent
 import org.wordpress.android.fluxc.di.WCDatabaseModule
+import org.wordpress.android.fluxc.module.MediaModule
 import org.wordpress.android.fluxc.module.OkHttpClientModule
 import org.wordpress.android.fluxc.module.ReleaseNetworkModule
 
@@ -12,7 +13,8 @@ import org.wordpress.android.fluxc.module.ReleaseNetworkModule
     includes = [
         ReleaseNetworkModule::class,
         OkHttpClientModule::class,
-        WCDatabaseModule::class
+        WCDatabaseModule::class,
+        MediaModule::class
     ]
 )
 abstract class FluxCModule

WooCommerce/src/main/kotlin/com/woocommerce/android/media/FileUploadUtils.kt

@@ -85,15 +85,9 @@ object FileUploadUtils {
             path,
             mimeType,
             filenameWithExtension,
-            null
         )
         val instantiatedMedia = mediaStore.instantiateMediaModel(media)
-        return if (instantiatedMedia != null) {
-            instantiatedMedia
-        } else {
-            WooLog.w(T.MEDIA, "We couldn't instantiate the media")
-            null
-        }
+        return instantiatedMedia
     }
 
     /**

WooCommerce/src/main/kotlin/com/woocommerce/android/media/MediaFilesRepository.kt

@@ -49,7 +49,7 @@ class MediaFilesRepository @Inject constructor(
     private val resourceProvider: ResourceProvider,
     private val mediaPickerUtils: MediaPickerUtils
 ) {
-    suspend fun fetchMedia(localUri: String): MediaModel? {
+    suspend fun getLocalMedia(localUri: String): MediaModel? {
         return withContext(dispatchers.io) {
             val mediaModel = FileUploadUtils.mediaModelFromLocalUri(
                 context,
@@ -120,7 +120,7 @@ class MediaFilesRepository @Inject constructor(
 
     fun uploadFile(localUri: String): Flow<UploadResult> {
         return flow {
-            val mediaModel = fetchMedia(localUri)
+            val mediaModel = getLocalMedia(localUri)
 
             if (mediaModel == null) {
                 WooLog.w(T.MEDIA, "MediaFilesRepository > null media")

WooCommerce/src/main/kotlin/com/woocommerce/android/media/ProductImagesUploadWorker.kt

@@ -2,9 +2,7 @@ package com.woocommerce.android.media
 
 import com.woocommerce.android.di.AppCoroutineScope
 import com.woocommerce.android.media.MediaFilesRepository.UploadResult.*
-import com.woocommerce.android.media.ProductImagesUploadWorker.Event
 import com.woocommerce.android.media.ProductImagesUploadWorker.Event.MediaUploadEvent
-import com.woocommerce.android.media.ProductImagesUploadWorker.Work
 import com.woocommerce.android.model.Product
 import com.woocommerce.android.model.toAppModel
 import com.woocommerce.android.ui.products.details.ProductDetailRepository
@@ -172,7 +170,7 @@ class ProductImagesUploadWorker @Inject constructor(
     private suspend fun fetchMedia(work: Work.FetchMedia) {
         WooLog.d(T.MEDIA, "ProductImagesUploadWorker -> fetch media ${work.localUri}")
 
-        val fetchedMedia = mediaFilesRepository.fetchMedia(work.localUri)
+        val fetchedMedia = mediaFilesRepository.getLocalMedia(work.localUri)
         if (fetchedMedia == null) {
             WooLog.w(T.MEDIA, "ProductImagesUploadWorker -> fetching media failed")
 

WooCommerce/src/test/kotlin/com/woocommerce/android/media/ProductImagesUploadWorkerTest.kt

@@ -35,7 +35,7 @@ import org.mockito.kotlin.never
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
-import org.wordpress.android.fluxc.model.MediaModel
+import org.wordpress.android.fluxc.media.MediaTestUtils
 import org.wordpress.android.fluxc.store.MediaStore.MediaErrorType.GENERIC_ERROR
 import org.wordpress.android.util.DateTimeUtils
 import java.util.Date
@@ -45,20 +45,19 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
     companion object {
         private const val REMOTE_PRODUCT_ID = 1L
         private const val TEST_URI = "test"
-        private val FETCHED_MEDIA = MediaModel(0, 0)
-        private val UPLOADED_MEDIA = MediaModel(0, 0).apply {
-            fileName = ""
-            filePath = ""
-            url = ""
-            uploadDate = DateTimeUtils.iso8601FromDate(Date())
-        }
+        private val FETCHED_MEDIA = MediaTestUtils.createRemoteTestMedia().build()
+        private val UPLOADED_MEDIA = MediaTestUtils.createRemoteTestMedia()
+            .fileName("")
+            .url("")
+            .uploadDate(DateTimeUtils.iso8601FromDate(Date()))
+            .build()
     }
 
     private val notificationHandler: ProductImagesNotificationHandler = mock()
     private val productImagesServiceWrapper: ProductImagesServiceWrapper = mock()
     private lateinit var worker: ProductImagesUploadWorker
     private val mediaFilesRepository: MediaFilesRepository = mock {
-        onBlocking { fetchMedia(TEST_URI) } doReturn FETCHED_MEDIA
+        onBlocking { getLocalMedia(TEST_URI) } doReturn FETCHED_MEDIA
         onBlocking { uploadMedia(any(), any()) } doReturn flowOf(UploadResult.UploadSuccess(UPLOADED_MEDIA))
     }
     private val productDetailRepository: ProductDetailRepository = mock()
@@ -111,7 +110,7 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
         }
         worker.enqueueWork(Work.FetchMedia(REMOTE_PRODUCT_ID, TEST_URI))
 
-        verify(mediaFilesRepository).fetchMedia(TEST_URI)
+        verify(mediaFilesRepository).getLocalMedia(TEST_URI)
         assertThat(eventsList[0]).isEqualTo(FetchSucceeded(REMOTE_PRODUCT_ID, TEST_URI, FETCHED_MEDIA))
         job.cancel()
     }
@@ -122,7 +121,9 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
         val job = launch {
             worker.events.toList(eventsList)
         }
-        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaModel(0, 0)))
+        worker.enqueueWork(
+            Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaTestUtils.createRemoteTestMedia().build())
+        )
 
         advanceUntilIdle()
         verify(mediaFilesRepository).uploadMedia(any(), any())
@@ -133,9 +134,11 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
     @Test
     fun `when media upload progress changes, then update notification`() = testBlocking {
         whenever(mediaFilesRepository.uploadMedia(any(), any()))
-            .thenReturn(flowOf(UploadProgress(0.5f), UploadSuccess(MediaModel(0, 0))))
+            .thenReturn(flowOf(UploadProgress(0.5f), UploadSuccess(MediaTestUtils.createRemoteTestMedia().build())))
 
-        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaModel(0, 0)))
+        worker.enqueueWork(
+            Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaTestUtils.createRemoteTestMedia().build())
+        )
         advanceUntilIdle()
 
         verify(notificationHandler).setProgress(0.5f)
@@ -153,7 +156,9 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
         val job = launch {
             worker.events.toList(eventsList)
         }
-        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaModel(0, 0)))
+        worker.enqueueWork(
+            Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaTestUtils.createRemoteTestMedia().build())
+        )
 
         advanceUntilIdle()
         assertThat(eventsList).contains(UploadFailed(REMOTE_PRODUCT_ID, TEST_URI, error))
@@ -166,7 +171,9 @@ class ProductImagesUploadWorkerTest : BaseUnitTest() {
         val job = launch {
             worker.events.toList(eventsList)
         }
-        worker.enqueueWork(Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaModel(0, 0)))
+        worker.enqueueWork(
+            Work.UploadMedia(REMOTE_PRODUCT_ID, TEST_URI, MediaTestUtils.createRemoteTestMedia().build())
+        )
 
         advanceUntilIdle()
         assertThat(eventsList).contains(ProductUploadsCompleted(REMOTE_PRODUCT_ID))

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/media/MediaFileUploadHandlerTest.kt

@@ -29,9 +29,7 @@ import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
-import org.wordpress.android.fluxc.model.MediaModel
-import org.wordpress.android.fluxc.model.MediaModel.MediaUploadState.FAILED
-import org.wordpress.android.fluxc.model.MediaModel.MediaUploadState.UPLOADED
+import org.wordpress.android.fluxc.media.MediaTestUtils
 import org.wordpress.android.fluxc.store.MediaStore.MediaErrorType
 import org.wordpress.android.fluxc.store.MediaStore.MediaErrorType.NULL_MEDIA_ARG
 import org.wordpress.android.util.DateTimeUtils
@@ -80,7 +78,7 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
     fun `when media is fetched, then start uploading it`() = testBlocking {
         mediaFileUploadHandler.enqueueUpload(REMOTE_PRODUCT_ID, listOf(TEST_URI))
 
-        val fetchedMedia = MediaModel(0, 0)
+        val fetchedMedia = MediaTestUtils.createRemoteTestMedia().build()
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.FetchSucceeded(
                 REMOTE_PRODUCT_ID,
@@ -125,14 +123,12 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
         mediaFileUploadHandler.enqueueUpload(REMOTE_PRODUCT_ID, listOf(TEST_URI))
 
         launch {
-            val successfulUpload = mediaFileUploadHandler.observeSuccessfulUploads(REMOTE_PRODUCT_ID).first()
-            assertThat(successfulUpload.uploadState).isEqualTo(UPLOADED.toString())
+            mediaFileUploadHandler.observeSuccessfulUploads(REMOTE_PRODUCT_ID).first()
         }
 
-        val mediaModel = MediaModel(0, 0).apply {
-            postId = REMOTE_PRODUCT_ID
-            setUploadState(UPLOADED)
-        }
+        val mediaModel = MediaTestUtils.createRemoteTestMedia()
+            .postId(REMOTE_PRODUCT_ID)
+            .build()
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.UploadSucceeded(
                 REMOTE_PRODUCT_ID,
@@ -146,13 +142,12 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
     fun `given there is no external observer, when uploads finish, then start product update`() = testBlocking {
         mediaFileUploadHandler.enqueueUpload(REMOTE_PRODUCT_ID, listOf(TEST_URI))
 
-        val mediaModel = MediaModel(0, 0).apply {
-            postId = REMOTE_PRODUCT_ID
-            fileName = "test"
-            url = "url"
-            uploadDate = DateTimeUtils.iso8601FromDate(Date())
-            setUploadState(UPLOADED)
-        }
+        val mediaModel = MediaTestUtils.createRemoteTestMedia()
+            .fileName("test")
+            .url("url")
+            .uploadDate(DateTimeUtils.iso8601FromDate(Date()))
+            .postId(REMOTE_PRODUCT_ID)
+            .build()
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.UploadSucceeded(
                 REMOTE_PRODUCT_ID,
@@ -170,13 +165,12 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
             val testUri2 = "file:///test2"
             mediaFileUploadHandler.enqueueUpload(REMOTE_PRODUCT_ID, listOf(TEST_URI, testUri2))
 
-            val mediaModel = MediaModel(0, 0).apply {
-                postId = REMOTE_PRODUCT_ID
-                fileName = "test"
-                url = "url"
-                uploadDate = DateTimeUtils.iso8601FromDate(Date())
-                setUploadState(UPLOADED)
-            }
+            val mediaModel = MediaTestUtils.createRemoteTestMedia()
+                .fileName("test")
+                .url("url")
+                .uploadDate(DateTimeUtils.iso8601FromDate(Date()))
+                .postId(REMOTE_PRODUCT_ID)
+                .build()
             eventsFlow.tryEmit(
                 Event.MediaUploadEvent.UploadSucceeded(
                     REMOTE_PRODUCT_ID,
@@ -203,10 +197,9 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
 
         val job = launch { mediaFileUploadHandler.observeSuccessfulUploads(REMOTE_PRODUCT_ID).collect() }
 
-        val mediaModel = MediaModel(0, 0).apply {
-            postId = REMOTE_PRODUCT_ID
-            setUploadState(FAILED)
-        }
+        val mediaModel = MediaTestUtils.createRemoteTestMedia()
+            .postId(REMOTE_PRODUCT_ID)
+            .build()
 
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.UploadFailed(
@@ -229,10 +222,9 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
     fun `given there is no external observer, when an upload fails, then show notification`() = testBlocking {
         mediaFileUploadHandler.enqueueUpload(REMOTE_PRODUCT_ID, listOf(TEST_URI))
 
-        val mediaModel = MediaModel(0, 0).apply {
-            postId = REMOTE_PRODUCT_ID
-            setUploadState(FAILED)
-        }
+        val mediaModel = MediaTestUtils.createRemoteTestMedia()
+            .postId(REMOTE_PRODUCT_ID)
+            .build()
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.UploadFailed(
                 REMOTE_PRODUCT_ID,
@@ -261,12 +253,11 @@ class MediaFileUploadHandlerTest : BaseUnitTest() {
     @Test
     fun `when assigning uploads to created product, then update the id for the successful ones`() = testBlocking {
         mediaFileUploadHandler.enqueueUpload(ProductDetailViewModel.DEFAULT_ADD_NEW_PRODUCT_ID, listOf(TEST_URI))
-        val mediaModel = MediaModel(0, 0).apply {
-            fileName = "test"
-            url = "url"
-            uploadDate = DateTimeUtils.iso8601FromDate(Date())
-            setUploadState(UPLOADED)
-        }
+        val mediaModel = MediaTestUtils.createRemoteTestMedia()
+            .fileName("test")
+            .url("url")
+            .uploadDate(DateTimeUtils.iso8601FromDate(Date()))
+            .build()
         eventsFlow.tryEmit(
             Event.MediaUploadEvent.UploadSucceeded(
                 ProductDetailViewModel.DEFAULT_ADD_NEW_PRODUCT_ID,

WooCommerce/src/test/kotlin/com/woocommerce/android/ui/products/details/ProductDetailViewModelTest.kt

@@ -62,7 +62,7 @@ import org.mockito.kotlin.spy
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
-import org.wordpress.android.fluxc.model.MediaModel
+import org.wordpress.android.fluxc.media.MediaTestUtils
 import org.wordpress.android.fluxc.model.SiteModel
 import org.wordpress.android.fluxc.store.MediaStore
 import org.wordpress.android.fluxc.store.WCProductStore
@@ -1090,10 +1090,10 @@ class ProductDetailViewModelTest : BaseUnitTest() {
             on { it.observeCurrentUploadErrors(any()) } doReturn emptyFlow()
             on { it.observeCurrentUploads(any()) } doReturn flowOf(emptyList())
             on { it.observeSuccessfulUploads(any()) } doReturn uris.map {
-                MediaModel(0, 0).apply {
-                    url = it
-                    uploadDate = "2022-09-27 18:00:00.000"
-                }
+                MediaTestUtils.createRemoteTestMedia()
+                    .url(it)
+                    .uploadDate("2022-09-27 18:00:00.000")
+                    .build()
             }.asFlow()
         }
 

libs/fluxc-plugin/src/main/kotlin/org/wordpress/android/fluxc/model/WCProductImageModel.kt

@@ -1,26 +1,13 @@
 package org.wordpress.android.fluxc.model
 
 import com.google.gson.JsonObject
-import org.wordpress.android.fluxc.utils.DateUtils
 
 class WCProductImageModel(val id: Long) {
     var dateCreated: String = ""
     var src: String = ""
     var alt: String = ""
     var name: String = ""
 
-    companion object {
-        fun fromMediaModel(media: MediaModel): WCProductImageModel {
-            with(WCProductImageModel(media.mediaId)) {
-                dateCreated = media.uploadDate ?: DateUtils.getCurrentDateString()
-                src = media.url
-                alt = media.alt
-                name = media.fileName ?: ""
-                return this
-            }
-        }
-    }
-
     fun toJson(): JsonObject {
         return JsonObject().also { json ->
             json.addProperty("id", id)