update flow upload media

ios/Flutter/.last_build_id

-48197743e3d78b3769f70bac9a76e7e0
+5729eb498eaeb9c64784fcfc80bbb33b

lib/custom_model/CropStatus.dart

   String description;
   String executeBy;
   String media;
+  List<String> mediaDel;
 
   CropStatus(
       {this.id,
       this.internodeLength,
       this.description,
       this.executeBy,
-      this.media});
+      this.media,
+      this.mediaDel});
 
   CropStatus.fromJson(Map<String, dynamic> json) {
     id = json['id'];
     data['description'] = this.description;
     data['executeBy'] = this.executeBy;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     return data;
   }
 }

lib/custom_model/Dung.dart

   String weatherConditions;
   String purpose;
   String executeBy;
+  List<String> mediaDel;
   List<SuppliesUsing> suppliesUsing;
 
   Dung(
       this.weatherConditions,
       this.purpose,
       this.executeBy,
+      this.mediaDel,
       this.suppliesUsing});
 
   Dung.fromJson(Map<String, dynamic> json) {
     data['weatherConditions'] = this.weatherConditions;
     data['purpose'] = this.purpose;
     data['executeBy'] = this.executeBy;
+    data['media_del'] = this.mediaDel;
     if (this.suppliesUsing != null) {
       data['suppliesUsing'] =
           this.suppliesUsing.map((v) => v.toJson()).toList();

lib/custom_model/End.dart

   String executeDate;
   String description;
   String createdByName;
+  List<String> mediaDel;
   String media;
 
   End(
       this.executeDate,
       this.description,
       this.createdByName,
+      this.mediaDel,
       this.media});
 
   End.fromJson(Map<String, dynamic> json) {
     data['description'] = this.description;
     data['createdByName'] = this.createdByName;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     return data;
   }
 }

lib/custom_model/Harvest.dart

   String description;
   String executeBy;
   String media;
+  List<String> mediaDel;
   num collectedQuantityLv1;
   num collectedQuantityLv2;
   num collectedQuantityLv3;
       this.description,
       this.executeBy,
       this.media,
+      this.mediaDel,
       this.collectedQuantityLv1,
       this.collectedQuantityLv2,
       this.collectedQuantityLv3,
     data['description'] = this.description;
     data['executeBy'] = this.executeBy;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     data['collectedQuantityLv1'] = this.collectedQuantityLv1;
     data['collectedQuantityLv2'] = this.collectedQuantityLv2;
     data['collectedQuantityLv3'] = this.collectedQuantityLv3;

lib/custom_model/HarvestProcess.dart

   String description;
   String executeBy;
   String media;
+  List<String> mediaDel;
   num quantityLv1;
   num quantityLv2;
   num quantityLv3;
       this.description,
       this.executeBy,
       this.media,
+      this.mediaDel,
       this.quantityLv1,
       this.quantityLv2,
       this.quantityLv3,
     data['description'] = this.description;
     data['executeBy'] = this.executeBy;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     data['quantityLv1'] = this.quantityLv1;
     data['quantityLv2'] = this.quantityLv2;
     data['quantityLv3'] = this.quantityLv3;

lib/custom_model/Nursery.dart

   String description;
   String executeBy;
   String media;
+  List<String> mediaDel;
   String seedName;
   num substratesId;
   String substrateName;
       this.description,
       this.executeBy,
       this.media,
+      this.mediaDel,
       this.seedName,
       this.substratesId,
       this.substrateName,
     data['description'] = this.description;
     data['executeBy'] = this.executeBy;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     data['seedName'] = this.seedName;
     data['substratesId'] = this.substratesId;
     data['substrateName'] = this.substrateName;

lib/custom_model/Other.dart

   int cropId;
   int activityId;
   String media;
+  List<String> mediaDel;
   String executeDate;
   String description;
   String createdByName;
       this.cropId,
       this.activityId,
       this.media,
+      this.mediaDel,
       this.executeDate,
       this.description,
       this.createdByName,
     data['cropId'] = this.cropId;
     data['activityId'] = this.activityId;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     data['executeDate'] = this.executeDate;
     data['description'] = this.description;
     data['createdByName'] = this.createdByName;

lib/custom_model/Packing.dart

   String description;
   String executeBy;
   String media;
+  List<String> mediaDel;
   num quantityLv1;
   num quantityLv2;
   num quantityLv3;
       this.description,
       this.executeBy,
       this.media,
+      this.mediaDel,
       this.quantityLv1,
       this.quantityLv2,
       this.quantityLv3,
     data['description'] = this.description;
     data['executeBy'] = this.executeBy;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     data['quantityLv1'] = this.quantityLv1;
     data['quantityLv2'] = this.quantityLv2;
     data['quantityLv3'] = this.quantityLv3;

lib/custom_model/Plant.dart

   String density;
   num quantity;
   String media;
