docs: function sliceUploadFile(params, callback) {
      var self = this;
      var ep = new EventProxy();
      var TaskId = params.TaskId;
      var Bucket = params.Bucket;
      var Region = params.Region;
      var Key = params.Key;
      var FilePath = params.FilePath;
      var ChunkSize = params.ChunkSize || params.SliceSize || this.options.ChunkSize;
      var AsyncLimit = params.AsyncLimit;
      var StorageClass = params.StorageClass || 'Standard';
      var ServerSideEncryption = params.ServerSideEncryption;
      var FileSize;
  
      var onProgress;
      var onHashProgress = params.onHashProgress;
  
      // 上传过程中出现错误，返回错误
      ep.on('error', function (err) {
          if (!self._isRunningTask(TaskId)) return;
          return callback(err);
      });
  
      // 上传分块完成，开始 uploadSliceComplete 操作
      ep.on('upload_complete', function (UploadCompleteData) {
          callback(null, UploadCompleteData);
      });
  
      // 上传分块完成，开始 uploadSliceComplete 操作
      ep.on('upload_slice_complete', function (UploadData) {
          uploadSliceComplete.call(self, {
              Bucket: Bucket,
              Region: Region,
              Key: Key,
              UploadId: UploadData.UploadId,
              SliceList: UploadData.SliceList,
          }, function (err, data) {
              if (!self._isRunningTask(TaskId)) return;
              delete uploadIdUsing[UploadData.UploadId];
              if (err) {
                  onProgress(null, true);
                  return ep.emit('error', err);
              }
              onProgress({loaded: FileSize, total: FileSize}, true);
              removeUploadId.call(self, UploadData.UploadId);
              ep.emit('upload_complete', data);
          });
      });
  
      // 获取 UploadId 完成，开始上传每个分片
      ep.on('get_upload_data_finish', function (UploadData) {
  
          // 处理 UploadId 缓存
          var uuid = util.getFileUUID(params.FileStat, params.ChunkSize);
          uuid && setUploadId.call(self, uuid, UploadData.UploadId); // 缓存 UploadId
          uploadIdUsing[UploadData.UploadId] = true; // 标记 UploadId 为正在使用
          TaskId && self.on('inner-kill-task', function (data) {
              if (data.TaskId === TaskId && data.toState === 'canceled') {
                  delete uploadIdUsing[UploadData.UploadId]; // 去除 UploadId 正在使用的标记
              }
          });
  
          // 获取 UploadId
          uploadSliceList.call(self, {
              TaskId: TaskId,
              Bucket: Bucket,
              Region: Region,
              Key: Key,
              FilePath: FilePath,
              FileSize: FileSize,
              SliceSize: ChunkSize,
              AsyncLimit: AsyncLimit,
              ServerSideEncryption: ServerSideEncryption,
              UploadData: UploadData,
              onProgress: onProgress
          }, function (err, data) {
              if (!self._isRunningTask(TaskId)) return;
              if (err) {
                  onProgress(null, true);
                  return ep.emit('error', err);
              }
              ep.emit('upload_slice_complete', data);
          });
      });
  
      // 开始获取文件 UploadId，里面会视情况计算 ETag，并比对，保证文件一致性，也优化上传
      ep.on('get_file_size_finish', function () {
  
          onProgress = util.throttleOnProgress.call(self, FileSize, params.onProgress);
  
          if (params.UploadData.UploadId) {
              ep.emit('get_upload_data_finish', params.UploadData);
          } else {
              var _params = util.extend({
                  TaskId: TaskId,
                  Bucket: Bucket,
                  Region: Region,
                  Key: Key,
                  Headers: params.Headers,
                  StorageClass: StorageClass,
                  FilePath: FilePath,
                  FileSize: FileSize,
                  SliceSize: ChunkSize,
                  onHashProgress: onHashProgress,
              }, params);
              getUploadIdAndPartList.call(self, _params, function (err, UploadData) {
                  if (!self._isRunningTask(TaskId)) return;
                  if (err) return ep.emit('error', err);
                  params.UploadData.UploadId = UploadData.UploadId;
                  params.UploadData.PartList = UploadData.PartList;
                  ep.emit('get_upload_data_finish', params.UploadData);
              });
          }
      });
  
      // 获取上传文件大小
      FileSize = params.ContentLength;
      delete params.ContentLength;
      !params.Headers && (params.Headers = {});
      util.each(params.Headers, function (item, key) {
          if (key.toLowerCase() === 'content-length') {
              delete params.Headers[key];
          }
      });
  
      // 控制分片大小
      (function () {
          var SIZE = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 1024 * 2, 1024 * 4, 1024 * 5];
          var AutoChunkSize = 1024 * 1024;
          for (var i = 0; i < SIZE.length; i++) {
              AutoChunkSize = SIZE[i] * 1024 * 1024;
              if (FileSize / AutoChunkSize <= self.options.MaxPartNumber) break;
          }
          params.ChunkSize = params.SliceSize = ChunkSize = Math.max(ChunkSize, AutoChunkSize);
      })();
  
      // 开始上传
      if (FileSize === 0) {
          params.Body = '';
          params.ContentLength = 0;
          params.SkipTask = true;
          self.putObject(params, function (err, data) {
              if (err) {
                  return callback(err);
              }
              callback(null, data);
          });
      } else {
          ep.emit('get_file_size_finish');
      }
  
  }