import { isDefined } from "@nativescript/core/utils/types";

import { HttpResponseEncoding } from "@nativescript/core/http";

import { ImageSource } from "@nativescript/core/image-source";

import * as Https from "./https.common";

import { File } from "@nativescript/core/file-system";

interface Ipeer {

enabled: boolean;

allowInvalidCertificates: boolean;

validatesDomainName: boolean;

host?: string;

commonName?: string;

certificate?: string;

x509Certificate?: java.security.cert.Certificate;

}

let peer: Ipeer = {

enabled: false,

allowInvalidCertificates: false,

validatesDomainName: true,

};

let cache: okhttp3.Cache;

export function setCache(options?: Https.CacheOptions) {

if (options) {

cache = new okhttp3.Cache(

new java.io.File(options.diskLocation),

options.diskSize

);

} else {

cache = null;

}

if (Client) {

getClient(true);

}

}

export function clearCache() {

if (cache) {

cache.evictAll();

}

}

let _timeout = 10;

class HttpsResponse implements Https.HttpsResponseLegacy {

private callback?: com.nativescript.https.OkHttpResponse.OkHttpResponseAsyncCallback;

constructor(

private response: com.nativescript.https.OkHttpResponse,

private tag: string,

private url: string

) {}

getOrCreateCloseCallback() {

if (!notClosedResponses[this.tag]) {

// we need to store handling request to be able to cancel them

notClosedResponses[this.tag] = this.response;

this.response.closeCallback = new OkHttpResponse.OkHttpResponseCloseCallback(

{

onClose() {

delete notClosedResponses[this.tag];

},

}

);

}

}

getCallback(resolve, reject) {

return new com.nativescript.https.OkHttpResponse.OkHttpResponseAsyncCallback(

{

onBitmap(res) {

resolve(new ImageSource(res));

},

onString(res) {

resolve(res);

},

onByteArray(res) {

resolve((ArrayBuffer as any).from(res));

},

onFile(res) {

resolve(res);

},

onException(err) {

reject(err);

},

}

);

}

// cache it because asking it again wont work as the socket is closed

arrayBuffer: ArrayBuffer;

toArrayBuffer() {

try {

this.arrayBuffer =

this.arrayBuffer ||

(ArrayBuffer as any).from(this.response.toByteArray());

return this.arrayBuffer;

} catch {

return null;

}

}

toArrayBufferAsync(): Promise<ArrayBuffer> {

if (this.arrayBuffer) {

return Promise.resolve(this.arrayBuffer);

}

return new Promise((resolve, reject) => {

this.getOrCreateCloseCallback();

this.response.toByteArrayAsync(this.getCallback(resolve, reject));

}).then((r: ArrayBuffer) => {

this.arrayBuffer = r;

return this.arrayBuffer;

});

}

// cache it because asking it again wont work as the socket is closed

stringResponse: string;

toString() {

try {

// TODO: handle arraybuffer already stored

this.stringResponse =

this.stringResponse || this.response.asString();

return this.stringResponse;

} catch {

return null;

}

}

async toStringAsync(): Promise<string> {

if (this.stringResponse) {

return this.stringResponse;

}

// TODO: handle arraybuffer already stored

this.stringResponse = await new Promise<string>((resolve, reject) => {

this.getOrCreateCloseCallback();

this.response.asStringAsync(this.getCallback(resolve, reject));

});

return this.stringResponse;

}

// cache it because asking it again wont work as the socket is closed

jsonResponse: any;

toJSON(encoding?: HttpResponseEncoding) {

try {

if (this.jsonResponse) {

return this.jsonResponse;

}

// TODO: handle arraybuffer already stored

this.stringResponse =

this.stringResponse || this.response.asString();

this.jsonResponse = Https.parseJSON(this.stringResponse);

return this.jsonResponse;

} catch (err) {

console.error("HttpsResponse.toJSON", err);

return null;

}

}

async toJSONAsync() {

if (this.jsonResponse) {

return this.jsonResponse;

}

if (this.stringResponse) {

this.jsonResponse = Https.parseJSON(this.stringResponse);

return this.jsonResponse;

}

// TODO: handle arraybuffer already stored

const r = await this.toStringAsync();

this.jsonResponse = Https.parseJSON(r);

return this.jsonResponse;

}

// cache it because asking it again wont work as the socket is closed

imageSource: ImageSource;

async toImage(): Promise<ImageSource> {

if (this.imageSource) {

return this.imageSource;

}

return new Promise<ImageSource>((resolve, reject) => {

this.getOrCreateCloseCallback();

this.response

.toBitmapAsync(this.getCallback(resolve, reject))

.then((r) => {

this.imageSource = r;

return r;

});

});

}

// toFile(destinationFilePath: string): File {

// if (!destinationFilePath) {

// destinationFilePath = Https.getFilenameFromUrl(this.url);

// }

// const file = this.response.toFile(destinationFilePath);

// return File.fromPath(destinationFilePath);

// }

// cache it because asking it again wont work as the socket is closed

file: File;

toFile(destinationFilePath: string): Promise<File> {

if (this.file) {

return Promise.resolve(this.file);

}

if (!destinationFilePath) {

destinationFilePath = Https.getFilenameFromUrl(this.url);

}

return new Promise((resolve, reject) => {

this.getOrCreateCloseCallback();

this.response.toFileAsync(

destinationFilePath,

this.getCallback(resolve, reject)

);

}).then(() => {

this.file = File.fromPath(destinationFilePath);

return this.file;

});

}

}

