CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-io-ktor--ktor-client-core-tvosarm64

Ktor HTTP Client Core for tvOS ARM64 - multiplatform asynchronous HTTP client library with coroutines support

—

Pending
Overview
Eval results
Files

http-client.mddocs/

HTTP Client Core

The core HTTP client functionality provides the main HttpClient class for making asynchronous HTTP requests with full coroutines support. It offers both convenience methods for common HTTP verbs and advanced request building capabilities.

Core Types

// HttpClient class (main constructor is internal)
class HttpClient(
    public val engine: HttpClientEngine,
    private val userConfig: HttpClientConfig<out HttpClientEngineConfig> = HttpClientConfig()
) : CoroutineScope, Closeable {
    public val attributes: Attributes
    public val engineConfig: HttpClientEngineConfig
    public val monitor: Events
    public val requestPipeline: HttpRequestPipeline
    public val responsePipeline: HttpResponsePipeline
    public val sendPipeline: HttpSendPipeline
    public val receivePipeline: HttpReceivePipeline
    
    public fun isSupported(capability: HttpClientEngineCapability<*>): Boolean
    public fun config(block: HttpClientConfig<*>.() -> Unit): HttpClient
    override fun close()
}

// HTTP method extensions (all are extension functions, not class members)
suspend fun HttpClient.get(builder: HttpRequestBuilder): HttpResponse
suspend fun HttpClient.get(block: HttpRequestBuilder.() -> Unit): HttpResponse
suspend fun HttpClient.get(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse
suspend fun HttpClient.get(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse

suspend fun HttpClient.post(builder: HttpRequestBuilder): HttpResponse
suspend fun HttpClient.post(block: HttpRequestBuilder.() -> Unit): HttpResponse
suspend fun HttpClient.post(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse
suspend fun HttpClient.post(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse

suspend fun HttpClient.put(builder: HttpRequestBuilder): HttpResponse
suspend fun HttpClient.put(block: HttpRequestBuilder.() -> Unit): HttpResponse
suspend fun HttpClient.put(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse
suspend fun HttpClient.put(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse

suspend fun HttpClient.delete(builder: HttpRequestBuilder): HttpResponse
suspend fun HttpClient.delete(block: HttpRequestBuilder.() -> Unit): HttpResponse
suspend fun HttpClient.delete(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse
suspend fun HttpClient.delete(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse

suspend fun HttpClient.head(builder: HttpRequestBuilder): HttpResponse
suspend fun HttpClient.head(block: HttpRequestBuilder.() -> Unit): HttpResponse
suspend fun HttpClient.head(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse
suspend fun HttpClient.head(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse

suspend fun HttpClient.options(builder: HttpRequestBuilder): HttpResponse
suspend fun HttpClient.options(block: HttpRequestBuilder.() -> Unit): HttpResponse
suspend fun HttpClient.options(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse
suspend fun HttpClient.options(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse

suspend fun HttpClient.patch(builder: HttpRequestBuilder): HttpResponse
suspend fun HttpClient.patch(block: HttpRequestBuilder.() -> Unit): HttpResponse
suspend fun HttpClient.patch(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse
suspend fun HttpClient.patch(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse

// Generic request methods
suspend fun HttpClient.request(builder: HttpRequestBuilder = HttpRequestBuilder()): HttpResponse
suspend fun HttpClient.request(block: HttpRequestBuilder.() -> Unit): HttpResponse
suspend fun HttpClient.request(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse
suspend fun HttpClient.request(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpResponse

// Prepared statement extensions
suspend fun HttpClient.prepareGet(builder: HttpRequestBuilder): HttpStatement
suspend fun HttpClient.prepareGet(block: HttpRequestBuilder.() -> Unit): HttpStatement
suspend fun HttpClient.prepareGet(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement
suspend fun HttpClient.prepareGet(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement

suspend fun HttpClient.preparePost(builder: HttpRequestBuilder): HttpStatement
suspend fun HttpClient.preparePost(block: HttpRequestBuilder.() -> Unit): HttpStatement
suspend fun HttpClient.preparePost(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement
suspend fun HttpClient.preparePost(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement

suspend fun HttpClient.preparePut(builder: HttpRequestBuilder): HttpStatement
suspend fun HttpClient.preparePut(block: HttpRequestBuilder.() -> Unit): HttpStatement
suspend fun HttpClient.preparePut(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement
suspend fun HttpClient.preparePut(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement

suspend fun HttpClient.prepareDelete(builder: HttpRequestBuilder): HttpStatement
suspend fun HttpClient.prepareDelete(block: HttpRequestBuilder.() -> Unit): HttpStatement
suspend fun HttpClient.prepareDelete(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement
suspend fun HttpClient.prepareDelete(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement

suspend fun HttpClient.prepareHead(builder: HttpRequestBuilder): HttpStatement
suspend fun HttpClient.prepareHead(block: HttpRequestBuilder.() -> Unit): HttpStatement
suspend fun HttpClient.prepareHead(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement
suspend fun HttpClient.prepareHead(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement

suspend fun HttpClient.prepareOptions(builder: HttpRequestBuilder): HttpStatement
suspend fun HttpClient.prepareOptions(block: HttpRequestBuilder.() -> Unit): HttpStatement
suspend fun HttpClient.prepareOptions(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement
suspend fun HttpClient.prepareOptions(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement

suspend fun HttpClient.preparePatch(builder: HttpRequestBuilder): HttpStatement
suspend fun HttpClient.preparePatch(block: HttpRequestBuilder.() -> Unit): HttpStatement
suspend fun HttpClient.preparePatch(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement
suspend fun HttpClient.preparePatch(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement

suspend fun HttpClient.prepareRequest(builder: HttpRequestBuilder = HttpRequestBuilder()): HttpStatement
suspend fun HttpClient.prepareRequest(block: HttpRequestBuilder.() -> Unit): HttpStatement
suspend fun HttpClient.prepareRequest(urlString: String, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement
suspend fun HttpClient.prepareRequest(url: Url, block: HttpRequestBuilder.() -> Unit = {}): HttpStatement

Client Configuration

class HttpClientConfig<T : HttpClientEngineConfig> {
    var expectSuccess: Boolean = true
    var followRedirects: Boolean = true  
    var useDefaultTransformers: Boolean = true
    var developmentMode: Boolean = false
    
    fun <P : Any, B : Any> install(
        plugin: HttpClientPlugin<P, B>,
        configure: P.() -> Unit = {}
    )
    
    fun engine(factory: HttpClientEngineFactory<T>, configure: T.() -> Unit = {})
}

Client Creation

Default Client

// Creates client with default engine for the platform
val client = HttpClient()

Client with Configuration

val client = HttpClient {
    expectSuccess = false
    followRedirects = true
    
    // Install plugins
    install(HttpTimeout) {
        requestTimeoutMillis = 30000
        connectTimeoutMillis = 10000
    }
}

Client with Specific Engine

// Using engine factory
val client = HttpClient(engineFactory) {
    // Configure engine-specific settings
}

// Using engine instance
val engine = engineFactory.create {
    // Engine configuration
}
val client = HttpClient(engine)

Making Requests

Simple GET Request

val response: HttpResponse = client.get("https://api.example.com/users")
val text: String = response.bodyAsText()

POST with Body

val response = client.post("https://api.example.com/users") {
    setBody("{ \"name\": \"John\", \"email\": \"john@example.com\" }")
    header("Content-Type", "application/json")
}

Generic Request with Full Configuration

val response = client.request {
    method = HttpMethod.Post
    url("https://api.example.com/users")
    header("Authorization", "Bearer $token")
    parameter("expand", "profile")
    setBody(userData)
}

Using Prepared Statements

// Prepare request for reuse
val statement = client.preparePost("https://api.example.com/users") {
    header("Content-Type", "application/json")
}

// Execute with different bodies
val response1 = statement.execute { setBody(user1) }
val response2 = statement.execute { setBody(user2) }

Lifecycle Management

Closing the Client

// Always close the client when done
client.close()

Using with Resources

HttpClient().use { client ->
    val response = client.get("https://api.example.com/data")
    // Client automatically closed when exiting block
}

Error Handling

Basic Error Handling

try {
    val response = client.get("https://api.example.com/users")
    if (response.status.isSuccess()) {
        val data = response.bodyAsText()
        // Process successful response
    } else {
        println("Request failed: ${response.status}")
    }
} catch (e: Exception) {
    println("Network error: ${e.message}")
}

Timeout Exceptions

import io.ktor.client.network.sockets.*

try {
    val response = client.get("https://slow-api.example.com")
} catch (e: ConnectTimeoutException) {
    println("Connection timeout")
} catch (e: SocketTimeoutException) {
    println("Read timeout")
}

Client Events

The client provides events for monitoring request lifecycle:

object HttpRequestCreated : EventDefinition<HttpRequestBuilder>()
object HttpRequestIsReadyForSending : EventDefinition<HttpRequest>()
object HttpResponseReceived : EventDefinition<HttpResponseContainer>()
object HttpResponseCancelled : EventDefinition<HttpResponseContainer>()

Monitoring Events

client.monitor.subscribe(HttpRequestCreated) { request ->
    println("Request created: ${request.method} ${request.url}")
}

client.monitor.subscribe(HttpResponseReceived) { container ->
    println("Response received: ${container.response.status}")
}

Install with Tessl CLI

npx tessl i tessl/maven-io-ktor--ktor-client-core-tvosarm64

docs

builtin-plugins.md

caching.md

cookies.md

engine-configuration.md

forms.md

http-client.md

index.md

plugin-system.md

request-building.md

response-handling.md

response-observation.md

utilities.md

websockets.md

tile.json