HarmonyOSBaseLibs/src/main/ets/http/HttpHelper.ets

import { ArrayList, HashMap } from '@kit.ArkTS';
import http from '@ohos.net.http';
import { LogHelper } from '../../../../Index';
import { SZYXLocalStorageHelper } from '../utils/SZYXLocalStorageHelper';
import { SZYXLocalStorageKeys } from '../utils/SZYXLocalStorageKeys';
import { HttpHelperX, HttpParamsForm, HttpParamsGet, HttpParamsPost, HttpParamsUpload } from './HttpHelperX';
import { BusinessError } from '@kit.BasicServicesKit';
import { image } from '@kit.ImageKit';

type AnyResult = object | string | number | boolean | null | undefined;

interface Waiters {
  resolve: (v: AnyResult) => void;
  reject: (e: Error) => void;
}

interface PendingRequest {
  http?: http.HttpRequest
  waiters: Array<Waiters>
  seq: number
}


export class HttpHelper {
  private static instance: HttpHelper | null = null

  // 单例模式
  static get() {
    // 判断系统是否已经有单例了
    if (HttpHelper.instance === null) {
      HttpHelper.instance = new HttpHelper()
    }
    return HttpHelper.instance
  }

  //请求中队列
  private httpHandlerList = new HashMap<string, http.HttpRequest>();
  // 并发白名单，这个名单里面的api，重复请求不会取消
  private concurrentList = new ArrayList<string>();
  private pendingMap = new HashMap<string, PendingRequest>();
  private seqGen = 0;

  constructor() {
    SZYXLocalStorageHelper.storage.setOrCreate(SZYXLocalStorageKeys.HttpHandlerList, this.httpHandlerList)
    SZYXLocalStorageHelper.storage.setOrCreate(SZYXLocalStorageKeys.HttpHandlerListLength, this.httpHandlerList.length)
    try {
      this.concurrentList.clear()
    } catch (error) {
    }
  }

  /**
   * 添加并发白名单
   * @param apiNo
   */
  public addConcurrent(apiNo?: string) {
    if (!apiNo) {
      return
    }
    try {
      if (this.concurrentList.getIndexOf(apiNo) === -1) {
        this.concurrentList.add(apiNo)
      }
    } catch (error) {
    }
  }

  public addConcurrents(apiNo: string[]) {
    for (let apiNoElement of apiNo) {
      try {
        if (this.concurrentList.getIndexOf(apiNoElement) === -1) {
          this.concurrentList.add(apiNoElement)
        }
      } catch (error) {
      }
    }
  }

  public removeConcurrent(apiNo: string) {
    try {
      if (this.concurrentList.getIndexOf(apiNo) !== -1) {
        this.concurrentList.remove(apiNo)
      }
    } catch (error) {
    }
  }

  public removeConcurrents(apiNo: string[]) {
    for (let apiNoElement of apiNo) {
      try {
        if (this.concurrentList.getIndexOf(apiNoElement) !== -1) {
          this.concurrentList.remove(apiNoElement)
        }
      } catch (error) {
      }
    }
  }

