autobots-lib/lib/QCRNetworkModule.js

汽车人基础库

'use strict';
import { NativeModules, Platform } from 'react-native';
import Utils from "../util/utils";

var QCRRNNetworkModule = NativeModules.QCRRNNetworkModule;

var NetworkModule = {

  async getCacheData(cacheKey: String) {
    if (QCRRNNetworkModule && QCRRNNetworkModule.getCacheData) {
      try {
        return await QCRRNNetworkModule.getCacheData(cacheKey, Platform.OS === 'android' ? null : {});
      } catch (error) {
        console.error('getCacheData发生了异常：' + error);
        return '';
      }
    } else {
      return '';
    }
  },

  writeCacheData(cacheKey: String, params: Object, isAdd: boolean, expireTime: number) {
    if (QCRRNNetworkModule && QCRRNNetworkModule.writeCache) {
      const isAddNumber = Platform.OS === 'android' ? (isAdd ? 1 : 0) : isAdd;
      if (Platform.OS === 'android' && typeof params === 'object') {
        QCRRNNetworkModule.writeCache(cacheKey, JSON.stringify(params), isAddNumber, expireTime);
      } else {
        QCRRNNetworkModule.writeCache(cacheKey, params, isAddNumber, expireTime);
      }
    }
  },

  clearCacheData(cacheKey: String) {
    if (QCRRNNetworkModule && QCRRNNetworkModule.clearCache) {
      QCRRNNetworkModule.clearCache(cacheKey);
    }
  },

  fetchList(url: String, config: Object, params: Object, cacheFunction: Function) {
    return new Promise(function (resolve, reject) {
      if (QCRRNNetworkModule && (!Utils.isChooseOldNetApi(params) || QCRRNNetworkModule.postList)) {
        asyncListFetch(url, config, params, cacheFunction, resolve, reject);
      } else {
        asyncPostJsonFetch(url, config, params, resolve, reject);
      }
    });
  },

  fetch(url: String, config: Object, params: Object, cacheFunction: Function) {
    return new Promise(function (resolve, reject) {
      if (QCRRNNetworkModule && !Utils.isChooseOldNetApi(params)) {
        asyncFetch(url, config, params, cacheFunction, resolve, reject);
      } else {
        asyncFromFetch(url, config, params, resolve, reject);
      }
    });
  },

  get(url: String, headers: Object, params: Object) {
    let requestUrl = url;
    if (params && Object.keys(params).length > 0) {
      if (requestUrl.indexOf('?') >= 0) {
        requestUrl += '&'
      } else {
        requestUrl += '?'
      }
      for (let key in params) {
        requestUrl += `${key}=${params[key]}`
      }
    }
    return new Promise(function (resolve, reject) {
      if (QCRRNNetworkModule) {
        asyncGet(requestUrl, headers, resolve, reject);
      } else {
        asyncGetFromFetch(requestUrl, headers, resolve, reject);
      }
    });
  },

  postForm(url: String, header: Object, form: Object) {
    return new Promise(function (resolve, reject) {
      if (QCRRNNetworkModule) {
        asyncPostForm(url, header, form, resolve, reject);
      } else {
        asyncPostFormFetch(url, header, form, resolve, reject);
      }
    });
  },

  postJson(url: String, header: Object, json: Object) {
    return new Promise(function (resolve, reject) {
      if (QCRRNNetworkModule) {
        asyncPostJson(url, header, json, resolve, reject);
      } else {
        asyncPostJsonFetch(url, header, json, resolve, reject);
      }
    });
  },

  postFile(url: String, header: Object, param: Object, files: Array) {
    return new Promise(function (resolve, reject) {
      if (QCRRNNetworkModule) {
        asyncPostFile(url, header, param, files, resolve, reject);
      } else {
        asyncPostFileFromFetch(url, header, param, files, resolve, reject);
      }
    });
  },

  downFile(url: String, fileName: String) {
    return new Promise(function (resolve, reject) {
      if (QCRRNNetworkModule) {
        asyncDownFile(url, fileName, resolve, reject);
      } else {
        asyncDownFileRN(url, fileName, resolve, reject);
      }
    });
  },

  cancel(url: String) {
    return new Promise(function (resolve, reject) {
      asyncCancel(url, resolve, reject);
    });
  },

  checkNetState(callback: Function) {
    QCRRNNetworkModule && QCRRNNetworkModule.checkNetState(callback);
  },

  getNetType(callback: Function) {
    QCRRNNetworkModule && QCRRNNetworkModule.getNetType(callback);
  },

};

