Ktor OkHttp Client Engine

import io.ktor.client.HttpClient
import io.ktor.client.engine.okhttp.OkHttp
import io.ktor.client.engine.okhttp.OkHttpConfig

import io.ktor.client.HttpClient
import io.ktor.client.engine.okhttp.OkHttp
import io.ktor.client.request.get
import io.ktor.client.statement.bodyAsText

// Create client with OkHttp engine
val client = HttpClient(OkHttp)

// Make a simple request
val response = client.get("https://api.example.com/data")
val content = response.bodyAsText()

// Close client when done
client.close()

/**
 * A JVM/Android client engine that uses the OkHttp HTTP client.
 * This engine supports Android 5.0 and newer.
 */
public data object OkHttp : HttpClientEngineFactory<OkHttpConfig> {
    /**
     * Creates a new OkHttp engine instance with the provided configuration.
     * @param block Configuration block for OkHttpConfig
     * @return Configured HttpClientEngine instance
     */
    override fun create(block: OkHttpConfig.() -> Unit): HttpClientEngine
    
    /**
     * Compares this object with another for equality.
     * @param other The object to compare with
     * @return true if objects are equal, false otherwise
     */
    override fun equals(other: Any?): Boolean
    
    /**
     * Returns the hash code for this object.
     * @return Hash code value
     */
    override fun hashCode(): Int
    
    /**
     * Returns string representation of this object.
     * @return "OkHttp"
     */
    override fun toString(): String
}

import io.ktor.client.HttpClient
import io.ktor.client.engine.okhttp.OkHttp

// Basic engine usage
val client = HttpClient(OkHttp)

// Engine with configuration
val configuredClient = HttpClient(OkHttp) {
    engine {
        // OkHttpConfig configuration goes here
        clientCacheSize = 20
    }
}

/**
 * A configuration for the OkHttp client engine.
 */
public class OkHttpConfig : HttpClientEngineConfig() {
    /**
     * Allows you to specify a preconfigured OkHttpClient instance.
     */
    public var preconfigured: OkHttpClient?
    
    /**
     * Specifies the size of cache that keeps recently used OkHttpClient instances.
     * Set this property to 0 to disable caching.
     */
    public var clientCacheSize: Int
    
    /**
     * Specifies the WebSocket.Factory used to create a WebSocket instance.
     * Otherwise, OkHttpClient is used directly.
     */
    public var webSocketFactory: WebSocket.Factory?
    
    /**
     * Configures OkHttpClient using OkHttpClient.Builder.
     * @param block Configuration block for OkHttpClient.Builder
     */
    public fun config(block: OkHttpClient.Builder.() -> Unit)
    
    /**
     * Adds an Interceptor to the OkHttp client.
     * @param interceptor Request/response interceptor
     */
    public fun addInterceptor(interceptor: Interceptor)
    
    /**
     * Adds a network Interceptor to the OkHttp client.
     * @param interceptor Network-level interceptor
     */
    public fun addNetworkInterceptor(interceptor: Interceptor)
}

import io.ktor.client.HttpClient
import io.ktor.client.engine.okhttp.OkHttp
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import java.util.concurrent.TimeUnit

// Using preconfigured OkHttpClient
val customOkHttpClient = OkHttpClient.Builder()
    .connectTimeout(30, TimeUnit.SECONDS)
    .build()

val client = HttpClient(OkHttp) {
    engine {
        preconfigured = customOkHttpClient
    }
}

// Adding interceptors
val clientWithLogging = HttpClient(OkHttp) {
    engine {
        addInterceptor(HttpLoggingInterceptor().apply {
            level = HttpLoggingInterceptor.Level.BODY
        })
        
        // Configure client builder directly
        config {
            connectTimeout(10, TimeUnit.SECONDS)
            readTimeout(30, TimeUnit.SECONDS)
            writeTimeout(30, TimeUnit.SECONDS)
        }
    }
}

// Adjusting cache size
val cachedClient = HttpClient(OkHttp) {
    engine {
        clientCacheSize = 5  // Keep 5 recent client instances
    }
}

/**
 * OkHttp-based HTTP client engine implementation.
 */
public class OkHttpEngine(override val config: OkHttpConfig) : HttpClientEngineBase("ktor-okhttp") {
    /**
     * Set of capabilities supported by this engine.
     */
    override val supportedCapabilities: Set<HttpClientEngineCapability<*>>
    
    /**
     * Coroutine context for engine operations.
     */
    override val coroutineContext: CoroutineContext
    
    /**
     * Executes an HTTP request and returns the response data.
     * @param data HTTP request data to execute
     * @return HTTP response data
     */
    override suspend fun execute(data: HttpRequestData): HttpResponseData
    
    /**
     * Closes the engine and cleans up resources.
     */
    override fun close()
}

/**
 * Container for the OkHttp engine factory.
 */
public class OkHttpEngineContainer : HttpClientEngineContainer {
    /**
     * The OkHttp engine factory.
     */
    override val factory: HttpClientEngineFactory<*>
    
    /**
     * String representation of the container.
     * @return "OkHttp"
     */
    override fun toString(): String
}

/**
 * Exception thrown when an unsupported WebSocket frame type is encountered.
 */
public class UnsupportedFrameTypeException(
    private val frame: Frame
) : IllegalArgumentException("Unsupported frame type: $frame"), CopyableThrowable<UnsupportedFrameTypeException> {
    /**
     * Creates a copy of this exception.
     * @return Copy of the exception
     */
    override fun createCopy(): UnsupportedFrameTypeException
}

import io.ktor.client.HttpClient
import io.ktor.client.engine.okhttp.OkHttp
import io.ktor.client.plugins.HttpTimeout
import kotlin.time.Duration.Companion.seconds

val client = HttpClient(OkHttp) {
    install(HttpTimeout) {
        requestTimeoutMillis = 30.seconds.inWholeMilliseconds
        connectTimeoutMillis = 10.seconds.inWholeMilliseconds
        socketTimeoutMillis = 30.seconds.inWholeMilliseconds
    }
}

import io.ktor.client.HttpClient
import io.ktor.client.engine.okhttp.OkHttp
import io.ktor.client.plugins.websocket.WebSockets
import io.ktor.client.plugins.websocket.webSocketSession
import io.ktor.websocket.Frame
import io.ktor.websocket.readText

val client = HttpClient(OkHttp) {
    install(WebSockets)
}

client.webSocketSession("wss://echo.websocket.org") {
    send(Frame.Text("Hello WebSocket!"))
    val response = incoming.receive() as Frame.Text
    println("Received: ${response.readText()}")
}

import io.ktor.client.HttpClient
import io.ktor.client.engine.okhttp.OkHttp
import io.ktor.client.plugins.sse.SSE
import io.ktor.client.plugins.sse.serverSentEvents
import kotlinx.coroutines.flow.collect

val client = HttpClient(OkHttp) {
    install(SSE)
}

client.serverSentEvents("https://api.example.com/events") {
    incoming.collect { event ->
        println("Event: ${event.data}")
    }
}