asStreams<T> method

Stream<ResponseDates<T>> asStreams<T>()

Implementation

Stream<ResponseDates<T>> asStreams<T>() async* {
  //创建Stream监听,使用Controller的时候一定要close 否者会报错
  StreamController<ResponseDates<T>> controller =
      StreamController<ResponseDates<T>>();
  try {
    if (!RxDioConfig.instance.getCacheState()) {
      _cacheMode = CacheMode.DEFAULT;
    }
    //网络条件判断
    var connectivityResult = await (Connectivity().checkConnectivity());
    //判断缓存模型没有缓存
    switch (_cacheMode) {
      case CacheMode.DEFAULT:
      case CacheMode.NO_CACHE:
        //默认没有缓存
        NetworkManager.instance
            .request<T>(_url,
                params: _params,
                method: _httpMethod,
                host: _host,
                options: _options,
                cancelToken: _cancelToken)
            .then((data) {
          controller.add(
              ResponseDates<T>(ResponseTypes.NETWORK, _transformation(data)));
        }, onError: (error) {
          controller.add(ResponseDates(ResponseTypes.ERROR, null,
              error: error.toString(),
              statusCode: Constants.responseCodeNetworkError));
        });
        break;
      case CacheMode.REQUEST_FAILED_READ_CACHE:
        //先获取网络,当网络不存在的时候获取缓存数据
        if (connectivityResult == ConnectivityResult.mobile ||
            connectivityResult == ConnectivityResult.wifi) {
          NetworkManager.instance
              .request<T>(_url,
                  params: _params,
                  method: _httpMethod,
                  host: _host,
                  options: _options,
                  cancelToken: _cancelToken ??= CancelToken())
              .then((data) {
            if (data.runtimeType == T) {
              controller.add(ResponseDates(
                  ResponseTypes.NETWORK, _transformation(data)));
            }
          }, onError: (error) {
            controller.add(ResponseDates(ResponseTypes.ERROR, null,
                error: error.toString(),
                statusCode: Constants.responseCodeNetworkError));
          });
        } else {
          var cacheData = await RxDioConfig.instance
              .getCacheInterface()
              ?.getCache(_url, _params);
          if (cacheData != null) {
            if (cacheData.isNotEmpty) {
              //存在缓存返回缓存
              Map<String, dynamic> jsonData = json.decode(cacheData);
              BaseBean bean = BaseBean<T>.fromJson(jsonData);
              controller.add(ResponseDates(
                  ResponseTypes.CACHE, _transformation(bean.data)));
            } else {
              //不存在缓存返回错误
              controller.add(ResponseDates(ResponseTypes.CACHE, null,
                  error: Constants.error_01,
                  statusCode: Constants.responseCodeNoCache));
            }
          }
        }
        break;
      case CacheMode.FIRST_CACHE_THEN_REQUEST:
        if (connectivityResult == ConnectivityResult.mobile ||
            connectivityResult == ConnectivityResult.wifi) {
          //先获取缓存,在获取网络数据
          var cacheData = await RxDioConfig.instance
              .getCacheInterface()
              ?.getCache(_url, _params);
          if (cacheData != null) {
            if (cacheData.isNotEmpty) {
              //存在缓存返回缓存
              Map<String, dynamic> jsonData = json.decode(cacheData);
              BaseBean bean = BaseBean<T>.fromJson(jsonData);
              controller.add(ResponseDates(
                  ResponseTypes.CACHE, _transformation(bean.data)));
            }
            NetworkManager.instance
                .request<T>(_url,
                    params: _params,
                    method: _httpMethod,
                    host: _host,
                    options: _options,
                    cancelToken: _cancelToken)
                .then((data) {
              if (!controller.isClosed) {
                controller.add(ResponseDates(
                    ResponseTypes.NETWORK, _transformation(data)));
              }
            }, onError: (error) {
              if (!controller.isClosed) {
                controller.add(ResponseDates(ResponseTypes.ERROR, null,
                    error: error.toString(),
                    statusCode: Constants.responseCodeNetworkError));
              }
            });
          } else {
            //不存在缓存返回错误
            if (!controller.isClosed) {
              controller.add(ResponseDates(ResponseTypes.CACHE, null,
                  statusCode: Constants.responseCodeNoCache,
                  error: Constants.error_01));
            }
          }
          break;
        }
    }
    yield* controller.stream;
    controller.close();
  } on Exception catch (e) {
    log("Exception : $e \n");
  } finally {
    if (_cancelToken != null && _cancelToken!.isCancelled) {
      _cancelToken?.cancel();
    }
  }
}