Tile image loaders based on Coil.

docs/tiles.md

@@ -1,5 +1,7 @@
 # Tiles Library
 
+## CoroutinesTileService
+
 Provides a CoroutinesTileService, which also acts as a LifecycleService.
 
 ```kotlin
@@ -16,6 +18,19 @@ class ExampleTileService : CoroutinesTileService() {
 }
 ```
 
+## Coil Image Helpers
+
+Provides a suspending method to load an image from the network, convert to an RGB_565
+bitmap, and encode as a Tiles InlineImageResource.
+
+```kotlin
+val imageResource = imageLoader.loadImageResource(applicationContext, 
+    "https://raw.githubusercontent.com/google/horologist/main/docs/media-ui/playerscreen.png") {
+    // Show a local error image if missing
+    error(R.drawable.missingImage)
+}
+```
+
 ## Download
 
 ```groovy

gradle/libs.versions.toml

@@ -54,6 +54,7 @@ androidx-test-rules = "androidx.test:rules:1.4.0"
 androidx-wear = { module = "androidx.wear:wear", version.ref = "androidxWear" }
 androidx-wear-tiles = { module = "androidx.wear.tiles:tiles", version.ref = "androidxtiles" }
 androidx-wear-tiles-testing = { module = "androidx.wear.tiles:tiles-testing", version.ref = "androidxtiles" }
+coil = "io.coil-kt:coil-compose:2.1.0"
 com-squareup-okhttp3-okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "com-squareup-okhttp3" }
 compose-foundation-foundation = { module = "androidx.compose.foundation:foundation", version.ref = "compose" }
 compose-material-iconscore = { module = "androidx.compose.material:material-icons-core", version.ref = "compose" }

tiles/api/current.api

@@ -12,5 +12,11 @@ package com.google.android.horologist.tiles {
     method public abstract suspend Object? tileRequest(androidx.wear.tiles.RequestBuilders.TileRequest requestParams, kotlin.coroutines.Continuation<? super androidx.wear.tiles.TileBuilders.Tile> p);
   }
 
+  public final class ImagesKt {
+    method public static suspend Object? loadImage(coil.ImageLoader, android.content.Context context, Object? data, optional kotlin.jvm.functions.Function1<? super coil.request.ImageRequest.Builder,kotlin.Unit> configurer, optional kotlin.coroutines.Continuation<? super android.graphics.Bitmap> p);
+    method public static suspend Object? loadImageResource(coil.ImageLoader, android.content.Context context, Object? data, optional kotlin.jvm.functions.Function1<? super coil.request.ImageRequest.Builder,kotlin.Unit> configurer, optional kotlin.coroutines.Continuation<? super androidx.wear.tiles.ResourceBuilders.ImageResource> p);
+    method public static androidx.wear.tiles.ResourceBuilders.ImageResource toImageResource(android.graphics.Bitmap);
+  }
+
 }
 

tiles/build.gradle

@@ -101,6 +101,8 @@ dependencies {
     implementation libs.androidx.wear.tiles
     implementation libs.androidx.lifecycle.service
 
+    implementation libs.coil
+
     testImplementation libs.androidx.wear.tiles.testing
     testImplementation libs.espresso.core
     testImplementation libs.junit
@@ -110,6 +112,7 @@ dependencies {
     testImplementation libs.androidx.concurrent.future.ktx
 
     androidTestImplementation libs.androidx.lifecycle.testing
+    androidTestImplementation libs.kotlinx.coroutines.test
     androidTestImplementation libs.truth
     debugImplementation libs.compose.ui.test.manifest
     androidTestImplementation libs.espresso.core

tiles/src/androidTest/java/com/google/android/horologist/tiles/FakeImageLoader.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed 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
+ *
+ *      https://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 CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.horologist.tiles
+
+import android.content.Context
+import android.graphics.BitmapFactory
+import android.graphics.drawable.BitmapDrawable
+import androidx.annotation.DrawableRes
+import coil.ComponentRegistry
+import coil.ImageLoader
+import coil.decode.DataSource
+import coil.disk.DiskCache
+import coil.memory.MemoryCache
+import coil.request.DefaultRequestOptions
+import coil.request.Disposable
+import coil.request.ErrorResult
+import coil.request.ImageRequest
+import coil.request.ImageResult
+import coil.request.SuccessResult
+import java.io.IOException
+
+// https://coil-kt.github.io/coil/image_loaders/#testing
+class FakeImageLoader(val imageFn: (ImageRequest) -> ImageResult) : ImageLoader {
+    override val defaults = DefaultRequestOptions()
+    override val components = ComponentRegistry()
+    override val memoryCache: MemoryCache? get() = null
+    override val diskCache: DiskCache? get() = null
+
+    override fun enqueue(request: ImageRequest): Disposable = TODO()
+
+    override suspend fun execute(request: ImageRequest): ImageResult {
+        return imageFn(request)
+    }
+
+    override fun newBuilder(): ImageLoader.Builder = throw UnsupportedOperationException()
+
+    override fun shutdown() {}
+
+    companion object {
+        fun loadSuccessBitmap(context: Context, request: ImageRequest, @DrawableRes id: Int): ImageResult {
+            val bitmap = BitmapFactory.decodeResource(context.resources, id)
+            val result = BitmapDrawable(context.resources, bitmap)
+            return SuccessResult(
+                drawable = result,
+                request = request,
+                dataSource = DataSource.NETWORK
+            )
+        }
+
+        fun loadErrorBitmap(context: Context, request: ImageRequest, @DrawableRes id: Int): ImageResult {
+            val bitmap = BitmapFactory.decodeResource(context.resources, id)
+            val result = BitmapDrawable(context.resources, bitmap)
+            return ErrorResult(
+                drawable = result,
+                request = request,
+                throwable = IOException("request for ")
+            )
+        }
+    }
+}

tiles/src/androidTest/java/com/google/android/horologist/tiles/ImagesTest.kt

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed 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
+ *
+ *      https://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 CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:OptIn(ExperimentalCoroutinesApi::class, ExperimentalCoroutinesApi::class)
+
+package com.google.android.horologist.tiles
+
+import android.content.Context
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.wear.tiles.ResourceBuilders
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Before
+import org.junit.Test
+
+class ImagesTest {
+    private lateinit var context: Context
+
+    @Before
+    fun setup() {
+        context = InstrumentationRegistry.getInstrumentation().context
+    }
+
+    @Test
+    public fun loadImageResource() {
+        runTest {
+            val imageLoader = FakeImageLoader {
+                // https://wordpress.org/openverse/image/34896de8-afb0-494c-af63-17b73fc14124/
+                FakeImageLoader.loadSuccessBitmap(context, it, R.drawable.coil)
+            }
+
+            val imageResource = imageLoader.loadImageResource(context, R.drawable.coil)
+
+            val inlineResource = imageResource!!.inlineResource!!
+            assertThat(inlineResource.format).isEqualTo(ResourceBuilders.IMAGE_FORMAT_RGB_565)
+            assertThat(inlineResource.widthPx).isEqualTo(200)
+            assertThat(inlineResource.heightPx).isEqualTo(134)
+        }
+    }
+
+    @Test
+    public fun handlesFailures() {
+        runTest {
+            val imageLoader = FakeImageLoader {
+                // https://wordpress.org/openverse/image/34896de8-afb0-494c-af63-17b73fc14124/
+                FakeImageLoader.loadErrorBitmap(context, it, R.drawable.coil)
+            }
+
+            val imageResource = imageLoader.loadImageResource(context, R.drawable.coil) {
+                error(R.drawable.coil)
+            }
+
+            val inlineResource = imageResource!!.inlineResource!!
+            assertThat(inlineResource.format).isEqualTo(ResourceBuilders.IMAGE_FORMAT_RGB_565)
+        }
+    }
+}

tiles/src/main/java/com/google/android/horologist/tiles/images.kt

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2022 The Android Open Source Project
+ *
+ * Licensed 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
+ *
+ *      https://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 CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.horologist.tiles
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.drawable.BitmapDrawable
+import androidx.wear.tiles.ResourceBuilders
+import androidx.wear.tiles.ResourceBuilders.ImageResource
+import coil.ImageLoader
+import coil.request.ImageRequest
+import java.nio.ByteBuffer
+
+/**
+ * Load a Bitmap from a CoilImage loader.
+ *
+ * @param context the context of the service or activity.
+ * @param data the image to fetch in one of the support Coil formats such as String, HttpUrl.
+ * @param configurer any additional configuration of the ImageRequest being built.
+ */
+public suspend fun ImageLoader.loadImage(
+    context: Context,
+    data: Any?,
+    configurer: ImageRequest.Builder.() -> Unit = {}
+): Bitmap? {
+    val request = ImageRequest.Builder(context)
+        .data(data)
+        .apply(configurer)
+        .allowRgb565(true)
+        .allowHardware(false)
+        .build()
+    val response = execute(request)
+    return (response.drawable as? BitmapDrawable)?.bitmap
+}
+
+/**
+ * Load an ImageResource from a CoilImage loader.
+ *
+ * @param context the context of the service or activity.
+ * @param data the image to fetch in one of the support Coil formats such as String, HttpUrl.
+ * @param configurer any additional configuration of the ImageRequest being built.
+ */
+public suspend fun ImageLoader.loadImageResource(
+    context: Context,
+    data: Any?,
+    configurer: ImageRequest.Builder.() -> Unit = {}
+): ImageResource? = loadImage(context, data, configurer)?.toImageResource()
+
+/**
+ * Convert a bitmap to a ImageResource.
+ *
+ * Ensures it uses RGB_565 encoding, then generates an ImageResource
+ * with the correct width and height.
+ */
+public fun Bitmap.toImageResource(): ImageResource {
+    val rgb565Bitmap = if (config == Bitmap.Config.RGB_565) {
+        this
+    } else {
+        copy(Bitmap.Config.RGB_565, false)
+    }
+
+    val byteBuffer = ByteBuffer.allocate(rgb565Bitmap.byteCount)
+    rgb565Bitmap.copyPixelsToBuffer(byteBuffer)
+    val bytes: ByteArray = byteBuffer.array()
+
+    return ImageResource.Builder().setInlineResource(
+        ResourceBuilders.InlineImageResource.Builder()
+            .setData(bytes)
+            .setWidthPx(rgb565Bitmap.width)
+            .setHeightPx(rgb565Bitmap.height)
+            .setFormat(ResourceBuilders.IMAGE_FORMAT_RGB_565)
+            .build()
+    )
+        .build()
+}