export function enableSSLPinning(options: Https.HttpsSSLPinningOptions) {

if (!peer.host && !peer.certificate) {

let certificate: string;

let inputStream: java.io.FileInputStream;

try {

let file = new java.io.File(options.certificate);

inputStream = new java.io.FileInputStream(file);

let x509Certificate = java.security.cert.CertificateFactory.getInstance(

"X509"

).generateCertificate(inputStream);

peer.x509Certificate = x509Certificate;

certificate = okhttp3.CertificatePinner.pin(x509Certificate);

inputStream.close();

} catch (error) {

try {

if (inputStream) {

inputStream.close();

}

} catch (e) {}

console.error("nativescript-https > enableSSLPinning error", error);

return;

}

peer.host = options.host;

peer.commonName = options.commonName || options.host;

peer.certificate = certificate;

if (options.allowInvalidCertificates === true) {

peer.allowInvalidCertificates = true;

}

if (options.validatesDomainName === false) {

peer.validatesDomainName = false;

}

}

peer.enabled = true;

getClient(true);

}

export function disableSSLPinning() {

peer.enabled = false;

getClient(true);

}

let Client: okhttp3.OkHttpClient;

let cookieJar: com.nativescript.https.QuotePreservingCookieJar;

let cookieManager: java.net.CookieManager;

function getClient(

reload: boolean = false,

timeout: number = 10

): okhttp3.OkHttpClient {

if (!Client) {

// ssl error fix on KitKat. Only need to be done once.

// client will be null only onced so will run only once

const version = android.os.Build.VERSION.SDK_INT;

if (version >= 16 && version < 22) {

java.security.Security.insertProviderAt(

(org as any).conscrypt.Conscrypt.newProvider(),

1

);

}

}

// if (!Client) {

// Client = new okhttp3.OkHttpClient()

// }

// if (Client) {

// Client.connectionPool().evictAll()

// Client = null

// }

if (Client && reload === false) {

if (timeout === _timeout) {

return Client;

} else {

return Client.newBuilder()

.connectTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS)

.writeTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS)

.readTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS)

.build();

}

}

if (!cookieJar) {

cookieManager = new java.net.CookieManager();

cookieManager.setCookiePolicy(java.net.CookiePolicy.ACCEPT_ALL);

cookieJar = new com.nativescript.https.QuotePreservingCookieJar(

cookieManager

);

}

let client = new okhttp3.OkHttpClient.Builder();

