package jp.co.gunmabank.util
import android.os.Handler
import android.os.Looper
import com.google.gson.Gson
import com.google.gson.JsonParseException
import com.google.gson.internal.`$Gson$Types`
import com.squareup.okhttp.*
import io.fabric.sdk.android.services.common.AbstractSpiCall.DEFAULT_TIMEOUT
import jp.co.gunmabank.minefocus.BuildConfig
import java.io.IOException
import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type
import java.net.CookieManager
import java.net.CookiePolicy
import java.net.Proxy
import jp.co.gunmabank.util.TrustAllCerts
import java.security.SecureRandom
import java.util.concurrent.TimeUnit
import javax.net.ssl.*
import javax.xml.datatype.DatatypeConstants.SECONDS
import io.fabric.sdk.android.services.settings.IconRequest.build
import com.squareup.okhttp.RequestBody
import jp.co.gunmabank.common.Common
import io.fabric.sdk.android.services.settings.IconRequest.build
import io.fabric.sdk.android.services.settings.IconRequest.build
/**
* 非同時OkHttpのフォームに基づいてを提出
* Created by wangsai on 2017/05/12.
*/
object OkHttpUtil {
private var mOkHttpClient: OkHttpClient
private val mDelivery: Handler
private val mGson: Gson
private var mInstance: OkHttpUtil? = null
init {
mOkHttpClient = OkHttpClient()
//cookie enabled
mOkHttpClient.cookieHandler = CookieManager(null, java.net.CookiePolicy.ACCEPT_ORIGINAL_SERVER)
mDelivery = Handler(Looper.getMainLooper())
mGson = Gson()
if (mInstance == null) {
synchronized(OkHttpUtil::class.java) {
if (mInstance == null) {
mInstance = OkHttpUtil
}
}
}
}
/**
* 非同時OkHttpのフォームに基づいてを提出
* @param url
* *
* @param callback
* *
* @param sendData
* *
* @throws IOException
*/
@Throws(IOException::class)
private fun postFormDataAsyn(url: String, callback: ResultCallback<*>, sendData: String, sendLinkData: String, name: String, linkname: String) {
val request = buildMultipartFormRequest(url, sendData, sendLinkData, name, linkname)
deliveryResult(callback, request)
}
@Throws(IOException::class)
private fun postJsonDataAsyn(url: String, callback: ResultCallback<*>, sendData: String) {
val request = buildPostJosnRequest(url, sendData)
deliveryResult(callback, request)
}
/**
* データを整理
* @param url
* *
* @param sendData
* *
* @return
*/
private fun buildMultipartFormRequest(url: String, sendData: String, sendLinkData: String, name: String, linkname: String): Request {
var boundary = "--AlamofireBoundary" + Common.randomFor4Num(8)
val builder = MultipartBuilder(boundary).type(MultipartBuilder.FORM)
builder.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + name + "\""), RequestBody.create(MediaType.parse("application/json; charset=utf-8"), sendData))
builder.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + linkname + "\""), RequestBody.create(MediaType.parse("application/json; charset=utf-8"), sendLinkData))
val requestBody = builder.build()
return Request.Builder().url(url).post(requestBody).build()
}
private fun buildPostJosnRequest(url: String, sendData: String): Request {
val request = Request.Builder().url(url).post(RequestBody.create(
MediaType.parse("application/json; charset=utf-8"),
sendData)).build()
return request
}
/**
* 結果を処理
* @param callback
* *
* @param request
*/
private fun deliveryResult(callback: ResultCallback<*>, request: Request) {
var dnpSendmsg = ""
mOkHttpClient.newCall(request).enqueue(object : Callback {
override fun onFailure(request: Request, e: IOException) {
dnpSendmsg = request.tag().toString()
sendFailedStringCallback(dnpSendmsg, request, e, callback)
}
override fun onResponse(response: Response) {
try {
val str = response.body().string()
if (callback.mType === String::class.java) {
sendSuccessResultCallback(str, callback)
} else {
//TODO mGson
}
} catch (e: IOException) {
sendFailedStringCallback(dnpSendmsg, response.request(), e, callback)
} catch (e: JsonParseException) {
sendFailedStringCallback(dnpSendmsg, response.request(), e, callback)
}
}
})
}
private fun sendFailedStringCallback(dnpSendmsg: String, request: Request, e: Exception, callback: ResultCallback<*>) {
mDelivery.post {
callback?.onError(dnpSendmsg, request, e)
}
}
private fun sendSuccessResultCallback(any: String, callback: ResultCallback<*>) {
mDelivery.post {
callback?.onResponse(any)
}
}
abstract class ResultCallback<T> {
internal var mType: Type
init {
mType = getSuperclassTypeParameter(javaClass)
}
abstract fun onError(dnpSendmsg: String, request: Request, e: Exception)
abstract fun onResponse(str: String)
companion object {
internal fun getSuperclassTypeParameter(subclass: Class<*>): Type {
val superclass = subclass.genericSuperclass
if (superclass is Class<*>) {
throw RuntimeException("Missing type parameter.")
}
val parameterized = superclass as ParameterizedType
return `$Gson$Types`.canonicalize(parameterized.actualTypeArguments[0])
}
}
}
/**
* 非同時OkHttpのフォームに基づいてを提出
* @param url
* *
* @param callback
* *
* @param sendData
* *
* @throws IOException
*/
fun postFormAsyn(url: String, callback: ResultCallback<*>, sendData: String, sendLinkData: String, name: String, linkname: String) {
mOkHttpClient = OkHttpClient()
mOkHttpClient.setConnectTimeout(100, TimeUnit.SECONDS)
mOkHttpClient.setReadTimeout(100, TimeUnit.SECONDS)
//cookie enabled
mOkHttpClient.cookieHandler = CookieManager(null, java.net.CookiePolicy.ACCEPT_ORIGINAL_SERVER)
mInstance!!.postFormDataAsyn(url, callback, sendData, sendLinkData, name, linkname)
}
/**
* 非同時OkHttpのフォームに基づいてを提出
* @param url
* *
* @param callback
* *
* @param sendData
* *
* @throws IOException
*/
fun postFormAsynForAUth(url: String, callback: ResultCallback<*>, sendData: String, sendLinkData: String, name: String, linkname: String, usename: String, usepassword: String) {
mOkHttpClient = OkHttpClient()
if (BuildConfig.FLAVOR == "stg" || BuildConfig.FLAVOR == "jp") {
mOkHttpClient.authenticator = object : Authenticator {
override fun authenticate(proxy: Proxy?, response: Response?): Request {
val credential = Credentials.basic(usename, usepassword)
return response!!.request().newBuilder()
.header("Authorization", credential)
.build()
}
override fun authenticateProxy(proxy: Proxy?, response: Response?): Request? {
return null
}
}
mOkHttpClient.sslSocketFactory = createSSLSocketFactory()
mOkHttpClient.hostnameVerifier = HostnameVerifier { hostname, session -> true }
}
mOkHttpClient.setConnectTimeout(100, TimeUnit.SECONDS)
mOkHttpClient.setReadTimeout(100, TimeUnit.SECONDS)
mOkHttpClient.setWriteTimeout(100, TimeUnit.SECONDS)
//cookie enabled
mOkHttpClient.cookieHandler = CookieManager(null, java.net.CookiePolicy.ACCEPT_ORIGINAL_SERVER)
mInstance!!.postFormDataAsyn(url, callback, sendData, sendLinkData, name, linkname)
}
fun postJsonAsynForAUth(url: String, callback: ResultCallback<*>, sendData: String, usename: String, usepassword: String) {
mOkHttpClient = OkHttpClient()
if (BuildConfig.FLAVOR == "stg" || BuildConfig.FLAVOR == "jp") {
mOkHttpClient.authenticator = object : Authenticator {
override fun authenticate(proxy: Proxy?, response: Response?): Request {
val credential = Credentials.basic(usename, usepassword)
return response!!.request().newBuilder()
.header("Authorization", credential)
.build()
}
override fun authenticateProxy(proxy: Proxy?, response: Response?): Request? {
return null
}
}
mOkHttpClient.sslSocketFactory = createSSLSocketFactory()
mOkHttpClient.hostnameVerifier = HostnameVerifier { hostname, session -> true }
}
mOkHttpClient.setConnectTimeout(600, TimeUnit.SECONDS)
mOkHttpClient.setReadTimeout(600, TimeUnit.SECONDS)
mOkHttpClient.setWriteTimeout(600, TimeUnit.SECONDS)
//cookie enabled
mOkHttpClient.cookieHandler = CookieManager(null, java.net.CookiePolicy.ACCEPT_ORIGINAL_SERVER)
mInstance!!.postJsonDataAsyn(url, callback, sendData)
}
private fun createSSLSocketFactory(): SSLSocketFactory? {
var ssfFactory: SSLSocketFactory? = null
try {
val sc = SSLContext.getInstance("TLS")
sc.init(null, arrayOf<TrustManager>(TrustAllCerts()), SecureRandom())
ssfFactory = sc.socketFactory
} catch (e: Exception) {
}
return ssfFactory
}
}