+  List<String> mediaDel;
   List<SuppliesUsing> suppliesUsing;
 
   Plant(
       this.density,
       this.quantity,
       this.media,
+      this.mediaDel,
       this.suppliesUsing});
 
   Plant.fromJson(Map<String, dynamic> json) {
     data['density'] = this.density;
     data['quantity'] = this.quantity;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     if (this.suppliesUsing != null) {
       data['suppliesUsing'] =
           this.suppliesUsing.map((v) => v.toJson()).toList();

lib/custom_model/RequestDisease.dart

   int cropId;
   String executeDate;
   String description;
+  List<String> mediaDel;
   List<ObjectUpdateDetail> objectUpdateDetail;
 
   RequestDisease(
       this.cropId,
       this.executeDate,
       this.description,
+      this.mediaDel,
       this.objectUpdateDetail});
 
   RequestDisease.fromJson(Map<String, dynamic> json) {
     data['activityId'] = this.activityId;
     data['executeDate'] = this.executeDate;
     data['description'] = this.description;
+    data['media_del'] = this.mediaDel;
     if (this.objectUpdateDetail != null) {
       data['objectUpdateDetail'] =
           this.objectUpdateDetail.map((v) => v.toJson()).toList();

lib/custom_model/RequestEnvironment.dart

   int cropId;
   String executeDate;
   String description;
+  List<String> mediaDel;
   List<EnvDetail> envDetail;
 
   RequestEnvironment(
       this.cropId,
       this.executeDate,
       this.description,
+      this.mediaDel,
       this.envDetail});
 
   RequestEnvironment.fromJson(Map<String, dynamic> json) {
     data['cropId'] = this.cropId;
     data['executeDate'] = this.executeDate;
     data['description'] = this.description;
+    data['media_del'] = this.mediaDel;
     if (this.envDetail != null) {
       data['envDetail'] = this.envDetail.map((v) => v.toJson()).toList();
     }

lib/custom_model/RequestGeneralModel.dart

   int activityId;
   String executeDate;
   String description;
+  List<String> mediaDel;
   List<ObjectUpdateDetail> objectUpdateDetail;
 
   RequestGeneralModel(
       this.activityId,
       this.executeDate,
       this.description,
+      this.mediaDel,
       this.objectUpdateDetail});
 
   RequestGeneralModel.fromJson(Map<String, dynamic> json) {
     data['activityId'] = this.activityId;
     data['executeDate'] = this.executeDate;
     data['description'] = this.description;
+    data['media_del'] = this.mediaDel;
     if (this.objectUpdateDetail != null) {
       data['objectUpdateDetail'] =
           this.objectUpdateDetail.map((v) => v.toJson()).toList();

lib/custom_model/Sell.dart

   String description;
   String executeBy;
   String media;
+  List<String> mediaDel;
   num quantityLv1;
   num quantityLv2;
   num quantityLv3;
       this.description,
       this.executeBy,
       this.media,
+      this.mediaDel,
       this.quantityLv1,
       this.quantityLv2,
       this.quantityLv3,
     data['description'] = this.description;
     data['executeBy'] = this.executeBy;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     data['quantityLv1'] = this.quantityLv1;
     data['quantityLv2'] = this.quantityLv2;
     data['quantityLv3'] = this.quantityLv3;

lib/custom_model/Spraying.dart

   int activityId;
   int cropId;
   String media;
+  List<String> mediaDel;
   String executeDate;
   num quarantinePeriod;
   String resultAt;
       this.activityId,
       this.cropId,
       this.media,
+      this.mediaDel,
       this.executeDate,
       this.quarantinePeriod,
       this.resultAt,
     data['activityId'] = this.activityId;
     data['cropId'] = this.cropId;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     data['executeDate'] = this.executeDate;
     data['quarantinePeriod'] = this.quarantinePeriod;
     data['resultAt'] = this.resultAt;

lib/custom_model/UseWater.dart

   int cropId;
   String executeDate;
   String media;
+  List<String> mediaDel;
   String waterType;
   num amount;
   String description;
       this.cropId,
       this.executeDate,
       this.media,
+      this.mediaDel,
       this.waterType,
       this.amount,
       this.description,
     data['cropId'] = this.cropId;
     data['executeDate'] = this.executeDate;
     data['media'] = this.media;
+    data['media_del'] = this.mediaDel;
     data['waterType'] = this.waterType;
     data['amount'] = this.amount;
     data['description'] = this.description;

lib/presentation/custom_widgets/widget_media_picker.dart

 import 'dart:io';
 
+import 'package:cached_network_image/cached_network_image.dart';
 import 'package:farm_tpf/custom_model/Media.dart';
 import 'package:farm_tpf/presentation/custom_widgets/camera_helper.dart';
 import 'package:farm_tpf/presentation/custom_widgets/widget_show_video.dart';
 import 'package:flutter/cupertino.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
-import 'package:get/get.dart';
 
 import 'bloc/media_helper_bloc.dart';
 import 'hoz_list_view.dart';
 
 class WidgetMediaPicker extends StatefulWidget {
   final List<Media> currentItems;
-  final Function(List<String> filePaths) onChangeFiles;
+  final Function(List<String> addNewFilePaths, List<String> deleteFilePaths)
+      onChangeFiles;
   WidgetMediaPicker({this.currentItems, @required this.onChangeFiles});
   @override
   _WidgetMediaPickerState createState() => _WidgetMediaPickerState();
 
 class _WidgetMediaPickerState extends State<WidgetMediaPicker> {
   List<Media> currentItems = [];
-  List<String> files = new List<String>();
+  List<String> addNewFilePaths = new List<String>();
+  List<String> deleteFilePaths = new List<String>();
 
   @override
   void initState() {
                         ..isServerFile = false
                         ..pathFile = filePath;
                       currentItems.add(newMedia);
-                      files.add(filePath);
+                      addNewFilePaths.add(filePath);
                       BlocProvider.of<MediaHelperBloc>(context)
                         ..add(ChangeListMedia(items: currentItems));
-                      widget.onChangeFiles(files);
+                      widget.onChangeFiles(addNewFilePaths, deleteFilePaths);
                     }
-                    print("Kích thước: $lengthFileInBytes bytes");
                   });
                 }
               });
                       ..isServerFile = false
                       ..pathFile = compressFile.path;
                     currentItems.add(newMedia);
-                    files.add(compressFile.path);
+                    addNewFilePaths.add(compressFile.path);
                     BlocProvider.of<MediaHelperBloc>(context)
                       ..add(ChangeListMedia(items: currentItems));
-                    widget.onChangeFiles(files);
+                    widget.onChangeFiles(addNewFilePaths, deleteFilePaths);
                   }
                 });
               }
                     ..isServerFile = false
                     ..pathFile = filePath;
                   currentItems.add(newMedia);