  /**
   * postJson请求
   * @param url url地址
   * @param headers
   * @param apiNo 请求标识，取消请求或者去重使用|考虑做自动重试使用
   * @returns
   */
  public postJson<T>(params: HttpParamsPost, apiNo?: string, showLog?: boolean): Promise<T> {
    return new Promise<T>((resolve, reject) => {

      let httpRequest = http.createHttp();
      const key = apiNo ?? params.url
      const pending = this.setHandler(key, httpRequest, {
        resolve: (v: AnyResult) => resolve(v as T),
        reject: (e: Error) => reject(e)
      })

      const header = HttpHelperX.getHeaders("application/json;charset=UTF-8", params.headers)

      if (showLog) {
        LogHelper.debug(`postJson：${apiNo}\n`, JSON.stringify(params))
      }
      httpRequest.request(HttpHelperX.getUrl(params.url, params.query), {
        method: http.RequestMethod.POST,
        connectTimeout: 60000,
        readTimeout: 60000,
        header: header,
        extraData: params.data,
        usingCache: false,
      }).then((data: http.HttpResponse) => {
        const latest = this.pendingMap.get(key)
        if (showLog && (!pending || (latest && latest.seq === pending.seq))) {
          LogHelper.debug(`${apiNo}:\n ${data.result as string}`)
          LogHelper.print(data)
        }

        if (data.responseCode === 200) {
          const result = (typeof data.result === 'string' ? JSON.parse(data.result) : data.result) as T

          if (!pending) {
            resolve(result)
          } else {
            if (!latest || latest.seq !== pending.seq) {
              return
            }
            const result1 = result as AnyResult
            latest.waiters.forEach(w => w.resolve(result1))
          }
        } else {
          const err: Error = new Error()
          err.name = data.responseCode.toString()
          err.message = '服务异常'
          if (!pending) {
            reject(err)
          } else {
            if (!latest || latest.seq !== pending.seq) {
              return
            }
            latest.waiters.forEach(w => w.reject(err))
          }
        }

      }).catch((err: Error) => {

        let e = err
        if (err.message === 'Failed writing received data to disk/application') {
          e.name = 'cancel'
          e.message = err.message
        }

        if (!pending) {
          LogHelper.error(JSON.stringify({ err: err, url: params.url, }))
          reject(e)
        } else {
          const latest = this.pendingMap.get(key)
          if (!latest || latest.seq !== pending.seq) {
            return
          }
          LogHelper.error(JSON.stringify({ err: err, url: params.url, }))
          latest.waiters.forEach(w => w.reject(e))
        }
      }).finally(() => {

        if (pending) {
          const latest = this.pendingMap.get(key)
          if (latest && latest.seq === pending.seq) {
            this.pendingMap.remove(key)
            this.httpHandlerList.remove(key)
          }
        } else {
          this.httpHandlerList.remove(key)
        }

        SZYXLocalStorageHelper.storage.setOrCreate(SZYXLocalStorageKeys.HttpHandlerList, this.httpHandlerList)
        SZYXLocalStorageHelper.storage.setOrCreate(
          SZYXLocalStorageKeys.HttpHandlerListLength,
          this.httpHandlerList.length
        )
      })
    })
  }

  setHandler(key: string, httpRequest: http.HttpRequest, waiters: Waiters): PendingRequest | null {
    // 白名单：完全绕过
    if (this.concurrentList.getIndexOf(key) !== -1) {
      return null
    }
    if (this.seqGen > 99999) {
      this.seqGen = 0
    }
    const seq = ++this.seqGen
    let pending = this.pendingMap.get(key)

    if (!pending) {
      pending = {
        waiters: [waiters],
        seq,
        http: httpRequest
      }
      this.pendingMap.set(key, pending)
    } else {
      // cancel 旧请求
      const h = pending.http
      pending = {
        waiters: [...pending.waiters, waiters],
        seq,
        http: httpRequest
      }
      this.pendingMap.set(key, pending)
      h?.destroy()
    }

    this.httpHandlerList.set(key, httpRequest)

    SZYXLocalStorageHelper.storage.setOrCreate(SZYXLocalStorageKeys.HttpHandlerList, this.httpHandlerList)
    SZYXLocalStorageHelper.storage.setOrCreate(
      SZYXLocalStorageKeys.HttpHandlerListLength,
      this.httpHandlerList.length
    )
    return pending
  }


