salk52 / flutter-file-upload-download Goto Github PK

 _asyncFileUpload(String text, File file, int i, DocProviderBLoC doc) async {
    final httpClient = getHttpClient();

    var endPoint = 'uploaddocument';

    final request =
        await httpClient.postUrl(Uri.parse("${baseUrl()}$endPoint"));

    int byteCount = 0;

    request.headers.add('auth-key', UserLocalPreference.getUserToken()!);

    var requestMultipart =
        http.MultipartRequest("POST", Uri.parse("${baseUrl()}$endPoint"));

    // requestMultipart.headers['auth-key'] = UserLocalPreference.getUserToken()!;

    //add multipart to request
    requestMultipart.fields['subcategory_id'] =
        doc.docData[i].subcategoryId.toString();
    requestMultipart.fields['doc_defination_id'] =
        doc.docData[i].docDefinationId.toString();

    requestMultipart.fields['name'] = doc.docData[i].name;
    requestMultipart.fields['password'] = password ?? '';
    requestMultipart.fields['application_id'] =
        UserLocalPreference.getApplicationId()!;

    debugPrint('appplication id -> ${UserLocalPreference.getApplicationId()!}');
    var pic = await http.MultipartFile.fromPath("files[]", file.path);
    requestMultipart.files.add(pic);
    var msStream = requestMultipart.finalize();

    var totalByteLength = requestMultipart.contentLength;

    request.contentLength = totalByteLength;


    request.headers.set(HttpHeaders.contentTypeHeader,
        requestMultipart.headers[HttpHeaders.contentTypeHeader]!);

    Stream<List<int>> streamUpload =
        msStream.transform(StreamTransformer.fromHandlers(
      handleData: (data, sink) {
        debugPrint('Percentage -> ${data.length}');
        sink.add(data);

        byteCount += data.length;

        var percentage = byteCount / totalByteLength * 100;

        loadingController.forward();
        debugPrint('Total ByteCount => ${percentage.floor()} % ');

        debugPrint('index => $i');
        setState(() {
          valuePercentage = percentage / 100;
          fileDownloadProgress[i] = valuePercentage;
          debugPrint('downloadProgress => ${fileDownloadProgress[i]}');
        });

        //uploadedPercentage.add(percentage.floor().toDouble());
      },
      handleError: (error, stack, sink) {
        throw error;
      },
      handleDone: (sink) {
        sink.close();
        // UPLOAD DONE;
      },
    ));

    await request.addStream(streamUpload);
    final httpResponse = await request.close();

    var statusCode = httpResponse.statusCode;
    var data = httpResponse.toString();

    debugPrint('Status ee code => $statusCode   Data => $data');

    if (statusCode ~/ 100 != 2) {
      password = '';
      throw Exception(
          'Error uploading file, Status code: ${httpResponse.statusCode}');
    } else {
      var dataResponse = await readResponseAsString(httpResponse);

      UploadDocumentResponse response =
          UploadDocumentResponse.fromJson(jsonDecode(dataResponse));

      debugPrint('dataResponse => ${response.message}   ');

      if (response.status!.contains('error')) {
        Utils.showSnackBar(
          title: response.status!,
          message: response.message!,
          context: context,
          bgColor: AppColors.errorBgColor,
          darkColor: AppColors.errorDarkColor,
        );
      } else {
        // ignore: use_build_context_synchronously
        var docProvider = Provider.of<DocProviderBLoC>(context, listen: false);
        debugPrint('file -> ${file.path}');
        docImage[i] = file.path;

        setState(() {
          docProvider.docData[i].isAllUploaded = true;
        });

        debugPrint('dataResponse => ${docProvider.docData[i].toJson()}   ');
        debugPrint(
            'getAllDocStatus => ${getAllDocStatus(docProvider.docData)}   ');
      }
    }
  }

flutter: Timestamp: 27/05/2020 10:16:40
flutter: progress: 0.0000038115517316420344 (74/19414665)
flutter: Timestamp: 27/05/2020 10:16:40
flutter: progress: 0.00000880777494744308 (171/19414665)
flutter: Timestamp: 27/05/2020 10:16:40
flutter: progress: 0.999995982418445 (19414587/19414665)
flutter: Timestamp: 27/05/2020 10:16:40
flutter: progress: 0.9999960854333567 (19414589/19414665)
flutter: Timestamp: 27/05/2020 10:16:40
flutter: progress: 1.0 (19414665/19414665)

print('progress: ${byteCount / totalByteLength} ($byteCount/$totalByteLength)');

  var multipart = http.MultipartFile.fromBytes(
    'file',
    attachment.file.buffer.asUint8List(),
    filename: attachment.name,
    contentType: MediaType.parse(attachment.contentType),
  );

static Future<Attachment> fileUploadMultipart({
  String url,
  Attachment attachment,
  OnUploadProgressCallback onUploadProgress,
}) async {
  assert(attachment != null);
  final httpClient = getHttpClient();

  final request = await httpClient.putUrl(Uri.parse(url));

  int byteCount = 0;

  var multipart = http.MultipartFile.fromBytes(
    'file',
    attachment.file.buffer.asUint8List(),
    filename: attachment.name,
    contentType: MediaType.parse(attachment.contentType),
  );

  // final fileStreamFile = file.openRead();

  // var multipart = MultipartFile("file", fileStreamFile, file.lengthSync(),
  //     filename: fileUtil.basename(file.path));

  var requestMultipart = http.MultipartRequest("", Uri.parse("uri"));

  requestMultipart.files.add(multipart);

  var msStream = requestMultipart.finalize();

  var totalByteLength = requestMultipart.contentLength;
  request.contentLength = totalByteLength;

  request.headers.set(
    HttpHeaders.contentTypeHeader,
    requestMultipart.headers[HttpHeaders.contentTypeHeader],
  );

  Stream<List<int>> streamUpload = msStream.transform(
    new StreamTransformer.fromHandlers(
      handleData: (data, sink) {
        sink.add(data);

        byteCount += data.length;

        var formatter = new DateFormat('dd/MM/yyyy HH:mm:ss');

        if (onUploadProgress != null) {
          print('Timestamp: ${formatter.format(DateTime.now())}');
          print('progress: ${byteCount / totalByteLength} ($byteCount/$totalByteLength)');
          onUploadProgress(byteCount, totalByteLength);
        }
      },
      handleError: (error, stack, sink) {
        throw error;
      },
      handleDone: (sink) {
        sink.close();
      },
    ),
  );

  await request.addStream(streamUpload);

  final httpResponse = await request.close();

  var statusCode = httpResponse.statusCode;

  if (statusCode ~/ 100 != 2) {
    throw Exception('Error uploading file, Status code: ${httpResponse.statusCode}');
  } else {
    var data = await readResponseAsString(httpResponse);
    var mapped = Attachment.fromJson(jsonDecode(data));
    return mapped;
  }
}