Two methods of image compression and image compression upload function for iOS

NSData *data = UIImageJPEGRepresentation(image, compression);
UIImage *resultImage = [UIImage imageWithData:data];

UIGraphicsBeginImageContext(size);
[image drawInRect:CGRectMake(0, 0, , )];
resultImage = UIGraphicsGetImageFromCurrentImageContext();
UIGraphicsEndImageContext();

+ (UIImage *)compressImageQuality:(UIImage *)image toByte:(NSInteger)maxLength {
 CGFloat compression = 1;
 NSData *data = UIImageJPEGRepresentation(image, compression);
 while ( > maxLength && compression > 0) {
 compression -= 0.02;
 data = UIImageJPEGRepresentation(image, compression); // When compression less than a value, this code dose not work
 }
 UIImage *resultImage = [UIImage imageWithData:data];
 return resultImage;
}

+ (UIImage *)compressImageQuality:(UIImage *)image toByte:(NSInteger)maxLength {
 CGFloat compression = 1;
 NSData *data = UIImageJPEGRepresentation(image, compression);
 if ( < maxLength) return image;
 CGFloat max = 1;
 CGFloat min = 0;
 for (int i = 0; i < 6; ++i) {
 compression = (max + min) / 2;
 data = UIImageJPEGRepresentation(image, compression);
 if ( < maxLength * 0.9) {
 min = compression;
 } else if ( > maxLength) {
 max = compression;
 } else {
 break;
 }
 }
 UIImage *resultImage = [UIImage imageWithData:data];
 return resultImage;
}

+ (UIImage *)compressImageSize:(UIImage *)image toByte:(NSUInteger)maxLength {
 UIImage *resultImage = image;
 NSData *data = UIImageJPEGRepresentation(resultImage, 1);
 NSUInteger lastDataLength = 0;
 while ( > maxLength &&  != lastDataLength) {
 lastDataLength = ;
 CGFloat ratio = (CGFloat)maxLength / ;
 CGSize size = CGSizeMake((NSUInteger)( * sqrtf(ratio)), (NSUInteger)( * sqrtf(ratio))); // Use NSUInteger to prevent white blank
 UIGraphicsBeginImageContext(size);
 // Use image to draw (drawInRect:), image is larger but more compression time
 // Use result image to draw, image is smaller but less compression time
 [resultImage drawInRect:CGRectMake(0, 0, , )];
 resultImage = UIGraphicsGetImageFromCurrentImageContext();
 UIGraphicsEndImageContext();
 data = UIImageJPEGRepresentation(resultImage, 1);
 }
 return resultImage;
}

+ (UIImage *)compressImage:(UIImage *)image toByte:(NSUInteger)maxLength {
 // Compress by quality
 CGFloat compression = 1;
 NSData *data = UIImageJPEGRepresentation(image, compression);
 if ( < maxLength) return image;
 CGFloat max = 1;
 CGFloat min = 0;
 for (int i = 0; i < 6; ++i) {
 compression = (max + min) / 2;
 data = UIImageJPEGRepresentation(image, compression);
 if ( < maxLength * 0.9) {
 min = compression;
 } else if ( > maxLength) {
 max = compression;
 } else {
 break;
 }
 }
 UIImage *resultImage = [UIImage imageWithData:data];
 if ( < maxLength) return resultImage;
 // Compress by size
 NSUInteger lastDataLength = 0;
 while ( > maxLength &&  != lastDataLength) {
 lastDataLength = ;
 CGFloat ratio = (CGFloat)maxLength / ;
 CGSize size = CGSizeMake((NSUInteger)( * sqrtf(ratio)), (NSUInteger)( * sqrtf(ratio))); // Use NSUInteger to prevent white blank
 UIGraphicsBeginImageContext(size);
 [resultImage drawInRect:CGRectMake(0, 0, , )];
 resultImage = UIGraphicsGetImageFromCurrentImageContext();
 UIGraphicsEndImageContext();
 data = UIImageJPEGRepresentation(resultImage, compression);
 }
 return resultImage;
}

