Cómo cargar imágenes en swift usando Alamofire
afnetworking (8)
Aquí hay un enfoque utilizando RxAlamofire:
import Alamofire
import RxAlamofire
extension UIImageView {
public func imageFromUrl(urlString: String) {
requestData(.GET, urlString)
.observeOn(MainScheduler.instance)
.subscribeNext { self.image = UIImage(data: $0.1) }
}
}
Tengo un controlador de vista de colección, que carga la imagen asíncrona por URL. (Algo así como Instegram) Estoy buscando la mejor manera de implementar la parte de la imagen de carga. por favor dime que piensas
Primera forma - sin ninguna biblioteca externa:
let downloadQueue = dispatch_queue_create("com.pro.asyncImages",nil)
dispatch_async(downloadQueue){
var data = NSData(contentsOfURL: NSURL(string: pictureUrl!)!)
var image: UIImage?
if (data != nil){
image = UIImage(data: data!)
}
dispatch_async(dispatch_get_main_queue()){
uiImageView.image = image
}
}
Segunda vía - usando Alamofire (la solicitud pertenece a Alamofire)
if let mediaUrl = info.mediaUrl {
request(.GET,mediaUrl).response(){
(_, _, data, _) in
let image = UIImage(data: data! as NSData)
imageView.image = image
}
}
Y por último, leí que AFNetworking, está haciendo un gran trabajo al cargar url async to urlImage, que es lo que quiero hacer.
Entonces, ¿es AFNetworking mejor para esta tarea? (luego Alamofire) y si no, no entendí cómo agregar AFNetworking a mi proyecto Swift, además de agregar el #import "AFNetworking.h", ¿qué archivos debo agregar?
por favor explique cuál es el mejor método, mis necesidades son el rendimiento, la acusación y el almacenamiento en caché. El controlador de colección de vistas actúa como Instegram y carga imágenes, mientras se desplaza hacia abajo. Espero haber sido lo suficientemente claro sobre lo que necesito, gracias
Como mencionan los autores en Alamofire README.md :
¿Cuándo debo usar AFNetworking?
- Extensiones de UIKit, como cargar imágenes de forma asíncrona en UIImageView
Así que responde a tu pregunta:
Entonces, ¿es AFNetworking mejor para esta tarea?
¡Sí!
Pero si aún desea utilizar el proyecto de vainilla Alamofire , puede obtener la imagen de esta manera:
Alamofire.request(.GET, "https://robohash.org/123.png").response { (request, response, data, error) in
self.myImageView.image = UIImage(data: data, scale:1)
}
PD
Pero si solo desea cargar una imagen (por supuesto, asíncrono), no necesita utilizar Alamofire o AFNetworking . Solo agrega esta pequeña extensión en tu código:
extension UIImageView {
public func imageFromUrl(urlString: String) {
if let url = NSURL(string: urlString) {
let request = NSURLRequest(URL: url)
NSURLConnection.sendAsynchronousRequest(request, queue: NSOperationQueue.mainQueue()) {
(response: NSURLResponse!, data: NSData!, error: NSError!) -> Void in
self.image = UIImage(data: data)
}
}
}
}
Y úsalo:
myImageView.imageFromUrl("https://robohash.org/123.png")
Creé una versión Swift de UIImageView + AFNetworking aquí: Github .
No tiene que usar AFNetworking (y un encabezado puente) o Alamofire en su proyecto. Solo agrega el archivo a tu proyecto y úsalo.
Ejemplo de uso:
myImageView.setImageWithUrl(imageUrl, placeHolderImage: somePlaceHolderImage)
En realidad, hay varias formas de cargar su imagen desde la URL usando Alamofire. y esta es una forma en la que me he desarrollado y ya lo estoy usando en uno de mis proyectos Swift. De esta manera, estoy cargando las imágenes de forma asíncrona y las muestro en UITableView y, desde el punto de vista del rendimiento, está bien y no hay bloqueo mientras se desplaza a UITableView porque se preocupa por cambiar las imágenes cargadas.
Primero, debe crear una solicitud GET utilizando Alamofire para descargar la imagen, y tiene que usar Request + AlamofireImage de la Biblioteca de AlamofireImage para tener que
import AlamofireImage
Y luego en
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
}
Tienes que llamar a tu solicitud de descarga de imagen de esta manera:
//Download image
// We should perform this in a background thread
Alamofire.request(.GET, deshItem.dish_imageUrl!)
.responseImage { response in
debugPrint(response)
print(response.request)
print(response.response)
debugPrint(response.result)
if let image = response.result.value {
print("image downloaded: /(image)")
// Store the commit date in to our cache
self.ImageCache[dishName!] = image
// Update the cell
dispatch_async(dispatch_get_main_queue(), {
if let cellToUpdate = tableView.cellForRowAtIndexPath(indexPath) {
let dishImageView:UIImageView = cellToUpdate.viewWithTag(104) as! UIImageView
dishImageView.image = image
}
})
}
}
Para el almacenamiento en caché de imágenes, he creado un diccionario que contendrá imágenes para cada celda o elemento (cadena), por lo que esta forma de almacenamiento en caché de las imágenes evitará el bloqueo que aparece al desplazarse.
Código de ejemplo completo:
import AlamofireImage
class MainFeedTableViewController: UITableViewController, FloatRatingViewDelegate {
var ImageCache = [String:UIImage]()
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier("MainFeedCellID", forIndexPath: indexPath)
// Configure the cell...
let dishName = deshItem.dish_name
//This is a workaround to cash the image and improve the performance while user scrolling UITableView.
// If this image is already cached, don''t re-download
if let dishImage = ImageCache[dishName!] {
let dishImageView:UIImageView = cell.viewWithTag(104) as! UIImageView
dishImageView.image = dishImage
}
else {
//Download image
// We should perform this in a background thread
Alamofire.request(.GET, deshItem.dish_imageUrl!)
.responseImage { response in
debugPrint(response)
print(response.request)
print(response.response)
debugPrint(response.result)
if let image = response.result.value {
print("image downloaded: /(image)")
// Store the commit date in to our cache
self.ImageCache[dishName!] = image
// Update the cell
dispatch_async(dispatch_get_main_queue(), {
if let cellToUpdate = tableView.cellForRowAtIndexPath(indexPath) {
let dishImageView:UIImageView = cellToUpdate.viewWithTag(104) as! UIImageView
dishImageView.image = image
}
})
}
}
}
return cell
}
He desarrollado una pequeña y sencilla biblioteca de CocoaPods para trabajar con Alamofire e Images.
CocoaPods es una excelente manera de abordar las necesidades de dependencias de su biblioteca. Es fácil de instalar una vez, y fácil de agregar y actualizar dependencias para sus proyectos.
La biblioteca es de código abierto y se puede encontrar en https://github.com/gchiacchio/AlamoImage
Tiene una gran documentación con ejemplos, por lo que la disfrutarás en minutos.
Lo tengo trabajando en un par de proyectos, incluyendo vistas de colección y desplazamiento.
Puede descargar la imagen usando responseData(queue:completionHandler:)
SWIFT 4
func downloadImages(imageURL: String) {
Alamofire.request(imageURL, method: .get)
.validate()
.responseData(completionHandler: { (responseData) in
self.yourImageVIew.image = UIImage(data: responseData.data!)
DispatchQueue.main.async {
// Refresh you views
}
})
}
Si desea usar el marco UImageView de AFNetworking, debe hacer #import "UIImageView+AFNetworking.h" en su archivo de cabecera de puente.
AFNetworking tiene una memoria caché compartida, por lo que no necesitará almacenar o cancelar manualmente sus solicitudes. El setImageWithURL de AFNetworking puede convertir fácilmente una URL a una imagen en ImageView.
Código de ejemplo usando UIImage+AFNetworking :
cell.imageView.setImageWithURL(NSURL(string:imageSource), placeholderImage: UIImage(named:"placeholder"))
Si está utilizando Alamofire, tiene que convertir manualmente NSData a UIImage. Para Alamofire, puede crear un objeto NSCache() para almacenar en caché sus imágenes. El rendimiento de ambas bibliotecas debería ser similar. Puede usar Alamofire para las llamadas a la API de su servidor y luego usar AFNetworking para mostrar imágenes de forma asíncrona.
Código de muestra usando Alamofire para el caché de imágenes:
let imageCache = NSCache()
if let image = self.imageCache.objectForKey(imageURL) as? UIImage {
cell.imageView.image = image
} else {
// 3
cell.imageView.image = nil
// 4
cell.request = Alamofire.request(.GET, imageURL).validate(contentType: ["image/*"]).responseImage() {
(request, _, image, error) in
if error == nil && image != nil {
// 5
self.imageCache.setObject(image!, forKey: request.URLString)
// 6
if request.URLString == cell.request?.request.URLString {
cell.imageView.image = image
}
} else {
/*
If the cell went off-screen before the image was downloaded, we cancel it and
an NSURLErrorDomain (-999: cancelled) is returned. This is a normal behavior.
*/
}
}
}
Puede leer este tutorial para obtener más detalles sobre el uso de Alamofire.
Tomado de Alamofire / README.md
"Con el fin de mantener Alamofire enfocado específicamente en las implementaciones de redes centrales, Alamofire Software Foundation ha creado bibliotecas de componentes adicionales para brindar funcionalidad adicional al ecosistema de Alamofire.
AlamofireImage: una biblioteca de imágenes que incluye serializadores de respuesta de imagen, extensiones de UIImage y UIImageView, filtros de imagen personalizados, un caché de la memoria que se purga automáticamente y un sistema de descarga de imágenes basado en la prioridad