Kotlin Retrofit как отправить запрос к серверу с небезопасным сертификатом?

#Retrofit
object RetrofitInstance {
 
val okHttpClient: OkHttpClient = OkHttpClient.Builder()
        .readTimeout(5, TimeUnit.MINUTES)
    .connectTimeout(5, TimeUnit.MINUTES)
    .build()
 
    val api: ApiService by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .client(okHttpClient)
            .addConverterFactory(GsonConverterFactory.create())
            .build()
            .create(ApiService::class.java)
    }
}
 
#API Service
interface ApiService {
    @GET("authorization")
    suspend fun login(@Header("Authorization") authHeader: String): LoginResponse
}
 
#Viewmodel
 private fun login() {
        _loading.value = true
        viewModelScope.launch {
            try {
                val base = email.value+":"+password.value
                val authHeader = "Basic "+Base64.encodeToString(base.toByteArray(),Base64.NO_WRAP)
                println(authHeader)
                val loginResponse = RetrofitInstance.api.login()
                if(loginResponse.user_id!=null && loginResponse.user_id!="") {//
                    //val context = getApplication<Application>().applicationContext
                    //println("HTTP Response:"+loginResponse.refreshToken+loginResponse.id+" "+loginResponse.username+" "+loginResponse.lastName)
                    storeUser(1, loginResponse.user_id, loginResponse.user_name, loginResponse.division_id, loginResponse.division_name, "", "")
                    //storeUser(1, loginResponse.user, loginResponse.user, loginResponse.user, loginResponse.user, "", "")
 
                    TokenManager.saveRefreshToken(applicationContext, authHeader)
 
                    _step.value = AuthSteps.FINAL
                    println("Success Signin")
                } else {
                    _refreshToken.value = authHeader
                    _step.value = AuthSteps.LOGIN//
                    println("Error Signin")
 
                }
            } catch (e: HttpException) {
                ApiUtils.handleHttpException(e) { error ->
                    setToastServerMessage(error)
                }
            }
            //catch (e: Exception) {
           //     setToastMessage(R.string.network_error)
            //}
            finally {
                _loading.value = false
            }
        }
    }

package an.imation.singlee
 
import okhttp3.OkHttpClient
import java.security.KeyStore
import java.security.SecureRandom
import java.security.cert.CertificateException
import java.security.cert.X509Certificate
import java.util.concurrent.TimeUnit
import javax.net.ssl.*
 
object UnSafeOkHttp {
 
    fun OkHttpClient.Builder.setUnsafe(): OkHttpClient.Builder {
        return try {
            // Create a trust manager that does not validate certificate chains
            val trustAllCerts = arrayOf<TrustManager>(
                object : X509TrustManager {
                    @Throws(CertificateException::class)
                    override fun checkClientTrusted(
                        chain: Array<X509Certificate?>?,
                        authType: String?
                    ) {
                    }
 
                    @Throws(CertificateException::class)
                    override fun checkServerTrusted(
                        chain: Array<X509Certificate?>?,
                        authType: String?
                    ) {
                    }
 
                    override fun getAcceptedIssuers(): Array<X509Certificate?>? {
                        return arrayOf()
                    }
                }
            )
 
            // Install the all-trusting trust manager
            val sslContext = SSLContext.getInstance("SSL")
            sslContext.init(null, trustAllCerts, SecureRandom())
            // Create an ssl socket factory with our all-trusting manager
            val sslSocketFactory = sslContext.socketFactory
            val trustManagerFactory: TrustManagerFactory =
                TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
            trustManagerFactory.init(null as KeyStore?)
            val trustManagers: Array<TrustManager> =
                trustManagerFactory.trustManagers
            check(!(trustManagers.size != 1 || trustManagers[0] !is X509TrustManager)) {
                "Unexpected default trust managers:" + trustManagers.contentToString()
            }
 
            val trustManager =
                trustManagers[0] as X509TrustManager
 
 
            val builder = this
                .sslSocketFactory(sslSocketFactory, trustManager)
                .hostnameVerifier(HostnameVerifier { _, _ -> true })
            builder
        } catch (e: Exception) {
            throw RuntimeException(e)
        }
    }
 
    val exampleOkHttp = OkHttpClient.Builder()
        .setUnsafe()
        .readTimeout(5, TimeUnit.MINUTES)
        .connectTimeout(5, TimeUnit.MINUTES)
        .build()
 
}