if (peer.enabled === true) {

if (peer.host || peer.certificate) {

let spec = okhttp3.ConnectionSpec.MODERN_TLS;

client.connectionSpecs(java.util.Collections.singletonList(spec));

let pinner = new okhttp3.CertificatePinner.Builder();

pinner.add(peer.host, [peer.certificate]);

client.certificatePinner(pinner.build());

if (peer.allowInvalidCertificates === false) {

try {

let x509Certificate = peer.x509Certificate;

let keyStore = java.security.KeyStore.getInstance(

java.security.KeyStore.getDefaultType()

);

keyStore.load(null, null);

// keyStore.setCertificateEntry(peer.host, x509Certificate)

keyStore.setCertificateEntry("CA", x509Certificate);

// let keyManagerFactory = javax.net.ssl.KeyManagerFactory.getInstance(

// javax.net.ssl.KeyManagerFactory.getDefaultAlgorithm()

// )

let keyManagerFactory = javax.net.ssl.KeyManagerFactory.getInstance(

"X509"

);

keyManagerFactory.init(keyStore, null);

let keyManagers = keyManagerFactory.getKeyManagers();

let trustManagerFactory = javax.net.ssl.TrustManagerFactory.getInstance(

javax.net.ssl.TrustManagerFactory.getDefaultAlgorithm()

);

trustManagerFactory.init(keyStore);

let sslContext = javax.net.ssl.SSLContext.getInstance(

"TLS"

);

sslContext.init(

keyManagers,

trustManagerFactory.getTrustManagers(),

new java.security.SecureRandom()

);

client.sslSocketFactory(sslContext.getSocketFactory());

} catch (error) {

console.error(

"nativescript-https > client.allowInvalidCertificates error",

error

);

}

}

if (peer.validatesDomainName === true) {

try {

client.hostnameVerifier(

new javax.net.ssl.HostnameVerifier({

verify: (

hostname: string,

session: javax.net.ssl.SSLSession

): boolean => {

let pp = session.getPeerPrincipal().getName();

let hv = javax.net.ssl.HttpsURLConnection.getDefaultHostnameVerifier();

if (

peer.commonName &&

peer.commonName[0] === "*"

) {

return (

hv.verify(peer.host, session) &&

hostname.indexOf(peer.host) > -1 &&

hostname.indexOf(

session.getPeerHost()

) > -1 &&

pp.indexOf(peer.commonName) !== -1

);

} else {

return (

hv.verify(peer.host, session) &&

peer.host === hostname &&

peer.host === session.getPeerHost() &&

pp.indexOf(peer.host) !== -1

);

}

},

})

);

} catch (error) {

console.error(

"nativescript-https > client.validatesDomainName error",

error

);

}

}

} else {

console.warn(

"nativescript-https > Undefined host or certificate. SSL pinning NOT working!!!"

);

}

}

_timeout = timeout;

client

.connectTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS)

.writeTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS)

.readTimeout(timeout, java.util.concurrent.TimeUnit.SECONDS);

if (cache) {

client.cache(cache);

}

if (cookieJar) {

client.cookieJar(cookieJar);

}

Client = client.build();

return Client;

}

function cancelRequest(tag: string, client: okhttp3.OkHttpClient) {

if (notClosedResponses[tag]) {

notClosedResponses[tag].cancel();

return;

}

const dispatcher = client.dispatcher();

//When you want to cancel:

//A) go through the queued calls and cancel if the tag matches:

if (dispatcher.queuedCallsCount() > 0) {

const queuedCalls = dispatcher.queuedCalls();

for (let index = 0; index < queuedCalls.size(); index++) {

const call = queuedCalls.get(index);

if (call.request().tag() === tag) {

call.cancel();

return;

}

}

}

//B) go through the running calls and cancel if the tag matches:

if (dispatcher.runningCallsCount() > 0) {

const runningCalls = dispatcher.runningCalls();

for (let index = 0; index < runningCalls.size(); index++) {

const call = runningCalls.get(index);

if (call.request().tag() === tag) {

call.cancel();

return;

}

}

}

}

let CALL_ID = 0;

let notClosedResponses: {

[k: string]: com.nativescript.https.OkHttpResponse;

} = {};

let OkHttpResponse: typeof com.nativescript.https.OkHttpResponse;

