Swift - Wie speichere ich mit AlamofireImage/ImageShack?

Question

Ich verwende Alamofire, AlamofireImage Bilder mit Images Speicher mit Firebase Backend zwischenzuspeichern. Manchmal kommt Speicher über 100 MB. Ich möchte lernen, wie ich mein Bild-Caching und die Skalierung vor dem Hochladen verbessern kann. Zum Beispiel habe ich einen gemeinsamen Cache in der Klasse gesamtes Projekt erklärt mit, dass AutoPurgingImageCache:

let photoCache = AutoPurgingImageCache(
     memoryCapacity: 100 * 1024 * 1024, 
     preferredMemoryUsageAfterPurge: 60 * 1024 * 1024 
    ) 

Gibt es eine Möglichkeit diesen memoryCapacity, preferredMemoryUsageAfterPurge speichern Speicher zu definieren? Was genau meinen sie?

Ich verwende unter Alamofire.upload für didFinishPickingImage:

func imagePickerController(picker: UIImagePickerController, didFinishPickingImage image: UIImage, editingInfo: [String : AnyObject]?) { 

     let urlStr = "http://post.imageshack.us/upload_api.php" 
     let url = NSURL(string: urlStr)! 
     let imgData = UIImageJPEGRepresentation(image, 0.25)! 

     let keyData = "____IMGSHACK_API_KEY_____".dataUsingEncoding(NSUTF8StringEncoding)! 
     let keyJSON = "json".dataUsingEncoding(NSUTF8StringEncoding)! 
     let publicData = "no".dataUsingEncoding(NSUTF8StringEncoding)! 

     Alamofire.upload(.POST, url, headers: nil, 
         multipartFormData: { multipartFormData in 
          multipartFormData.appendBodyPart(data: imgData, name:"fileupload", fileName:"image", mimeType: "image/jpg") 
          multipartFormData.appendBodyPart(data: keyData, name: "key") 
          multipartFormData.appendBodyPart(data: keyJSON, name: "format") 
          multipartFormData.appendBodyPart(data: publicData, name: "public") 
      }, encodingCompletion: { encodingResult in 
       switch encodingResult { 
       case .Success(let upload, _, _): 
        upload.validate() 
        upload.responseJSON { response in 
         let responseJSON = response.result.value as? [String: AnyObject] 
         if let links = responseJSON!["links"] as? Dictionary<String, AnyObject> { 
          if let imgLink = links["image_link"] as? String { 
           self.postToFirebase(imgLink) 
           print(imgLink) 
          } 
         } 
        } 
       case .Failure(let encodingError): 
        print(encodingError) 
       } 
     }) 

     self.dismissViewControllerAnimated(true, completion: nil) 
     self.tableView.contentOffset = CGPointMake(0, -60); 

} 

Ich denke UIImageJPEGRepresentation (Bild, 0,25)! ist nicht gut Kompressionsfall, meine Bilder kommen aus dem Internet als voller Größe. Wenn ich vor der Komprimierung skaliere, um hochzuladen wie:

Ich denke Web-Plattform kann schlechte Bildqualität sein. Also ich Skala und Caching nach Bildern zum Herunterladen:

//MARK: - Image Downloading 

    func getNetworkImage(urlString: String, comesFrom: String, completion: (UIImage -> Void)) -> (Request) { 

     return Alamofire.request(.GET, urlString).responseImage { (response) -> Void in 
      guard let image = response.result.value else { return } 
      completion(image) 

      if comesFrom == "collectionPage" { 
       self.cacheCollectionImage(image, urlString: urlString) 
      } 
      else if comesFrom == "postPage" { 
       self.cachePostImage(image, urlString: urlString) 
      } 

     } 
    } 

    //MARK: - Image Caching 

    func cacheCollectionImage(image: Image, urlString: String) { 

     let size = CGSize(width: 188.0, height: 120.0) 
     let scaledImage = image.af_imageScaledToSize(size) 

     photoCache.addImage(scaledImage, withIdentifier: urlString) 

    } 

    func cachePostImage(image: Image, urlString: String) { 

     let size = CGSize(width: 300.0, height: 165.0) 
     let scaledImage = image.af_imageScaledToSize(size) 

     photoCache.addImage(scaledImage, withIdentifier: urlString) 

    } 


    func cachedImage(urlString: String) -> Image? { 
     print("cachedImage() func ended") 
     return photoCache.imageWithIdentifier(urlString) 
    } 

Auch meine Anwendung öffnet mit 40MB Speichernutzung. Und als ich sehe, max Top-Nutzung 130MB, nach Uploads und Scrollen, um wieder zurück AutoPurgingImageCache funktioniert und abnehmende Speicher mit, aber ich denke immer noch so viel.

Was raten Sie mir Speicher unter diesen Bedingungen zu speichern? Ich brauche einige Erklärungen, was Sie sagen wollen, Tools oder Strategie, um es so gut wie möglich zu behandeln, wie gute Qualität für jede Plattform.

Answer 1

Sie haben gerade Kopie & den Code aus AlamofireImage eingefügt:

let photoCache = AutoPurgingImageCache(
    memoryCapacity: 100 * 1024 * 1024, 
    preferredMemoryUsageAfterPurge: 60 * 1024 * 1024 
) 

1024 Bytes x 1024 Byte x 100 eine 100 MB-Speicher-Cache erstellen. Wenn dieses Limit erreicht ist, wird die Cachegröße auf 60 MB reduziert. Wenn du keinen so großen Cache willst, reduziere ihn einfach. Es gibt hier keine "richtige" Nummer, es kommt nur auf Ihren Anwendungsfall an. Ich persönlich benutze 20 MB im Cache und 100 MB Cache.