// MARK: - Reduce quality func resetSizeOfImageData(source_image: UIImage, maxSize: Int) -> NSData {
  //Adjust the resolution first  var newSize = CGSize(width: source_image., height: source_image.)
  let tempHeight =  / 1024
  let tempWidth =  / 1024
  if tempWidth > 1.0 && tempWidth > tempHeight {
   newSize = CGSize(width: source_image. / tempWidth, height: source_image. / tempWidth)
  }
  else if tempHeight > 1.0 && tempWidth < tempHeight {
   newSize = CGSize(width: source_image. / tempHeight, height: source_image. / tempHeight)
  }
  UIGraphicsBeginImageContext(newSize)
  source_image.drawAsPatternInRect(CGRect(x: 0, y: 0, width: , height: ))
  let newImage = UIGraphicsGetImageFromCurrentImageContext()
  UIGraphicsEndImageContext()
  //First determine whether the current quality meets the requirements, and then compress it if it is not met.  var finallImageData = UIImageJPEGRepresentation(newImage,1.0)
  let sizeOrigin  = Int64((finallImageData?.length)!)
  let sizeOriginKB = Int(sizeOrigin / 1024)
  if sizeOriginKB <= maxSize {
   return finallImageData!
  }
  //Save the compression coefficient  let compressionQualityArr = NSMutableArray()
  let avg = CGFloat(1.0/250)
  var value = avg
  for var i = 250; i>=1; i-- {
   value = CGFloat(i)*avg
   (value)
  }
  //Resize  //Note: Compression coefficient array compressionQualityArr is stored from large to small.  //Thoughts: half-fold calculation. If the intermediate compression coefficient still does not drop to the target value maxSize, then start looking for the compression coefficient from the second half; otherwise, look for the compression coefficient from the first half.  finallImageData = UIImageJPEGRepresentation(newImage, CGFloat(compressionQualityArr[125] as! NSNumber))
  if Int(Int64((UIImageJPEGRepresentation(newImage, CGFloat(compressionQualityArr[125] as! NSNumber))?.length)!)/1024) > maxSize {
   //Get the initial size   finallImageData = UIImageJPEGRepresentation(newImage, 1.0)
   //Start from the second half   for idx in 126..<250 {
    let value = compressionQualityArr[idx]
    let sizeOrigin = Int64((finallImageData?.length)!)
    let sizeOriginKB = Int(sizeOrigin / 1024)
    print("The quality currently reduced：\(sizeOriginKB)")
    if sizeOriginKB > maxSize {
     print("\(idx)----\(value)")
     finallImageData = UIImageJPEGRepresentation(newImage, CGFloat(value as! NSNumber))
    } else {
     break
    }
   }
  } else {
   //Get the initial size   finallImageData = UIImageJPEGRepresentation(newImage, 1.0)
   //Start from the first half   for idx in 0..<125 {
    let value = compressionQualityArr[idx]
    let sizeOrigin = Int64((finallImageData?.length)!)
    let sizeOriginKB = Int(sizeOrigin / 1024)
    print("The quality currently reduced：\(sizeOriginKB)")
    if sizeOriginKB > maxSize {
     print("\(idx)----\(value)")
     finallImageData = UIImageJPEGRepresentation(newImage, CGFloat(value as! NSNumber))
    } else {
     break
    }
   }
  }
  return finallImageData!
 }

// MARK: - Reduce qualityfunc resetSizeOfImageData(source_image: UIImage!, maxSize: Int) -> NSData {
 //First determine whether the current quality meets the requirements, and then compress it if it is not met. var finallImageData = UIImageJPEGRepresentation(source_image,1.0)
 let sizeOrigin  = finallImageData?.count
 let sizeOriginKB = sizeOrigin! / 1024
 if sizeOriginKB <= maxSize {
  return finallImageData! as NSData
 }
 //Adjust the resolution first var defaultSize = CGSize(width: 1024, height: 1024)
 let newImage = (size: defaultSize, source_image: source_image)
 finallImageData = UIImageJPEGRepresentation(newImage,1.0);
 //Save the compression coefficient let compressionQualityArr = NSMutableArray()
 let avg = CGFloat(1.0/250)
 var value = avg
 var i = 250
 repeat {
  i -= 1
  value = CGFloat(i)*avg
  (value)
 } while i >= 1
 /*
   Resize
   Description: The compression coefficient array compressionQualityArr is stored from large to small.
   */
 //Thoughts: Search using dichotomy finallImageData = (arr: () as! [CGFloat], image: newImage, sourceData: finallImageData!, maxSize: maxSize)
 //If the compression to the specified size is still not possible, the resolution will be reduced while finallImageData?.count == 0 {
  //Resolution reduction is 100 per time  if -100 <= 0 || -100 <= 0 {
   break
  }
  defaultSize = CGSize(width: -100, height: -100)
  let image = (size: defaultSize, source_image: (data: UIImageJPEGRepresentation(newImage,  as! CGFloat)!)!)
  finallImageData = (arr: () as! [CGFloat], image: image, sourceData: UIImageJPEGRepresentation(image,1.0)!, maxSize: maxSize)
 }
 return finallImageData! as NSData
}
// MARK: - Adjust image resolution/size (equal scale)func newSizeImage(size: CGSize, source_image: UIImage) -> UIImage {
 var newSize = CGSize(width: source_image., height: source_image.)
 let tempHeight =  / 
 let tempWidth =  / 
 if tempWidth > 1.0 && tempWidth > tempHeight {
  newSize = CGSize(width: source_image. / tempWidth, height: source_image. / tempWidth)
 } else if tempHeight > 1.0 && tempWidth < tempHeight {
  newSize = CGSize(width: source_image. / tempHeight, height: source_image. / tempHeight)
 }
 UIGraphicsBeginImageContext(newSize)
 source_image.draw(in: CGRect(x: 0, y: 0, width: , height: ))
 let newImage = UIGraphicsGetImageFromCurrentImageContext()
 UIGraphicsEndImageContext()
 return newImage!
}
// MARK: - Dichotomyfunc halfFuntion(arr: [CGFloat], image: UIImage, sourceData finallImageData: Data, maxSize: Int) -> Data? {
 var tempFinallImageData = finallImageData
 var tempData = ()
 var start = 0
 var end =  - 1
 var index = 0
 var difference = 
 while start <= end {
  index = start + (end - start)/2
  tempFinallImageData = UIImageJPEGRepresentation(image, arr[index])!
  let sizeOrigin = 
  let sizeOriginKB = sizeOrigin / 1024
  print("The quality currently reduced：\(sizeOriginKB)\n\(index)----\(arr[index])")
  if sizeOriginKB > maxSize {
   start = index + 1
  } else if sizeOriginKB < maxSize {
   if maxSize-sizeOriginKB < difference {
    difference = maxSize-sizeOriginKB
    tempData = tempFinallImageData
   }
   end = index - 1
  } else {
   break
  }
 }
 return tempData
}