async function asyncFetch(url: String, config: Object, params: Object, cacheFunction: Function, resolveCallback: Function, rejectCallback: Function) {
  let needReadCache = (config && config.method && config.method.indexOf('cache') >= 0) ? true : false;
  if (needReadCache && cacheFunction) {
    try {
      if (Platform.OS === 'android') {
        //处理body为form类型要将param全部字段转为字条串类型，与请求网络接口写缓存时类型一致
        if (params && config && config.headers) {
          if (!(config.headers['Content-Type'] && config.headers['Content-Type'].indexOf('application/json') >= 0)) {
            const stringFieldParams = {};
            Object.keys(params).forEach(key => {
              if (typeof params[key] !== 'undefined' && params[key] !== null) {
                stringFieldParams[key] = String(params[key]);
              }
            });
            params = stringFieldParams;
          }
        }
      }
      let response = await QCRRNNetworkModule.getCacheData(url, params);
      if (typeof response === 'string') {
        if (response.trim() != '') {
          response = JSON.parse(response);
          cacheFunction(response);
        }
      } else {
        cacheFunction(response);
      }
    } catch (error) {
      console.log('缓存结果出错：', error)
    }
  }

  try {
    var events;
    if (Platform.OS === 'ios') {
      events = await QCRRNNetworkModule.fetch(url, config, params);
    } else {//android
      try {
        //处理body为json类型
        let isJsonPost = false;
        if (config && config.headers) {
          if (config.headers['Content-Type'] && config.headers['Content-Type'].indexOf('application/json') >= 0) {
            //if(params && Object.keys(params).length !== 0){
            let jsonparam = {};
            jsonparam.json = params ? JSON.stringify(params) : {};
            config.body = jsonparam;
            isJsonPost = true;
          }
        }
        config = config || {}
        //处理body为form类型
        if (!isJsonPost) {
          config.headers = config.headers || {}
          config.headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8'
          // 将参数对象中的所有值转换为字符串类型，因为原生只按string类型来处理，否则有其它类型会报解析异常
          const stringifiedParams = {};
          if (params) {
            Object.keys(params).forEach(key => {
              if (typeof params[key] !== 'undefined' && params[key] !== null) {
                stringifiedParams[key] = String(params[key]);
              }
              // else {
              //   stringifiedParams[key] = ""; // 将undefined值设为""
              // }
            });
          }

          let formparam = {};
          formparam.form = JSON.stringify(stringifiedParams);
          config.body = formparam;
        }

        console.log('asyncFetch 配置信息：', config);
        events = await QCRRNNetworkModule.fetch(url, config);
        if (typeof events === 'string') {
          events = JSON.parse(events);
        }
      } catch (error) {
        rejectCallback(error);
      }
    }
    resolveCallback(events);
  } catch (error) {
    console.log('结果：', error)
    rejectCallback(error);
  }
}

async function asyncListFetch(url: String, config: Object, params: Object, cacheFunction: Function, resolveCallback: Function, rejectCallback: Function) {
  let needReadCache = (config && config.method && config.method.indexOf('cache') >= 0) ? true : false;
  if (needReadCache && cacheFunction) {
    try {
      if (Platform.OS === 'android') {
        //处理body为form类型要将param全部字段转为字条串类型，与请求网络接口写缓存时类型一致
        if (params && config && config.headers) {
          if (!(config.headers['Content-Type'] && config.headers['Content-Type'].indexOf('application/json') >= 0)) {
            const stringFieldParams = {};
            Object.keys(params).forEach(key => {
              if (typeof params[key] !== 'undefined' && params[key] !== null) {
                stringFieldParams[key] = String(params[key]);
              }
            });
            params = stringFieldParams;
          }
        }
      }
      let response = await QCRRNNetworkModule.getCacheData(url, []);
      if (typeof response === 'string') {
        if (response.trim() != '') {
          response = JSON.parse(response);
          cacheFunction(response);
        }
      } else {
        cacheFunction(response);
      }
    } catch (error) {
      console.log('缓存结果出错：', error)
    }
  }

  try {
    var events;
    if (Platform.OS === 'ios') {
      events = await QCRRNNetworkModule.postList(url, config, params, needReadCache);
    } else {//android
      try {
        //处理body为json类型
        let isJsonPost = false;
        if (config && config.headers) {
          if (config.headers['Content-Type'] && config.headers['Content-Type'].indexOf('application/json') >= 0) {
            //if(params && Object.keys(params).length !== 0){
            let jsonparam = {};
            jsonparam.json = params ? JSON.stringify(params) : {};
            config.body = jsonparam;
            isJsonPost = true;
          }
        }
        config = config || {}
        //处理body为form类型
        if (!isJsonPost) {
          config.headers = config.headers || {}
          config.headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8'
          // 将参数对象中的所有值转换为字符串类型，因为原生只按string类型来处理，否则有其它类型会报解析异常
          const stringifiedParams = {};
          if (params) {
            Object.keys(params).forEach(key => {
              if (typeof params[key] !== 'undefined' && params[key] !== null) {
                stringifiedParams[key] = String(params[key]);
              }
              // else {
              //   stringifiedParams[key] = ""; // 将undefined值设为""
              // }
            });
          }

          let formparam = {};
          formparam.form = JSON.stringify(stringifiedParams);
          config.body = formparam;
        }

        console.log('asyncFetch 配置信息：', config);
        events = await QCRRNNetworkModule.fetch(url, config);
        if (typeof events === 'string') {
          events = JSON.parse(events);
        }
      } catch (error) {
        rejectCallback(error);
      }
    }
    resolveCallback(events);
  } catch (error) {
    console.log('结果：', error)
    rejectCallback(error);
  }
}