-                  files.add(filePath);
+                  addNewFilePaths.add(filePath);
                   BlocProvider.of<MediaHelperBloc>(context)
                     ..add(ChangeListMedia(items: currentItems));
-                  widget.onChangeFiles(files);
+                  widget.onChangeFiles(addNewFilePaths, deleteFilePaths);
                 }
               }
             }),
     return BlocBuilder<MediaHelperBloc, MediaHelperState>(
         builder: (context, state) {
       if (state is MediaHelperSuccess) {
-        files = [];
-        currentItems.forEach((element) {
-          files.add(element.pathFile);
-        });
-        widget.onChangeFiles(files);
-
         return WrapContentHozListView(
           itemBuilder: (context, index) {
             var item = currentItems[index];
             return _WidgetItemMedia(
                 item: item,
                 deleteImage: (item) {
-                  files.remove(item.pathFile);
+                  if (item.isServerFile) {
+                    var url =
+                        item.pathFile.replaceAll(ConstCommon.baseImageUrl, '');
+                    deleteFilePaths.add(url);
+                  }
                   currentItems.remove(item);
-                  widget.onChangeFiles(files);
+                  widget.onChangeFiles(addNewFilePaths, deleteFilePaths);
                   BlocProvider.of<MediaHelperBloc>(context)
                       .add(ChangeListMedia(items: currentItems));
                 });
                 child: item.isVideo
                     ? VideoWidget(
                         pathFile: item.pathFile,
+                        isServerFile: item.isServerFile,
                         play: false,
                       )
                     : Container(
                             border: Border.all(color: Colors.grey),
                             borderRadius:
                                 BorderRadius.all(Radius.circular(8.0))),
-                        child: Image.file(File(item.pathFile),
-                            width: 100, height: 100),
+                        child: item.isServerFile
+                            ? CachedNetworkImage(
+                                placeholder: (context, url) =>
+                                    Icon(Icons.crop_original),
+                                imageUrl: item.pathFile)
+                            : Image.file(File(item.pathFile),
+                                width: 100, height: 100),
                       )),
             Positioned(
               top: -14,

lib/presentation/custom_widgets/widget_show_video.dart

 
 class VideoWidget extends StatefulWidget {
   final bool play;
+  final bool isServerFile;
   final String pathFile;
 
-  const VideoWidget({Key key, @required this.pathFile, @required this.play})
+  const VideoWidget(
+      {Key key,
+      @required this.pathFile,
+      @required this.play,
+      @required this.isServerFile})
       : super(key: key);
 
   @override
   @override
   void initState() {
     super.initState();
-    videoPlayerController = VideoPlayerController.file(File(widget.pathFile));
+    if (widget.isServerFile) {
+      videoPlayerController = VideoPlayerController.network(widget.pathFile);
+    } else {
+      videoPlayerController = VideoPlayerController.file(File(widget.pathFile));
+    }
+
     _initializeVideoPlayerFuture = videoPlayerController.initialize().then((_) {
       //       Ensure the first frame is shown after the video is initialized, even before the play button has been pressed.
       videoPlayerController.play();

lib/presentation/screens/actions/crop_status/sc_edit_action_crop_status.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       //Create request general model
       try {
         RequestGeneralModel generalModel = RequestGeneralModel()
           ..name = "KHA_NANG_SINH_CHOI"
           ..index = _cropStatus.abilityProduceBuds);
         generalModel.objectUpdateDetail = generalDetail;
+        generalModel.mediaDel = Get.find<ChangeFileController>().deleteFiles;
         var activityCropStatus = jsonEncode(generalModel.toJson()).toString();
         //ADD NEW
         if (_cropStatus.activityId == null) {
                                 .format(executeTime);
                             //Show media
                             if (_cropStatus.media != null) {
-                              await UtilAction.cacheFiles(_cropStatus.media)
-                                  .then((value) {
-                                print("then: ${value.length}");
-                                BlocProvider.of<MediaHelperBloc>(context)
-                                    .add(ChangeListMedia(items: value));
-                              }).whenComplete(() {
-                                print("completed");
-                              });
+                              BlocProvider.of<MediaHelperBloc>(context).add(
+                                  ChangeListMedia(
+                                      items: UtilAction.convertFilePathToMedia(
+                                          _cropStatus.media)));
                             }
                           } else if (state is ActionDetailInitial) {
                             print("init");
                                       state.items.length.toString());
                                   return WidgetMediaPicker(
                                       currentItems: state.items,
-                                      onChangeFiles: (filePaths) async {
-                                        Get.find<ChangeFileController>()
-                                            .addAllFile(filePaths);
+                                      onChangeFiles: (newPathFiles,
+                                          deletePathFiles) async {
+                                        Get.find<ChangeFileController>().change(
+                                            newPathFiles, deletePathFiles);
                                       });
                                 } else {
                                   return Center(

lib/presentation/screens/actions/disease/sc_edit_action_disease.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       //Create request general model
       try {
         RequestDisease requestDisease = RequestDisease()
           ..name = "BIEN_PHAP_XU_LY"
           ..index = _disease.treatmentMeasures);
         requestDisease.objectUpdateDetail = generalDetail;
+        requestDisease.mediaDel = Get.find<ChangeFileController>().deleteFiles;
         var activityDisease = jsonEncode(requestDisease.toJson()).toString();
         //ADD NEW
         if (_disease.activityId == null) {
                                 .format(executeTime);
                             //Show media
                             if (_disease.media != null) {
-                              await UtilAction.cacheFiles(_disease.media)
-                                  .then((value) {
-                                BlocProvider.of<MediaHelperBloc>(context)
-                                    .add(ChangeListMedia(items: value));
-                              }).whenComplete(() {
-                                print("completed");
-                              });
+                              BlocProvider.of<MediaHelperBloc>(context).add(
+                                  ChangeListMedia(
+                                      items: UtilAction.convertFilePathToMedia(
+                                          _disease.media)));
                             }
                           } else if (state is ActionDetailInitial) {
                           } else if (state is ActionDetailLoading) {
                                 if (state is MediaHelperSuccess) {
                                   return WidgetMediaPicker(
                                       currentItems: state.items,
-                                      onChangeFiles: (filePaths) async {
-                                        Get.find<ChangeFileController>()
-                                            .addAllFile(filePaths);
+                                      onChangeFiles: (newPathFiles,
+                                          deletePathFiles) async {
+                                        Get.find<ChangeFileController>().change(
+                                            newPathFiles, deletePathFiles);
                                       });
                                 } else {
                                   return Center(

lib/presentation/screens/actions/dung/sc_edit_action_dung.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       List<SuppliesUsing> newSups = [];
       suppliesUsing.forEach((sup) {
         var newSup = sup;
         newSups.add(newSup);
       });
       _dung.suppliesUsing = newSups;
+      _dung.mediaDel = Get.find<ChangeFileController>().deleteFiles;
       var activityDung = jsonEncode(_dung.toJson()).toString();
       //ADD NEW
       if (_dung.activityId == null) {
                                           .format(executeTime);
                                   //Show media
                                   if (_dung.media != null) {
-                                    await UtilAction.cacheFiles(_dung.media)
-                                        .then((value) {
-                                      BlocProvider.of<MediaHelperBloc>(context)
-                                          .add(ChangeListMedia(items: value));
-                                    }).whenComplete(() {
-                                      print("completed");
-                                    });
+                                    BlocProvider.of<MediaHelperBloc>(context)
+                                        .add(ChangeListMedia(
+                                            items: UtilAction
+                                                .convertFilePathToMedia(
+                                                    _dung.media)));
                                   }
                                   //list supply
                                   suppliesUsing = _dung.suppliesUsing;
                                       if (state is MediaHelperSuccess) {
                                         return WidgetMediaPicker(
                                             currentItems: state.items,
-                                            onChangeFiles: (filePaths) async {
+                                            onChangeFiles: (newPathFiles,
+                                                deletePathFiles) async {
                                               Get.find<ChangeFileController>()
-                                                  .addAllFile(filePaths);
+                                                  .change(newPathFiles,
+                                                      deletePathFiles);
                                             });
                                       } else {
                                         return Center(

lib/presentation/screens/actions/end/sc_edit_action_end.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       try {
+        _end.mediaDel = Get.find<ChangeFileController>().deleteFiles;
         var activityEnd = jsonEncode(_end.toJson()).toString();
         //ADD NEW
         if (_end.activityId == null) {
                             } catch (_) {}
                             //Show media
                             if (_end.media != null) {
-                              await UtilAction.cacheFiles(_end.media)
-                                  .then((value) {
-                                BlocProvider.of<MediaHelperBloc>(context)
-                                    .add(ChangeListMedia(items: value));
-                              }).whenComplete(() {
-                                print("completed");
-                              });
+                              BlocProvider.of<MediaHelperBloc>(context).add(
+                                  ChangeListMedia(
+                                      items: UtilAction.convertFilePathToMedia(
+                                          _end.media)));
                             }
                           } else if (state is ActionDetailInitial) {
                           } else if (state is ActionDetailLoading) {
                                 if (state is MediaHelperSuccess) {
                                   return WidgetMediaPicker(
                                       currentItems: state.items,
-                                      onChangeFiles: (filePaths) async {
-                                        Get.find<ChangeFileController>()
-                                            .addAllFile(filePaths);
+                                      onChangeFiles: (newPathFiles,
+                                          deletePathFiles) async {
+                                        Get.find<ChangeFileController>().change(
+                                            newPathFiles, deletePathFiles);
                                       });
                                 } else {
                                   return Center(

lib/presentation/screens/actions/environment_update/sc_edit_action_environment_update.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       //Create request general model
       try {
         RequestEnvironment requestEnvironment = RequestEnvironment()
           ..name = "LLN"
           ..index = _environment.lln);
         requestEnvironment.envDetail = envDetail;
+        requestEnvironment.mediaDel =
+            Get.find<ChangeFileController>().deleteFiles;
         var activityEnvironmentUpdate =
             jsonEncode(requestEnvironment.toJson()).toString();
         //ADD NEW
                                 .format(executeTime);
                             //Show media
                             if (_environment.media != null) {
-                              await UtilAction.cacheFiles(_environment.media)
-                                  .then((value) {
-                                print("then: ${value.length}");
-                                BlocProvider.of<MediaHelperBloc>(context)
-                                    .add(ChangeListMedia(items: value));
-                              }).whenComplete(() {
-                                print("completed");
-                              });
+                              BlocProvider.of<MediaHelperBloc>(context).add(
+                                  ChangeListMedia(
+                                      items: UtilAction.convertFilePathToMedia(
+                                          _environment.media)));
                             }
                           } else if (state is ActionDetailInitial) {
                             print("init");
                                 if (state is MediaHelperSuccess) {
                                   return WidgetMediaPicker(
                                       currentItems: state.items,
-                                      onChangeFiles: (filePaths) async {
-                                        Get.find<ChangeFileController>()
-                                            .addAllFile(filePaths);
+                                      onChangeFiles: (newPathFiles,
+                                          deletePathFiles) async {
+                                        Get.find<ChangeFileController>().change(
+                                            newPathFiles, deletePathFiles);
                                       });
                                 } else {
                                   return Center(

lib/presentation/screens/actions/harvest/sc_edit_action_harvest.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       try {
+        _harvest.mediaDel = Get.find<ChangeFileController>().deleteFiles;
         var activityHarvest = jsonEncode(_harvest.toJson()).toString();
         //ADD NEW
         if (_harvest.activityId == null) {
                             } catch (_) {}
                             //Show media
                             if (_harvest.media != null) {
-                              await UtilAction.cacheFiles(_harvest.media)
-                                  .then((value) {
-                                BlocProvider.of<MediaHelperBloc>(context)
-                                    .add(ChangeListMedia(items: value));
-                              }).whenComplete(() {
-                                print("completed");
-                              });
+                              BlocProvider.of<MediaHelperBloc>(context).add(
+                                  ChangeListMedia(
+                                      items: UtilAction.convertFilePathToMedia(
+                                          _harvest.media)));
                             }
                           } else if (state is ActionDetailInitial) {
                           } else if (state is ActionDetailLoading) {
                                 if (state is MediaHelperSuccess) {
                                   return WidgetMediaPicker(
                                       currentItems: state.items,
-                                      onChangeFiles: (filePaths) async {
-                                        Get.find<ChangeFileController>()
-                                            .addAllFile(filePaths);
+                                      onChangeFiles: (newPathFiles,
+                                          deletePathFiles) async {
+                                        Get.find<ChangeFileController>().change(
+                                            newPathFiles, deletePathFiles);
                                       });
                                 } else {
                                   return Center(

lib/presentation/screens/actions/harvest_process/sc_edit_action_harvest_process.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       List<SuppliesUsing> newSups = [];
       suppliesUsing.forEach((sup) {
         var newSup = sup;
         newSups.add(newSup);
       });
       _harvestProcess.suppliesUsing = newSups;
+      _harvestProcess.mediaDel = Get.find<ChangeFileController>().deleteFiles;
       try {
         var activityHarvestProcess =
             jsonEncode(_harvestProcess.toJson()).toString();
                             } catch (_) {}
                             //Show media
                             if (_harvestProcess.media != null) {
-                              await UtilAction.cacheFiles(_harvestProcess.media)
-                                  .then((value) {
-                                BlocProvider.of<MediaHelperBloc>(context)
-                                    .add(ChangeListMedia(items: value));
-                              }).whenComplete(() {
-                                print("completed");
-                              });
+                              BlocProvider.of<MediaHelperBloc>(context).add(
+                                  ChangeListMedia(
+                                      items: UtilAction.convertFilePathToMedia(
+                                          _harvestProcess.media)));
                             }
                             //list supply
                             suppliesUsing = _harvestProcess.suppliesUsing;
                                 if (state is MediaHelperSuccess) {
                                   return WidgetMediaPicker(
                                       currentItems: state.items,
-                                      onChangeFiles: (filePaths) async {
-                                        Get.find<ChangeFileController>()
-                                            .addAllFile(filePaths);
+                                      onChangeFiles: (newPathFiles,
+                                          deletePathFiles) async {
+                                        Get.find<ChangeFileController>().change(
+                                            newPathFiles, deletePathFiles);
                                       });
                                 } else {
                                   return Center(

lib/presentation/screens/actions/nursery/sc_edit_action_nursery.dart

 import 'package:pattern_formatter/pattern_formatter.dart';
 import 'package:farm_tpf/utils/formatter.dart';
 
+import '../util_action.dart';
+
 class EditActionNurseryScreen extends StatefulWidget {
   final int cropId;
   final bool isEdit;
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
       _nursery.nurseryDetail = currentNurseryDetail;
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
+      _nursery.mediaDel = Get.find<ChangeFileController>().deleteFiles;
       var activityNursery = jsonEncode(_nursery.toJson()).toString();
       //ADD NEW
       if (_nursery.activityId == null) {
                                           .format(executeTime);
                                   //Show media
                                   if (_nursery.media != null) {
-                                    await cacheFiles(_nursery.media)
-                                        .then((value) {
-                                      print("then: ${value.length}");
-                                      BlocProvider.of<MediaHelperBloc>(context)
-                                          .add(ChangeListMedia(items: value));
-                                    }).whenComplete(() {
-                                      print("completed");
-                                    });
+                                    BlocProvider.of<MediaHelperBloc>(context)
+                                        .add(ChangeListMedia(
+                                            items: UtilAction
+                                                .convertFilePathToMedia(
+                                                    _nursery.media)));
                                   }
                                   //Show worker
                                   if (_nursery.nurseryDetail.length > 0) {
                                             state.items.length.toString());
                                         return WidgetMediaPicker(
                                             currentItems: state.items,
-                                            onChangeFiles: (filePaths) async {
+                                            onChangeFiles: (newPathFiles,
+                                                deletePathFiles) async {
                                               Get.find<ChangeFileController>()
-                                                  .addAllFile(filePaths);
+                                                  .change(newPathFiles,
+                                                      deletePathFiles);
                                             });
                                       } else {
                                         return Center(
     _executeByController.dispose();
     super.dispose();
   }
-
-  Future<List<Media>> cacheFiles(String existedMedias) async {
-    var medias = List<Media>();
-    var mediaPathsLocal = List<String>();
-    var mediaPaths = existedMedias.split(";");
-    for (int i = 0; i < mediaPaths.length; i++) {
-      var tempFile = await DefaultCacheManager()
-          .getSingleFile(ConstCommon.baseImageUrl + mediaPaths[i]);
-      print(tempFile.path);
-      var isVideo = lookupMimeType(tempFile.path) == "video/mp4";
-      print("file type: " + lookupMimeType(tempFile.path));
-      Media media = Media()
-        ..pathFile = tempFile.path
-        ..isVideo = isVideo;
-      medias.add(media);
-      mediaPathsLocal.add(tempFile.path);
-    }
-    Get.find<ChangeFileController>().addAllFile(filePaths);
-    return medias;
-  }
 }

lib/presentation/screens/actions/other/sc_edit_action_other.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       try {
+        _other.mediaDel = Get.find<ChangeFileController>().deleteFiles;
         var activityOther = jsonEncode(_other.toJson()).toString();
         //ADD NEW
         if (_other.activityId == null) {
                             } catch (_) {}
                             //Show media
                             if (_other.media != null) {
-                              await UtilAction.cacheFiles(_other.media)
-                                  .then((value) {
-                                BlocProvider.of<MediaHelperBloc>(context)
-                                    .add(ChangeListMedia(items: value));
-                              }).whenComplete(() {
-                                print("completed");
-                              });
+                              BlocProvider.of<MediaHelperBloc>(context).add(
+                                  ChangeListMedia(
+                                      items: UtilAction.convertFilePathToMedia(
+                                          _other.media)));
                             }
                           } else if (state is ActionDetailInitial) {
                           } else if (state is ActionDetailLoading) {
                                 if (state is MediaHelperSuccess) {
                                   return WidgetMediaPicker(
                                       currentItems: state.items,
-                                      onChangeFiles: (filePaths) async {
-                                        Get.find<ChangeFileController>()
-                                            .addAllFile(filePaths);
+                                      onChangeFiles: (newPathFiles,
+                                          deletePathFiles) async {
+                                        Get.find<ChangeFileController>().change(
+                                            newPathFiles, deletePathFiles);
                                       });
                                 } else {
                                   return Center(

lib/presentation/screens/actions/packing/sc_edit_action_packing.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       try {
+        _packing.mediaDel = Get.find<ChangeFileController>().deleteFiles;
         var activityPacking = jsonEncode(_packing.toJson()).toString();
         //ADD NEW
         if (_packing.activityId == null) {
                             } catch (_) {}
                             //Show media
                             if (_packing.media != null) {
-                              await UtilAction.cacheFiles(_packing.media)
-                                  .then((value) {
-                                BlocProvider.of<MediaHelperBloc>(context)
-                                    .add(ChangeListMedia(items: value));
-                              }).whenComplete(() {
-                                print("completed");
-                              });
+                              BlocProvider.of<MediaHelperBloc>(context).add(
+                                  ChangeListMedia(
+                                      items: UtilAction.convertFilePathToMedia(
+                                          _packing.media)));
                             }
                           } else if (state is ActionDetailInitial) {
                           } else if (state is ActionDetailLoading) {
                                 if (state is MediaHelperSuccess) {
                                   return WidgetMediaPicker(
                                       currentItems: state.items,
-                                      onChangeFiles: (filePaths) async {
-                                        Get.find<ChangeFileController>()
-                                            .addAllFile(filePaths);
+                                      onChangeFiles: (newPathFiles,
+                                          deletePathFiles) async {
+                                        Get.find<ChangeFileController>().change(
+                                            newPathFiles, deletePathFiles);
                                       });
                                 } else {
                                   return Center(

lib/presentation/screens/actions/plant/sc_edit_action_plant.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       List<SuppliesUsing> newSups = [];
       suppliesUsing.forEach((sup) {
         var newSup = sup;
         newSups.add(newSup);
       });
       _plant.suppliesUsing = newSups;
+      _plant.mediaDel = Get.find<ChangeFileController>().deleteFiles;
+      print("plant: ${_plant.mediaDel[0]}");
       var activityPlant = jsonEncode(_plant.toJson()).toString();
       //ADD NEW
       if (_plant.activityId == null) {
                                           .format(executeTime);
                                   //Show media
                                   if (_plant.media != null) {
-                                    await UtilAction.cacheFiles(_plant.media)
-                                        .then((value) {
-                                      BlocProvider.of<MediaHelperBloc>(context)
-                                          .add(ChangeListMedia(items: value));
-                                    }).whenComplete(() {
-                                      print("completed");
-                                    });
+                                    BlocProvider.of<MediaHelperBloc>(context)
+                                        .add(ChangeListMedia(
+                                            items: UtilAction
+                                                .convertFilePathToMedia(
+                                                    _plant.media)));
                                   }
                                   //list supply
                                   suppliesUsing = _plant.suppliesUsing;
                                       if (state is MediaHelperSuccess) {
                                         return WidgetMediaPicker(
                                             currentItems: state.items,
-                                            onChangeFiles: (filePaths) async {
+                                            onChangeFiles: (newPathFiles,
+                                                deletePathFiles) async {
                                               Get.find<ChangeFileController>()
-                                                  .addAllFile(filePaths);
+                                                  .change(newPathFiles,
+                                                      deletePathFiles);
                                             });
                                       } else {
                                         return Center(

lib/presentation/screens/actions/sell/sc_edit_action_sell.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       try {
+        _sell.mediaDel = Get.find<ChangeFileController>().deleteFiles;
         var activitySell = jsonEncode(_sell.toJson()).toString();
         //ADD NEW
         if (_sell.activityId == null) {
                             } catch (_) {}
                             //Show media
                             if (_sell.media != null) {
-                              await UtilAction.cacheFiles(_sell.media)
-                                  .then((value) {
-                                BlocProvider.of<MediaHelperBloc>(context)
-                                    .add(ChangeListMedia(items: value));
-                              }).whenComplete(() {
-                                print("completed");
-                              });
+                              BlocProvider.of<MediaHelperBloc>(context).add(
+                                  ChangeListMedia(
+                                      items: UtilAction.convertFilePathToMedia(
+                                          _sell.media)));
                             }
                           } else if (state is ActionDetailInitial) {
                           } else if (state is ActionDetailLoading) {
                                 if (state is MediaHelperSuccess) {
                                   return WidgetMediaPicker(
                                       currentItems: state.items,
-                                      onChangeFiles: (filePaths) async {
-                                        Get.find<ChangeFileController>()
-                                            .addAllFile(filePaths);
+                                      onChangeFiles: (newPathFiles,
+                                          deletePathFiles) async {
+                                        Get.find<ChangeFileController>().change(
+                                            newPathFiles, deletePathFiles);
                                       });
                                 } else {
                                   return Center(

lib/presentation/screens/actions/spraying/sc_edit_action_spraying.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       List<SuppliesUsing> newSups = [];
       suppliesUsing.forEach((sup) {
         var newSup = sup;
         newSups.add(newSup);
       });
       _spraying.suppliesUsing = newSups;
+      _spraying.mediaDel = Get.find<ChangeFileController>().deleteFiles;
       var activitySpraying = jsonEncode(_spraying.toJson()).toString();
       //ADD NEW
       if (_spraying.activityId == null) {
 
                                   //Show media
                                   if (_spraying.media != null) {
-                                    await UtilAction.cacheFiles(_spraying.media)
-                                        .then((value) {
-                                      BlocProvider.of<MediaHelperBloc>(context)
-                                          .add(ChangeListMedia(items: value));
-                                    }).whenComplete(() {
-                                      print("completed");
-                                    });
+                                    BlocProvider.of<MediaHelperBloc>(context)
+                                        .add(ChangeListMedia(
+                                            items: UtilAction
+                                                .convertFilePathToMedia(
+                                                    _spraying.media)));
                                   }
                                   //list supply
                                   suppliesUsing = _spraying.suppliesUsing;
                                       if (state is MediaHelperSuccess) {
                                         return WidgetMediaPicker(
                                             currentItems: state.items,
-                                            onChangeFiles: (filePaths) async {
+                                            onChangeFiles: (newPathFiles,
+                                                deletePathFiles) async {
                                               Get.find<ChangeFileController>()
-                                                  .addAllFile(filePaths);
+                                                  .change(newPathFiles,
+                                                      deletePathFiles);
                                             });
                                       } else {
                                         return Center(

lib/presentation/screens/actions/state_management_helper/change_file_controller.dart

 import 'package:get/get.dart';
 
 class ChangeFileController extends GetxController {
-  List<String> files;
+  List<String> newFiles;
+  List<String> deleteFiles;
   void initValue() {
-    files = [];
+    newFiles = [];
+    deleteFiles = [];
     update();
   }
 
-  void addAllFile(List<String> filePaths) {
-    files = [];
-    files = filePaths;
-    update();
-  }
-
-  void addFile(String filePath) {
-    files.add(filePath);
-    update();
-  }
-
-  void deleteFile(String filePath) {
-    files.remove(filePath);
+  void change(List<String> newPathFiles, List<String> deletePathFiles) {
+    newFiles = newPathFiles;
+    deleteFiles = deletePathFiles;
     update();
   }
 }

lib/presentation/screens/actions/use_water/sc_edit_action_user_water.dart

     if (_formKey.currentState.validate()) {
       _formKey.currentState.save();
       LoadingDialog.showLoadingDialog(context);
-      filePaths = Get.find<ChangeFileController>().files;
+      filePaths = Get.find<ChangeFileController>().newFiles;
       //Create request general model
       try {
         _useWater.waterType = changeRadio.selectedWaterType.waterTypeName;
+        _useWater.mediaDel = Get.find<ChangeFileController>().deleteFiles;
         var activityUseWater = jsonEncode(_useWater.toJson()).toString();
         //ADD NEW
         if (_useWater.activityId == null) {
 
                             //Show media
                             if (_useWater.media != null) {
-                              await UtilAction.cacheFiles(_useWater.media)
-                                  .then((value) {
-                                BlocProvider.of<MediaHelperBloc>(context)
-                                    .add(ChangeListMedia(items: value));
-                              }).whenComplete(() {
-                                print("completed");
-                              });
+                              BlocProvider.of<MediaHelperBloc>(context).add(
+                                  ChangeListMedia(
+                                      items: UtilAction.convertFilePathToMedia(
+                                          _useWater.media)));
                             }
                           } else if (state is ActionDetailInitial) {
                           } else if (state is ActionDetailLoading) {
                                 if (state is MediaHelperSuccess) {
                                   return WidgetMediaPicker(
                                       currentItems: state.items,
-                                      onChangeFiles: (filePaths) async {
-                                        Get.find<ChangeFileController>()
-                                            .addAllFile(filePaths);
+                                      onChangeFiles: (newPathFiles,
+                                          deletePathFiles) async {
+                                        Get.find<ChangeFileController>().change(
+                                            newPathFiles, deletePathFiles);
                                       });
                                 } else {
                                   return Center(

lib/presentation/screens/actions/util_action.dart

     return medias;
   }
 
+  static List<Media> convertFilePathToMedia(String existedMedias) {
+    var medias = List<Media>();
+    var mediaPaths = existedMedias.split(";");
+    for (int i = 0; i < mediaPaths.length; i++) {
+      var filePath = ConstCommon.baseImageUrl + mediaPaths[i];
+      var isVideo = lookupMimeType(filePath) == "video/mp4";
+      Media media = Media()
+        ..pathFile = filePath
+        ..isVideo = isVideo
+        ..isServerFile = true;
+      medias.add(media);
+    }
+    return medias;
+  }
+
   static num convertUnit({num inputValue, String oldUnit, String newUnit}) {
     num result = inputValue;
     if (newUnit.isEmpty || newUnit == oldUnit) {

pubspec.lock

       url: "https://pub.dartlang.org"
     source: hosted
     version: "7.1.0"
+  cached_network_image:
+    dependency: "direct main"
+    description:
+      name: cached_network_image
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "2.3.2+1"
   camera:
     dependency: "direct main"
     description:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "6.0.5"
+  flutter_blurhash:
+    dependency: transitive
+    description:
+      name: flutter_blurhash
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "0.5.0"
   flutter_cache_manager:
     dependency: "direct main"
     description:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "1.1.1"
+  octo_image:
+    dependency: transitive
+    description:
+      name: octo_image
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "0.3.0"
   package_config:
     dependency: transitive
     description:
     version: "2.2.1"
 sdks:
   dart: ">=2.10.0-110 <2.11.0"
-  flutter: ">=1.16.0 <2.0.0"
+  flutter: ">=1.20.0 <2.0.0"

pubspec.yaml

   http_parser: ^3.1.4
   rflutter_alert: ^1.1.0
   badges: ^1.1.1
+  cached_network_image: ^2.3.2+1
 
   camera: ^0.5.8+5
   path_provider: ^1.6.14