Metodo Alamofire.download(): dove si trova il file e salvato con successo?

Question

L'esempio per l'utilizzo di Alamofire.download() funziona perfettamente, ma non vi sono dettagli su come accedere al file scaricato risultante. Posso capire dove si trova il file e come è stato chiamato in base alla destinazione che ho impostato e alla richiesta di file originale che ho creato, ma suppongo che ci sia un valore a cui dovrei essere in grado di accedere per ottenere il percorso di download finale completo e nome del file nella risposta.

Come accedere al nome del file e come faccio a sapere se è stato salvato correttamente? Riesco a vedere i metodi delegati nell'attuale codice Alamofire che sembra gestire le chiamate di completamento delegate per il processo di download, ma come posso/posso accedere ai dettagli del file nel blocco .response?

Answer 1

L'esempio sul file Leggimi di Alamofire contiene effettivamente il percorso del file, quindi lo prendo con una variabile separata da utilizzare altrove nel mio codice. Non è molto elegante e spero ci sia un modo per ottenere queste informazioni nella risposta, ma per ora, questo è sempre il lavoro fatto:

var fileName: String? 
var finalPath: NSURL? 

Alamofire.download(.GET, urlToCall, { (temporaryURL, response) in 

    if let directoryURL = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)[0] as? NSURL {  

     fileName = response.suggestedFilename! 
     finalPath = directoryURL.URLByAppendingPathComponent(fileName!) 
     return finalPath! 
    } 

    return temporaryURL 
}) 
    .response { (request, response, data, error) in 

     if error != nil { 
      println("REQUEST: \(request)") 
      println("RESPONSE: \(response)") 
     } 

     if finalPath != nil { 
      doSomethingWithTheFile(finalPath!, fileName: fileName!) 
     } 
} 

Answer 2

ho speso circa 8 ore alla ricerca di una risposta a questa uno. La soluzione qui sotto funziona per me, e fondamentalmente collego al metodo di download per visualizzare l'immagine. Nell'esempio che segue, sto scaricando l'immagine del profilo di un utente conoscere il suo ID di Facebook:

let imageURL = "http://graph.facebook.com/\(FBId!)/picture?type=large" 

    let destination: (NSURL, NSHTTPURLResponse) -> (NSURL) = { 
     (temporaryURL, response) in 

     if let directoryURL = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)[0] as? NSURL { 
      var localImageURL = directoryURL.URLByAppendingPathComponent("\(self.FBId!).\(response.suggestedFilename!)") 
      return localImageURL 
     } 
     return temporaryURL 
    } 

    Alamofire.download(.GET, imageURL, destination).response(){ 
     (_, _, data, _) in 
      if let directoryURL = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)[0] as? NSURL { 
       var error: NSError? 
       let urls = NSFileManager.defaultManager().contentsOfDirectoryAtURL(directoryURL, includingPropertiesForKeys: nil, options: nil, error: &error) 

       if error == nil { 
        let downloadedPhotoURLs = urls as! [NSURL] 
        let imagePath = downloadedPhotoURLs[0] // assuming it's the first file 
        let data = NSData(contentsOfURL: imagePath) 
        self.viewProfileImage?.image = UIImage(data: data!) 
       } 
      } 
    } 

Answer 3

Swift 2.1 e un po 'più semplice:

var localPath: NSURL? 
Alamofire.download(.GET, 
    "http://jplayer.org/video/m4v/Big_Buck_Bunny_Trailer.m4v", 
    destination: { (temporaryURL, response) in 
     let directoryURL = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)[0] 
     let pathComponent = response.suggestedFilename 

     localPath = directoryURL.URLByAppendingPathComponent(pathComponent!) 
     return localPath! 
}) 
    .response { (request, response, _, error) in 
     print(response) 
     print("Downloaded file to \(localPath!)") 
} 

ancora difficile da capire perché stanno usando le chiusure per impostare il percorso di destinazione ...

Answer 4

Ecco metodo completo per scaricare file in destinazione con il progresso

// MARK: metodi di download

func downloadFile(reqType : RequestType, urlParam: String,completionHandler: (Double?, NSError?) -> Void) { 

    let documentsPath = NSURL(fileURLWithPath: NSSearchPathForDirectoriesInDomains(.DocumentDirectory, .UserDomainMask, true)[0]) 
    var downloadPath = documentsPath.URLByAppendingPathComponent("downloads") 
    var isDirectory: ObjCBool = false 
    if NSFileManager.defaultManager().fileExistsAtPath(downloadPath.path!, isDirectory: &isDirectory) { 
     if(!isDirectory){ 
      do { 
       try NSFileManager.defaultManager().createDirectoryAtPath(downloadPath.path!, withIntermediateDirectories: true, attributes: nil) 
      }catch { 
       NSLog("Unable to create directory ") 
      } 
     } 
    }else{ 
     do { 
      try NSFileManager.defaultManager().createDirectoryAtPath(downloadPath.path!, withIntermediateDirectories: true, attributes: nil) 
     }catch { 
      NSLog("Unable to create directory ") 
     } 

    } 


    //get the url from GTM 
    let urlString = self.getRequestedUrlFromIdentifier(reqType, param: urlParam) 
    let destination = Alamofire.Request.suggestedDownloadDestination(directory: .DocumentDirectory, domain: .UserDomainMask) 
    Alamofire.download(.GET, urlString, destination: { (temporaryURL, response) in 

     let pathComponent = response.suggestedFilename 
     downloadPath = downloadPath.URLByAppendingPathComponent(pathComponent!) 
     if NSFileManager.defaultManager().fileExistsAtPath(downloadPath.path!) { 
      do{ 
      try NSFileManager.defaultManager().removeItemAtPath(downloadPath.path!) 
      }catch { 

      } 
     } 
     return downloadPath 
    })   .progress { bytesRead, totalBytesRead, totalBytesExpectedToRead in 
      print(totalBytesRead) 

      // This closure is NOT called on the main queue for performance 
      // reasons. To update your ui, dispatch to the main queue. 
      dispatch_async(dispatch_get_main_queue()) { 
       print("Total bytes read on main queue: \(totalBytesRead)") 
      } 
     } 
     .response { request, response, _, error in 
      print(response) 
      let originalPath = destination(NSURL(string: "")!, response!) 
      if let error = error { 
       completionHandler(500000.1 , nil) 
       print("Failed with error: \(error)") 
      } else { 
       completionHandler(500000.0 , nil) 
       print("Downloaded file successfully \(downloadPath)") 
      } 
    } 

} 

Answer 5

This answer da un membro Alamofire sembra essere la risposta migliore:

let destination = Alamofire.Request.suggestedDownloadDestination(
    directory: .CachesDirectory, 
    domain: .UserDomainMask 
) 

Alamofire.download(.GET, "http://www.adobe.com/devnet/acrobat/pdfs/pdf_open_parameters.pdf", destination: destination) 
    .progress { bytesRead, totalBytesRead, totalBytesExpectedToRead in 
     print(totalBytesRead) 
    } 
    .response { request, response, _, error in 
     print(response) 
     print("fileURL: \(destination(NSURL(string: "")!, response))") 
}