async function asyncFromFetch(url: String, config: Object, params: Object, resolveCallback: Function, rejectCallback: Function) {
  try {
    let isJsonPost = false;
    if (config && config.headers) {
      if (config.headers['Content-Type'] && config.headers['Content-Type'].indexOf('application/json') >= 0) {
        config.body = params ? JSON.stringify(params) : {};
        isJsonPost = true;
      }
    }
    config = config || {}
    if (!isJsonPost) {
      config.headers = config.headers || {}
      config.headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8'
      let requestBody = '';
      for (let key in params) {
        requestBody += `${key}=${params[key] || ''}&`
      }
      config.body = requestBody.length > 0 ? requestBody.slice(0, -1) : ""
    }

    let requestMethod = (config.method && config.method.length > 0) ? config.method : 'get';
    if (config.method && config.method.length > 0 && config.method.indexOf('_cache') >= 0) {
      requestMethod = config.method.replace('_cache', '');
    }
    config.method = requestMethod;

    console.log('配置信息：', config);
    const response = await fetch(url, config);
    const json = await response.json();
    resolveCallback(json);
  } catch (error) {
    rejectCallback(error);
  }
}

async function asyncGet(url: String, header: Object, resolveCallback: Function, rejectCallback: Function) {
  try {
    var events;
    if (Platform.OS === 'ios') {
      events = await QCRRNNetworkModule.get(url, header);
    } else {
      events = await QCRRNNetworkModule.get(url, header, null);
      if (typeof events === 'string') {
        events = JSON.parse(events);
      }
    }
    resolveCallback(events);
  } catch (error) {
    rejectCallback(error);
  }
}

async function asyncGetFromFetch(url: String, header: Object, resolveCallback: Function, rejectCallback: Function) {
  try {
    var events = await fetch(url, { headers: header || {} })
    const json = await events.json();
    resolveCallback(json);
  } catch (error) {
    rejectCallback(error);
  }
}

async function asyncPostForm(url: String, headers: Object, form: Object, resolveCallback: Function, rejectCallback: Function) {
  try {
    console.log('--fetch--asyncPostForm url：', url);
    var events;
    if (Platform.OS === 'ios') {
      events = await QCRRNNetworkModule.postForm(url, headers, form);
    } else {//android
      try {
        headers = headers || {};
        headers['Content-Type'] = 'application/x-www-form-urlencoded; charset=utf-8';
        // 将参数对象中的所有值转换为字符串类型，因为原生只按string类型来处理，否则有其它类型会报解析异常
        const stringifiedForms = {};
        if (form) {
          Object.keys(form).forEach(key => {
            if (typeof form[key] !== 'undefined' && form[key] !== null) {
              stringifiedForms[key] = String(form[key]);
            }
            // else {
            //   stringifiedForms[key] = ""; // 将undefined值设为""
            // }
          });
        }
        console.log('--fetch--asyncPostForm 配置信息：', stringifiedForms);
        events = await QCRRNNetworkModule.postForm(url, headers, stringifiedForms);
        if (typeof events === 'string') {
          events = JSON.parse(events);
        }
      } catch (error) {
        rejectCallback(error);
      }
    }
    resolveCallback(events);

  } catch (error) {
    rejectCallback(error);
  }
}

