如何在多平台Ktor和Coil之间共享HttpClient？

Question

我想使用Coil图像库从api加载带有之前设置的相同cookie的图像。因此，我希望在Ktor网络调用和使用Coil加载图像时都使用相同的HttpClient。

如何在Ktor和Coil之间共享相同的HttpClient？我假设，我需要以某种方式调整依赖关系，但我无法理解它。

我在共享模块中的KtorApiImpl

class KtorApiImpl(log: Kermit) : KtorApi {
val baseUrl = BuildKonfig.baseUrl

// If this is a constructor property, then it gets captured
// inside HttpClient config and freezes this whole class.
@Suppress("CanBePrimaryConstructorProperty")
private val log = log

override val client = HttpClientProvider().getHttpClient().config {
    install(JsonFeature) {
        serializer = KotlinxSerializer()
    }
    install(Logging) {
        logger = object : Logger {
            override fun log(message: String) {
                log.v("Network") { message }
            }
        }

        level = LogLevel.INFO
    }
}

init {
    ensureNeverFrozen()
}

override fun HttpRequestBuilder.apiUrl(path: String) {
    url {
        takeFrom(baseUrl)
        encodedPath = path
    }
}

override fun HttpRequestBuilder.json() {
    contentType(ContentType.Application.Json)
}

}

androidMain中的实际HttpClientProvider

var cookieJar: CookieJar = object : CookieJar {
    private val cookieStore: HashMap<String, List<Cookie>> = HashMap()

    override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
        cookieStore[url.host] = cookies
    }

    override fun loadForRequest(url: HttpUrl): List<Cookie> {
        val cookies = cookieStore[url.host]
        return cookies ?: ArrayList()
    }
}


actual class HttpClientProvider actual constructor() {
    actual fun getHttpClient(): HttpClient {
        return HttpClient(OkHttp) {
            engine {
                preconfigured = getOkHttpClient()
            }
        }
    }
}

private fun getOkHttpClient(): OkHttpClient {
    return OkHttpClient.Builder()
        .cookieJar(cookieJar)
        .build()
}

androidApp中的ImageLoaderFactory -如何使用HttpClient而不是创建新的？

class CoilImageLoaderFactory(private val context: Context) : ImageLoaderFactory {
    override fun newImageLoader(): ImageLoader {
        return ImageLoader.Builder(context)
            .availableMemoryPercentage(0.25) // Use 25% of the application's available memory.
            .crossfade(true) // Show a short crossfade when loading images from network or disk.
            .componentRegistry {
                add(ByteArrayFetcher())
            }
            .okHttpClient {
                // Create a disk cache with "unlimited" size. Don't do this in production.
                // To create the an optimized Coil disk cache, use CoilUtils.createDefaultCache(context).
                val cacheDirectory = File(context.filesDir, "image_cache").apply { mkdirs() }
                val cache = Cache(cacheDirectory, Long.MAX_VALUE)

                // Lazily create the OkHttpClient that is used for network operations.
                OkHttpClient.Builder()
                    .cache(cache)
                    .build()
            }
            .build()
    }

}

androidApp中的Koin依赖项

@Suppress("unused")
class MainApp : Application() {

    override fun onCreate() {
        super.onCreate()
        initKoin(
        module {
            single<Context> { this@MainApp }
            single<AppInfo> { AndroidAppInfo }
            single { CoilImageLoaderFactory(get<Context>())}
            single<SharedPreferences> {
                get<Context>().getSharedPreferences("MAIN_SETTINGS", Context.MODE_PRIVATE)
            }
            single {
                { Log.i("Startup", "Hello from Android/Kotlin!") }
            }
        }
        )
    }
}

然后是主要活动

class MainActivity : AppCompatActivity() { 
    val loaderFactory: CoilImageLoaderFactory by inject()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            CompositionLocalProvider(LocalImageLoader provides loaderFactory.newImageLoader()) {
                MainTheme {
                    ProvideWindowInsets {
                        Surface {
                            MainScreen()
                        }
                    }
                }
            }
        }
    }
}

Answer 1

我使用以下命令从ImageLoader访问OkHttpClient

class CoilImageLoaderFactory(private val context: Context) : ImageLoaderFactory, KoinComponent {
val ktorApiImpl: KtorApi by inject()

override fun newImageLoader(): ImageLoader {
    return ImageLoader.Builder(context)
        .componentRegistry {
            add(ByteArrayFetcher())
        }
        .okHttpClient {
            val config = ktorApiImpl.client.engine.config as OkHttpConfig
            config.preconfigured as OkHttpClient
            
        }


        .build()
}

Answer 2

您可以使用ImageLoader.Builder.callFactory{}提供您自己的用于网络请求的Call.Factory。缺点是您必须将KtorApiImpl返回的任何类型映射到okttp3.Response，这是Coil能够理解的。

下面的示例描述了如何实现Call.Factory接口并将其提供给Coil的ImageLoader

ImageLoader.Builder(context)
            .callFactory {
                Call.Factory {
                    object: Call {
                        private var job: Job? = null
                        override fun clone(): Call {
                            TODO(“Not yet implemented”)
                        }

                        override fun request(): Request {
                            return it
                        }

                        override fun execute(): Response {
                            return runBlocking {
                                // Call KTOR client here
                            }
                        }

                        override fun enqueue(responseCallback: Callback) {
                            // Use a proper coroutines scope
                            job = GlobalScope.launch {
                                // Call KTOR client here
                            }
                        }

                        override fun cancel() {
                            job?.cancel()
                        }

                        override fun isExecuted(): Boolean {
                            return job?.isCompleted ?: false
                        }

                        override fun isCanceled(): Boolean {
                            return job?.isCancelled ?: false
                        }

                        override fun timeout(): Timeout {
                            // Your Timeout here
                        }
                    }
                }
            }