@file:SuppressLint("OldTargetApi")

import android.annotation.SuppressLint
import com.vanniktech.maven.publish.JavadocJar

plugins {
  id("com.android.library")
  kotlin("android")
  id("org.jetbrains.dokka")
  id("com.vanniktech.maven.publish.base")
  id("binary-compatibility-validator")
}

android {
  compileSdk = 34

  namespace = "okhttp.android"

  defaultConfig {
    minSdk = 21

gradlePlugin-bnd = { module = "biz.aQute.bnd:biz.aQute.bnd.gradle", version.ref = "biz-aQute-bnd" }
gradlePlugin-dokka = "org.jetbrains.dokka:dokka-gradle-plugin:1.9.20"
gradlePlugin-errorprone = "net.ltgt.gradle:gradle-errorprone-plugin:3.1.0"
gradlePlugin-graal = "com.palantir.graal:gradle-graal:0.12.0"

    } else {
      emptyList()
    }
  }

  /**
   * Convert a request header to OkHttp's cookies via [HttpCookie]. That extra step handles
   * multiple cookies in a single request header, which [Cookie.parse] doesn't support.
   */
  private fun decodeHeaderAsJavaNetCookies(
    url: HttpUrl,
    header: String,
  ): List<Cookie> {
    val result = mutableListOf<Cookie>()
    var pos = 0
    val limit = header.length

      result.writeUtf8(string, pos, limit)
      return true
    }

    var pos = pos + 4 // 'xn--'.size.

    // We'd prefer to operate directly on `result` but it doesn't offer insertCodePoint(), only
    // appendCodePoint(). The Punycode algorithm processes code points in increasing code-point
    // order, not in increasing index order.
    val codePoints = mutableListOf<Int>()

  fun retryAfterFailure(): Boolean {
    return exchange?.hasFailure == true &&
      exchangeFinder!!.routePlanner.hasNext(exchange?.connection)
  }

  /**
   * Returns a string that describes this call. Doesn't include a full URL as that might contain
   * sensitive information.
   */
  private fun toLoggableString(): String {
    return (
      (if (isCanceled()) "canceled " else "") +

    `NullPointerException: bio == null`.


## Version 4.9.0

_2020-09-11_

**With this release, `okhttp-tls` no longer depends on Bouncy Castle and doesn't install the
Bouncy Castle security provider.** If you still need it, you can do it yourself:

```
Security.addProvider(BouncyCastleProvider())
```

You will also need to configure this dependency:

```

 * it easy to get sample values to use in such tests.
 *
 * This class is pretty fast and loose with default values: it attempts to provide values that are
 * well-formed, but doesn't guarantee values are internally consistent. Callers must take care to
 * configure the factory when sample values impact the correctness of the test.
 */
class TestValueFactory : Closeable {

 *
 * The best way to improve the cache hit rate is by configuring the web server to return cacheable
 * responses. Although this client honors all [HTTP/1.1 (RFC 7234)][rfc_7234] cache headers, it
 * doesn't cache partial responses.
 *
 * ## Force a Network Response
 *
 * In some situations, such as after a user clicks a 'refresh' button, it may be necessary to skip

      MockResponse.Builder()
        .body(gzippedBody)
        .addHeader("Content-Encoding: gzip")
        .build(),
    )

    // Confirm that the user request doesn't have Accept-Encoding, and the user
    // response doesn't have a Content-Encoding or Content-Length.
    val userResponse = executeSynchronously("/")
    userResponse.assertCode(200)
      .assertRequestHeader("Accept-Encoding")

        // Assume the server won't send a TLS ServerHello until we send a TLS ClientHello. If
        // that happens, then we will have buffered bytes that are needed by the SSLSocket!
        // This check is imperfect: it doesn't tell us whether a handshake will succeed, just
        // that it will almost certainly fail because the proxy has sent unexpected data.
        if (source?.buffer?.exhausted() == false || sink?.buffer?.exhausted() == false) {