async function asyncPostJson(url: String, headers: Object, json: Object, resolveCallback: Function, rejectCallback: Function) {
  try {
    console.log('--fetch--asyncPostJson url：', url);
    var events;
    if (Platform.OS === 'ios') {
      events = await QCRRNNetworkModule.postJSON(url, headers, json);
    } else {//android
      try {
        headers = headers || {};
        headers['Content-Type'] = 'application/json';
        headers['Accept'] = 'application/json';

        // let jsonparam = {};
        let jsonparam = json ? json : {};
        console.log('--fetch--asyncPostJson 配置信息：', jsonparam);
        events = await QCRRNNetworkModule.postJSON(url, headers, jsonparam);
        if (typeof events === 'string') {
          events = JSON.parse(events);
        }
      } catch (error) {
        rejectCallback(error);
      }
    }
    resolveCallback(events);
  } catch (error) {
    rejectCallback(error);
  }
}

async function asyncPostFormFetch(url: String, header: Object, params: Object, resolveCallback: Function, rejectCallback: Function) {
  try {
    let headerDic = header || {}
    headerDic['Content-Type'] = "application/x-www-form-urlencoded; charset=utf-8";
    let requestBody = '';
    if (params) {
      for (let key in params) {
        requestBody += `${key}=${params[key] || ''}&`
      }
      requestBody = requestBody.length > 0 ? requestBody.slice(0, -1) : ""
    }
    var events = await fetch(url, { method: 'POST', headers: headerDic, body: requestBody })
    const json = await events.json();
    resolveCallback(json);
  } catch (error) {
    rejectCallback(error);
  }
}

async function asyncPostJsonFetch(url: String, header: Object, params: Object, resolveCallback: Function, rejectCallback: Function) {
  try {
    let headerDic = header || {}
    headerDic['Content-Type'] = "application/json";
    var events = await fetch(url, { method: 'POST', headers: headerDic, body: JSON.stringify(params) })
    const json = await events.json();
    resolveCallback(json);
  } catch (error) {
    rejectCallback(error);
  }
}

// let file = {uri: params.path, type: 'application/octet-stream', name: 'image.jpg'};
async function asyncPostFile(url: String, header: Object, param: Object, files: Array, resolveCallback: Function, rejectCallback: Function) {
  try {
    var events = await QCRRNNetworkModule.postFile(url, header, param, files);
    resolveCallback(events);
  } catch (error) {
    rejectCallback(error);
  }
}

async function asyncPostFileFromFetch(url: String, header: Object, param: Object, files: Array, resolveCallback: Function, rejectCallback: Function) {
  try {
    let headerDic = JSON.parse(JSON.stringify(header));
    headerDic['Content-Type'] = 'multipart/form-data';

    const fd = new FormData()
    files.forEach((element, index) => {
      const fileKey = element['fileKey'];
      fd.append(fileKey, element)
    })
    for (var key in param) {
      fd.append(key, param[key]);
    }

    var events = await fetch(url, {
      method: 'POST',
      body: fd,
      headers: headerDic
    })
    const json = await events.json();
    resolveCallback(json);
  } catch (error) {
    rejectCallback(error);
  }
}

async function asyncDownFile(url: String, fileName: String, resolveCallback: Function, rejectCallback: Function) {
  try {
    var events = await QCRRNNetworkModule.downFile(url, fileName);
    resolveCallback(events);
  } catch (error) {
    rejectCallback(error);
  }
}

async function asyncDownFileRN(url: String, fileName: String, resolveCallback: Function, rejectCallback: Function) {
  let timestamp = (new Date()).getTime();//获取当前时间错
  let random = String(((Math.random() * 1000000) | 0))//六位随机数
  let dirs = Platform.OS === 'ios' ? RNFS.LibraryDirectoryPath : RNFS.ExternalDirectoryPath; //外部文件，共享目录的绝对路径（仅限android）
  const downloadDest = `${dirs}/${fileName}`;
  const formUrl = url;
  const options = {
    fromUrl: formUrl,
    toFile: downloadDest,
    background: true,
    begin: (res) => {
      console.log('begin', res);
      console.log('contentLength:', res.contentLength / 1024 / 1024, 'M');
    },
  };
  try {
    const ret = RNFS.downloadFile(options);
    ret.promise.then(res => {
      console.log('success', res);
      console.log('file://' + downloadDest)
      let promise = CameraRoll.saveToCameraRoll(downloadDest);
      promise.then(function (result) {
        resolveCallback(result);
      }).catch(function (error) {
        console.log('error', error);
        rejectCallback(new Error(error))
      });
    }).catch(err => {
      rejectCallback(new Error(err))
    });
  } catch (e) {
    rejectCallback(new Error(e))
  }
}

async function asyncCancel(url: String, resolveCallback: Function, rejectCallback: Function) {
  if (!QCRRNNetworkModule) {
    return;
  }
  try {
    var events = await QCRRNNetworkModule.cancel(url);
    resolveCallback(events);
  } catch (error) {
    rejectCallback(error);
  }
}

module.exports = NetworkModule;