  /**
   * postForm请求
   * @param url url地址
   * @param headers
   * @param apiNo 请求标识，取消请求或者去重使用|考虑做自动重试使用
   * @returns
   */
  public postForm<T>(params: HttpParamsForm, apiNo?: string, showLog?: boolean): Promise<T> {

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

      let httpRequest = http.createHttp();
      const key = apiNo ?? params.url
      const pending = this.setHandler(key, httpRequest, {
        resolve: (v: AnyResult) => resolve(v as T),
        reject: (e: Error) => reject(e)
      })

      const header = HttpHelperX.getHeaders("application/x-www-form-urlencoded;charset=UTF-8", params.headers)
      let data = HttpHelperX.getContent(params.data)

      if (showLog) {
        LogHelper.debug(`postForm：${apiNo}\n`, JSON.stringify(params))
      }

      httpRequest.request(HttpHelperX.getUrl(params.url, params.query), {
        method: http.RequestMethod.POST,
        connectTimeout: 20000,
        readTimeout: 20000,
        header: header,
        usingCache: false,
        extraData: data ? encodeURI(data) : undefined
      })
        .then((data: http.HttpResponse) => {
          const latest = this.pendingMap.get(key)
          if (showLog && (!pending || (latest && latest.seq === pending.seq))) {
            LogHelper.debug(`${apiNo}:\n ${data.result as string}`)
            LogHelper.print(data)
          }

          if (data.responseCode === 200) {
            const result = (typeof data.result === 'string' ? JSON.parse(data.result) : data.result) as T

            if (!pending) {
              resolve(result)
            } else {
              if (!latest || latest.seq !== pending.seq) {
                return
              }
              const result1 = result as AnyResult
              latest.waiters.forEach(w => w.resolve(result1))
            }
          } else {
            const err: Error = new Error()
            err.name = data.responseCode.toString()
            err.message = '服务异常'
            if (!pending) {
              reject(err)
            } else {
              if (!latest || latest.seq !== pending.seq) {
                return
              }
              latest.waiters.forEach(w => w.reject(err))
            }
          }
        }).catch((err: Error) => {

        let e = err
        if (err.message === 'Failed writing received data to disk/application') {
          e.name = 'cancel'
          e.message = err.message
        }

        if (!pending) {
          LogHelper.error(JSON.stringify({ err: err, url: params.url, }))
          reject(e)
        } else {
          const latest = this.pendingMap.get(key)
          if (!latest || latest.seq !== pending.seq) {
            return
          }
          LogHelper.error(JSON.stringify({ err: err, url: params.url, }))
          latest.waiters.forEach(w => w.reject(e))
        }
      }).finally(() => {

        if (pending) {
          const latest = this.pendingMap.get(key)
          if (latest && latest.seq === pending.seq) {
            this.pendingMap.remove(key)
            this.httpHandlerList.remove(key)
          }
        } else {
          this.httpHandlerList.remove(key)
        }

        SZYXLocalStorageHelper.storage.setOrCreate(SZYXLocalStorageKeys.HttpHandlerList, this.httpHandlerList)
        SZYXLocalStorageHelper.storage.setOrCreate(
          SZYXLocalStorageKeys.HttpHandlerListLength,
          this.httpHandlerList.length
        )
      });
    });

  }


  /**
   * get请求
   * @param url url地址
   * @param data 请求参数
   * @param headers
   * @param apiNo 请求标识，取消请求或者去重使用|考虑做自动重试使用
   * @returns
   */
  public get<T>(params: HttpParamsGet, apiNo?: string, showLog?: boolean): Promise<T> {

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

      let httpRequest = http.createHttp();
      const key = apiNo ?? params.url
      const pending = this.setHandler(key, httpRequest, {
        resolve: (v: AnyResult) => resolve(v as T),
        reject: (e: Error) => reject(e)
      })

      if (showLog) {
        LogHelper.debug(`GET：${apiNo}\n`, HttpHelperX.getUrl(params.url, params.query) + '\n',
          JSON.stringify(params.headers))
      }

      httpRequest.request(HttpHelperX.getUrl(params.url, params.query), {
        method: http.RequestMethod.GET,
        connectTimeout: 20000,
        readTimeout: 20000,
        header: params.headers,
        usingCache: false,
        // extraData: params.data
      })
        .then((data: http.HttpResponse) => {
          const latest = this.pendingMap.get(key)
          if (showLog && (!pending || (latest && latest.seq === pending.seq))) {
            LogHelper.debug(`${apiNo}:\n ${data.result as string}`)
            LogHelper.print(data)
          }

          if (data.responseCode === 200) {
            const result = (typeof data.result === 'string' ? JSON.parse(data.result) : data.result) as T

            if (!pending) {
              resolve(result)
            } else {
              if (!latest || latest.seq !== pending.seq) {
                return
              }
              const result1 = result as AnyResult
              latest.waiters.forEach(w => w.resolve(result1))
            }
          } else {
            const err: Error = new Error()
            err.name = data.responseCode.toString()
            err.message = '服务异常'
            if (!pending) {
              reject(err)
            } else {
              if (!latest || latest.seq !== pending.seq) {
                return
              }
              latest.waiters.forEach(w => w.reject(err))
            }
          }
        }).catch((err: Error) => {

        let e = err
        if (err.message === 'Failed writing received data to disk/application') {
          e.name = 'cancel'
          e.message = err.message
        }

        if (!pending) {
          LogHelper.error(JSON.stringify({ err: err, url: params.url, }))
          reject(e)
        } else {
          const latest = this.pendingMap.get(key)
          if (!latest || latest.seq !== pending.seq) {
            return
          }
          LogHelper.error(JSON.stringify({ err: err, url: params.url, }))
          latest.waiters.forEach(w => w.reject(e))
        }
      }).finally(() => {

        if (pending) {
          const latest = this.pendingMap.get(key)
          if (latest && latest.seq === pending.seq) {
            this.pendingMap.remove(key)
            this.httpHandlerList.remove(key)
          }
        } else {
          this.httpHandlerList.remove(key)
        }

        SZYXLocalStorageHelper.storage.setOrCreate(SZYXLocalStorageKeys.HttpHandlerList, this.httpHandlerList)
        SZYXLocalStorageHelper.storage.setOrCreate(
          SZYXLocalStorageKeys.HttpHandlerListLength,
          this.httpHandlerList.length
        )
      });
    });

  }

  /**
   * postJson请求
   * @param url url地址
   * @param headers
   * @param apiNo 请求标识，取消请求或者去重使用|考虑做自动重试使用
   * @returns
   */
  public upload<T>(params: HttpParamsUpload, apiNo?: string, showLog?: boolean): Promise<T> {

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

      let httpRequest = http.createHttp();
      const key = apiNo ?? params.url
      const pending = this.setHandler(key, httpRequest, {
        resolve: (v: AnyResult) => resolve(v as T),
        reject: (e: Error) => reject(e)
      })

      if (showLog) {
        LogHelper.debug(`postJson：${apiNo}\n`, JSON.stringify(params))
      }
      httpRequest.on("dataSendProgress", (data: http.DataSendProgressInfo) => {
        if (showLog) {
          LogHelper.debug(`${apiNo}:\n${JSON.stringify(data)}`)
        }
        params.onProgress && params.onProgress(data.sendSize, data.totalSize)
      });
      httpRequest.request(HttpHelperX.getUrl(params.url, params.query), {
        method: http.RequestMethod.POST,
        connectTimeout: 20000,
        readTimeout: 20000,
        header: HttpHelperX.getHeaders("multipart/form-data", params.headers),
        usingCache: false,
        multiFormDataList: params.data,
      })
        .then((data: http.HttpResponse) => {
          const latest = this.pendingMap.get(key)
          if (showLog && (!pending || (latest && latest.seq === pending.seq))) {
            LogHelper.debug(`${apiNo}:\n ${data.result as string}`)
            LogHelper.print(data)
          }
          if (data.responseCode === 200) {
            const result = (typeof data.result === 'string' ? JSON.parse(data.result) : data.result) as T

            if (!pending) {
              resolve(result)
            } else {
              if (!latest || latest.seq !== pending.seq) {
                return
              }
              const result1 = result as AnyResult
              latest.waiters.forEach(w => w.resolve(result1))
            }
          } else {
            const err: Error = new Error()
            err.name = data.responseCode.toString()
            err.message = '服务异常'
            if (!pending) {
              reject(err)
            } else {
              if (!latest || latest.seq !== pending.seq) {
                return
              }
              latest.waiters.forEach(w => w.reject(err))
            }
          }
        }).catch((err: Error) => {

        let e = err
        if (err.message === 'Failed writing received data to disk/application') {
          e.name = 'cancel'
          e.message = err.message
        }

        if (!pending) {
          LogHelper.error(JSON.stringify({ err: err, url: params.url, }))
          reject(e)
        } else {
          const latest = this.pendingMap.get(key)
          if (!latest || latest.seq !== pending.seq) {
            return
          }
          LogHelper.error(JSON.stringify({ err: err, url: params.url, }))
          latest.waiters.forEach(w => w.reject(e))
        }
      }).finally(() => {

        if (pending) {
          const latest = this.pendingMap.get(key)
          if (latest && latest.seq === pending.seq) {
            this.pendingMap.remove(key)
            this.httpHandlerList.remove(key)
          }
        } else {
          this.httpHandlerList.remove(key)
        }

        SZYXLocalStorageHelper.storage.setOrCreate(SZYXLocalStorageKeys.HttpHandlerList, this.httpHandlerList)
        SZYXLocalStorageHelper.storage.setOrCreate(
          SZYXLocalStorageKeys.HttpHandlerListLength,
          this.httpHandlerList.length
        )
      });
    });

  }

  clearHttp() {
    for (let handler of this.httpHandlerList.keys()) {
      this.cancel(handler)
    }

  }

  cancel(apiNo: string) {
    try {
      if (this.httpHandlerList.hasKey(apiNo)) {
        this.httpHandlerList.get(apiNo).destroy()
        this.httpHandlerList.remove(apiNo)
        SZYXLocalStorageHelper.storage.setOrCreate(SZYXLocalStorageKeys.HttpHandlerList, this.httpHandlerList)
        SZYXLocalStorageHelper.storage.setOrCreate(SZYXLocalStorageKeys.HttpHandlerListLength,
          this.httpHandlerList.length)
      }
    } catch (error) {
    }
  }

  downloadImage(url: string): Promise<image.ImageSource> {
    return new Promise<image.ImageSource>((resolve, reject) => {
      http.createHttp()
        .request(url, (error: BusinessError, data: http.HttpResponse) => {
          if (error) {
            reject(error)
            return
          }
          if (data.result instanceof ArrayBuffer) {
            let imageData: ArrayBuffer = data.result as ArrayBuffer;
            let imageSource: image.ImageSource = image.createImageSource(imageData);
            resolve(imageSource)
          } else {
            reject(new Error('下载图片失败'))
          }
        })
    })
  }
}