export function createRequest(

opts: Https.HttpsRequestOptions

): Https.HttpsRequest {

let client = getClient(false);

let request = new okhttp3.Request.Builder();

request.url(opts.url);

if (opts.headers) {

Object.keys(opts.headers).forEach((key) =>

request.addHeader(key, opts.headers[key] as any)

);

}

if (opts.cachePolicy) {

let cacheControlBuilder = new okhttp3.CacheControl.Builder();

switch (opts.cachePolicy) {

case "noCache":

cacheControlBuilder = cacheControlBuilder.noStore();

break;

case "onlyCache":

cacheControlBuilder = cacheControlBuilder.onlyIfCached();

break;

case "ignoreCache":

cacheControlBuilder = cacheControlBuilder.noCache();

break;

}

request.cacheControl(cacheControlBuilder.build());

}

const methods = {

GET: "get",

HEAD: "head",

DELETE: "delete",

POST: "post",

PUT: "put",

PATCH: "patch",

};

let type;

if (

["GET", "HEAD"].indexOf(opts.method) !== -1 ||

(opts.method === "DELETE" &&

!isDefined(opts.body) &&

!isDefined(opts.content))

) {

request[methods[opts.method]]();

} else {

type =

opts.headers && opts.headers["Content-Type"]

? <string>opts.headers["Content-Type"]

: "application/json";

const MEDIA_TYPE = okhttp3.MediaType.parse(type);

let okHttpBody: okhttp3.RequestBody;

if (type.startsWith("multipart/form-data")) {

let builder = new okhttp3.MultipartBody.Builder();

builder.setType(MEDIA_TYPE);

(opts.body as Https.HttpsFormDataParam[]).forEach((param) => {

if (param.fileName && param.contentType) {

const MEDIA_TYPE = okhttp3.MediaType.parse(

param.contentType

);

builder.addFormDataPart(

param.parameterName,

param.fileName,

okhttp3.RequestBody.create(MEDIA_TYPE, param.data)

);

} else {

builder.addFormDataPart(param.parameterName, param.data);

}

});

okHttpBody = builder.build();

} else {

let body;

if (opts.body) {

try {

body = JSON.stringify(opts.body);

} catch (ignore) {}

} else if (opts.content) {

body = opts.content;

}

okHttpBody = okhttp3.RequestBody.create(

okhttp3.MediaType.parse(type),

body

);

}

request[methods[opts.method]](okHttpBody);

}

const tag = `okhttp_request_${CALL_ID++}`;

const call = client.newCall(request.tag(tag).build());

// We have to allow networking on the main thread because larger responses will crash the app with an NetworkOnMainThreadException.

// Note that it would probably be better to offload it to a Worker or (natively running) AsyncTask.

// Also note that once set, this policy remains active until the app is killed.

if (opts.useLegacy === false && opts.allowLargeResponse) {

android.os.StrictMode.setThreadPolicy(

android.os.StrictMode.ThreadPolicy.LAX

);

}

return {

nativeRequest: call,

cancel: () => cancelRequest(tag, client),

run(resolve, reject) {

call.enqueue(

new okhttp3.Callback({

onResponse(call, response) {

const responseBody = response.body();

const message = response.message();

const statusCode = response.code();

const getHeaders = function () {

const heads = response.headers();

let headers = {};

// let heads: okhttp3.Headers = resp.headers();

let i: number,

len: number = heads.size();

for (i = 0; i < len; i++) {

let key = heads.name(i);

headers[key] = heads.value(i);

}

return headers;

};

if (opts.useLegacy) {

if (!OkHttpResponse) {

OkHttpResponse =

com.nativescript.https.OkHttpResponse;

}

const nResponse = new OkHttpResponse(responseBody);

if (opts.onProgress) {

nResponse.progressCallback = new OkHttpResponse.OkHttpResponseProgressCallback(

{

onProgress: opts.onProgress,

}

);

}

resolve({

response,

content: new HttpsResponse(

nResponse,

tag,

opts.url

),

statusCode,

reason: message,

get headers() {

return getHeaders();

},

});

} else {

resolve({

response,

content: responseBody.string(),

reason: message,

statusCode,

get headers() {

return getHeaders();

},

});

}

},

onFailure(task, error) {

reject(error);

},

})

);

},

};

}

export function request(opts: Https.HttpsRequestOptions) {

return new Promise((resolve, reject) => {

try {

createRequest(opts).run(resolve, reject);

} catch (error) {

reject(error);

}

});

}