ios - glide - swift image library

Cargando/Descargando imagen desde URL en Swift

Question

Me gustaría cargar una imagen desde una URL en mi aplicación, así que primero probé con Objective-C y funcionó, sin embargo, con Swift, tengo un error de compilación:

''imageWithData'' no está disponible: use la construcción del objeto ''UIImage (datos :)''

Mi función:

@IBOutlet var imageView : UIImageView
override func viewDidLoad() {
super.viewDidLoad()
var url:NSURL = NSURL.URLWithString("http://myURL/ios8.png")
var data:NSData = NSData.dataWithContentsOfURL(url, options: nil, error: nil)
imageView.image = UIImage.imageWithData(data)// Error here
}

En Objective-C:

- (void)viewDidLoad {
[super viewDidLoad];
NSURL *url = [NSURL URLWithString:(@"http://myURL/ios8.png")];
NSData *data = [NSData dataWithContentsOfURL:url];
_imageView.image = [UIImage imageWithData: data];
_labelURL.text = @"http://www.quentinroussat.fr/assets/img/iOS%20icon''s%20Style/ios8.png";
}

¿Puede alguien explicarme por qué el imageWithData: no funciona con Swift y cómo puedo resolver el problema?

Answer 1

Kingfisher es una de las mejores bibliotecas para cargar imágenes en URL.

URL de Github - Kingfisher

// If you want to use Activity Indicator.
imageview_pic.kf.indicatorType = .activity
imageview_pic.kf.setImage(with: URL(string: "Give your url string"))
// If you want to use custom placeholder image.
imageview_pic.kf.setImage(with: URL(string: "Give your url string"), placeholder: UIImage(named: "placeholder image name"), options: nil, progressBlock: nil, completionHandler: nil)

Answer 2

Aquí está el código de trabajo para cargar / descargar imágenes desde la URL. NSCache automáticamente y muestra la imagen del marcador de posición antes de descargar y cargar la imagen real (código Swift 4).

func NKPlaceholderImage(image:UIImage?, imageView:UIImageView?,imgUrl:String,compate:@escaping (UIImage?) -> Void){
if image != nil && imageView != nil {
imageView!.image = image!
}
var urlcatch = imgUrl.replacingOccurrences(of: "/", with: "#")
let documentpath = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]
urlcatch = documentpath + "/" + "/(urlcatch)"
let image = UIImage(contentsOfFile:urlcatch)
if image != nil && imageView != nil
{
imageView!.image = image!
compate(image)
}else{
if let url = URL(string: imgUrl){
DispatchQueue.global(qos: .background).async {
() -> Void in
let imgdata = NSData(contentsOf: url)
DispatchQueue.main.async {
() -> Void in
imgdata?.write(toFile: urlcatch, atomically: true)
let image = UIImage(contentsOfFile:urlcatch)
compate(image)
if image != nil {
if imageView != nil {
imageView!.image = image!
}
}
}
}
}
}
}

Utilice de esta manera:

// Here imgPicture = your imageView
// UIImage(named: "placeholder") is Display image brfore download and load actual image.
NKPlaceholderImage(image: UIImage(named: "placeholder"), imageView: imgPicture, imgUrl: "Put Here your server image Url Sting") { (image) in }

Answer 3

¡Lo único que falta es un!

let url = NSURL.URLWithString("http://live-wallpaper.net/iphone/img/app/i/p/iphone-4s-wallpapers-mobile-backgrounds-dark_2466f886de3472ef1fa968033f1da3e1_raw_1087fae1932cec8837695934b7eb1250_raw.jpg");
var err: NSError?
var imageData :NSData = NSData.dataWithContentsOfURL(url!,options: NSDataReadingOptions.DataReadingMappedIfSafe, error: &err)
var bgImage = UIImage(data:imageData!)

Answer 4

Envolví el código de las mejores respuestas a la pregunta en una clase única y reutilizable que extiende UIImageView, para que pueda usar directamente UIImageViews de carga asíncrona en su guión gráfico (o crearlas a partir del código).

Aquí está mi clase:

import Foundation
import UIKit
class UIImageViewAsync :UIImageView
{
override init()
{
super.init(frame: CGRect())
}
override init(frame:CGRect)
{
super.init(frame:frame)
}
required init(coder aDecoder: NSCoder) {
super.init(coder: aDecoder)
}
func getDataFromUrl(url:String, completion: ((data: NSData?) -> Void)) {
NSURLSession.sharedSession().dataTaskWithURL(NSURL(string: url)!) { (data, response, error) in
completion(data: NSData(data: data))
}.resume()
}
func downloadImage(url:String){
getDataFromUrl(url) { data in
dispatch_async(dispatch_get_main_queue()) {
self.contentMode = UIViewContentMode.ScaleAspectFill
self.image = UIImage(data: data!)
}
}
}
}

y aquí está cómo usarlo:

imageView.downloadImage("http://www.image-server.com/myImage.jpg")

Answer 5

Para tu información: Para swift-2.0 Xcode7.0 beta2

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!)
}
}
}
}

Answer 6

Puedes usar pod SDWebImage para lograr lo mismo. Es fácil de usar. Puedes obtener documentación aquí SDWebImage

Aquí está el código de ejemplo

self.yourImage.sd_setImage(with: NSURL(string: StrUrl as String ) as URL!, placeholderImage: placeholderImage, options: SDWebImageOptions(rawValue: 0), completed: { (image, error, cacheType, imageURL) in
if( error != nil)
{
print("Error while displaying image" , (error?.localizedDescription)! as String)
}
})

Answer 7

Querrás hacer:

UIImage(data: data)

En Swift, han reemplazado la mayoría de los métodos de fábrica de Objective C con constructores regulares.

Ver:

https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithObjective-CAPIs.html#//apple_ref/doc/uid/TP40014216-CH4-XID_26

Answer 8

Recomiendo usar la biblioteca de Kingfisher para descargar imágenes de forma asíncrona. La mejor parte sobre el uso de Kingfisher es que almacena en caché todas las imágenes descargadas de forma predeterminada con la url de la imagen como identificación. La próxima vez que solicite descargar una imagen con esa URl en particular, la cargará desde el caché.

Uso:

newsImage.kf.setImage(with: imageUrl!, placeholder: nil, options: nil, progressBlock: nil, completionHandler: { (image, error, cacheType, imageUrl) in
if error == nil{
self.activityIndicator.stopAnimating()
}else if error != nil{
self.activityIndicator.stopAnimating()
}
})

Answer 9

Si estás buscando una implementación muy simple. (Esto funcionó para mí en Swift 2)

 let imageURL = NSURL(string: "https://farm2.staticflickr.com/1591/26078338233_d1466b7da2_m.jpg")
let imagedData = NSData(contentsOfURL: imageURL!)!
imageView?.image = UIImage(data: imagedData)

Implementé dentro de una vista de tabla con una celda personalizada que solo tiene una imagen

func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell{
let cell = tableView.dequeueReusableCellWithIdentifier("theCell", forIndexPath: indexPath) as! customTableViewCell
let imageURL = NSURL(string: "https://farm2.staticflickr.com/1591/26078338233_d1466b7da2_m.jpg")
let imagedData = NSData(contentsOfURL: imageURL!)!
cell.imageView?.image = UIImage(data: imagedData)
return cell
}

Answer 10

Si solo desea cargar la imagen (¡de forma asíncrona!) , Simplemente agregue esta pequeña extensión a su código swift:

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
if let imageData = data as NSData? {
self.image = UIImage(data: imageData)
}
}
}
}
}

Y úsalo de esta manera:

myImageView.imageFromUrl("https://robohash.org/123.png")

Answer 11

Swift 2.x responde que descarga imagen a archivo (a diferencia de la respuesta de Leo Dabus, que almacena la imagen en la memoria). Basado en la respuesta de Leo Dabus y en la respuesta de Rob de Obtenga los datos de NSURLSession DownloadTaskWithRequest del controlador de finalización :

 // Set download vars
let downloadURL = NSURL() // URL to download from
let localFilename = "foobar.png" // Filename for storing locally
// Create download request
let task = NSURLSession.sharedSession().downloadTaskWithURL(downloadURL) { location, response, error in
guard location != nil && error == nil else {
print("Error downloading message: /(error)")
return
}
// If here, no errors so save message to permanent location
let fileManager = NSFileManager.defaultManager()
do {
let documents = try fileManager.URLForDirectory(.DocumentDirectory, inDomain: .UserDomainMask, appropriateForURL: nil, create: false)
let fileURL = documents.URLByAppendingPathComponent(localFilename)
try fileManager.moveItemAtURL(location!, toURL: fileURL)
self.doFileDownloaded(fileURL, localFilename: localFilename)
print("Downloaded message @ /(localFilename)")
} catch {
print("Error downloading message: /(error)")
}
}
// Start download
print("Starting download @ /(downloadURL)")
task.resume()
// Helper function called after file successfully downloaded
private func doFileDownloaded(fileURL: NSURL, localFilename: String) {
// Do stuff with downloaded image
}

Answer 12

Swift 3 con manejo de errores

let url = URL(string: arr[indexPath.row] as! String)
if url != nil {
DispatchQueue.global().async {
let data = try? Data(contentsOf: url!) //make sure your image in this url does exist, otherwise unwrap in a if let check / try-catch
DispatchQueue.main.async {
if data != nil {
cell.imgView.image = UIImage(data:data!)
}else{
cell.imgView.image = UIImage(named: "default.png")
}
}
}
}

Con extension

extension UIImageView {
func setCustomImage(_ imgURLString: String?) {
guard let imageURLString = imgURLString else {
self.image = UIImage(named: "default.png")
return
}
DispatchQueue.global().async {
let data = try? Data(contentsOf: URL(string: imageURLString)!)
DispatchQueue.main.async {
self.image = data != nil ? UIImage(data: data!) : UIImage(named: "default.png")
}
}
}
}

Uso de la extensión

myImageView. setCustomImage ("url")

Answer 13

Swift 4

Este método descargará una imagen de un sitio web de forma asíncrona y la almacenará en caché:

 func getImageFromWeb(_ urlString: String, closure: @escaping (UIImage?) -> ()) {
guard let url = URL(string: urlString) else {
return closure(nil)
}
let task = URLSession(configuration: .default).dataTask(with: url) { (data, response, error) in
guard error == nil else {
print("error: /(String(describing: error))")
return closure(nil)
}
guard response != nil else {
print("no response")
return closure(nil)
}
guard data != nil else {
print("no data")
return closure(nil)
}
DispatchQueue.main.async {
closure(UIImage(data: data!))
}
}; task.resume()
}

En uso:

 getImageFromWeb("http://www.apple.com/euro/ios/ios8/a/generic/images/og.png") { (image) in
if let image = image {
let imageView = UIImageView(frame: CGRect(x: 0, y: 0, width: 200, height: 200))
imageView.image = image
self.view.addSubview(imageView)
} // if you use an Else statement, it will be in background
}

Answer 14

Swift 4.1 He creado una función que solo pasa la URL de la imagen; la clave de caché después de generar la imagen la configura para completar el bloque.

 class NetworkManager: NSObject {
private var imageQueue = OperationQueue()
private var imageCache = NSCache<AnyObject, AnyObject>()
func downloadImageWithUrl(imageUrl: String, cacheKey: String, completionBlock: @escaping (_ image: UIImage?)-> Void) {
let downloadedImage = imageCache.object(forKey: cacheKey as AnyObject)
if let _ = downloadedImage as? UIImage {
completionBlock(downloadedImage as? UIImage)
} else {
let blockOperation = BlockOperation()
blockOperation.addExecutionBlock({
let url = URL(string: imageUrl)
do {
let data = try Data(contentsOf: url!)
let newImage = UIImage(data: data)
if newImage != nil {
self.imageCache.setObject(newImage!, forKey: cacheKey as AnyObject)
self.runOnMainThread {
completionBlock(newImage)
}
} else {
completionBlock(nil)
}
} catch {
completionBlock(nil)
}
})
self.imageQueue.addOperation(blockOperation)
blockOperation.completionBlock = {
print("Image downloaded /(cacheKey)")
}
}
}
}
extension NetworkManager {
fileprivate func runOnMainThread(block:@escaping ()->Void) {
if Thread.isMainThread {
block()
} else {
let mainQueue = OperationQueue.main
mainQueue.addOperation({
block()
})
}
}
}

Answer 15

Swift 4.2 Xcode 10.1 Desde la extensión de vista de imagen URL de cadena

extension UIImageView {
func downloaded(from url: URL, contentMode mode: UIView.ContentMode = .scaleAspectFit) {
contentMode = mode
URLSession.shared.dataTask(with: url) { data, response, error in
guard
let httpURLResponse = response as? HTTPURLResponse, httpURLResponse.statusCode == 200,
let mimeType = response?.mimeType, mimeType.hasPrefix("image"),
let data = data, error == nil,
let image = UIImage(data: data)
else { return }
DispatchQueue.main.async() {
self.image = image
}
}.resume()
}
func downloaded(from link: String, contentMode mode: UIView.ContentMode = .scaleAspectFit) {
guard let url = URL(string: link) else { return }
downloaded(from: url, contentMode: mode)
}
}

Answer 16

Un método para obtener la imagen que es segura y funciona con Swift 2.0 y X-Code 7.1:

static func imageForImageURLString(imageURLString: String, completion: (image: UIImage?, success: Bool) -> Void) {
guard let url = NSURL(string: imageURLString),
let data = NSData(contentsOfURL: url),
let image = UIImage(data: data)
else {
completion(image: nil, success: false);
return
}
completion(image: image, success: true)
}

Entonces llamaría a este método así:

imageForImageURLString(imageString) { (image, success) -> Void in
if success {
guard let image = image
else { return } // Error handling here
// You now have the image.
} else {
// Error handling here.
}
}

Si está actualizando la vista con la imagen, tendrá que usar esto después de "if success {":

 dispatch_async(dispatch_get_main_queue()) { () -> Void in
guard let image = image
else { return } // Error handling here
// You now have the image. Use the image to update the view or anything UI related here
// Reload the view, so the image appears
}

La razón por la que se necesita esta última parte si está usando la imagen en la interfaz de usuario es porque las llamadas de red llevan tiempo. Si intenta actualizar la interfaz de usuario usando la imagen sin llamar a dispatch_async como se muestra arriba, la computadora buscará la imagen mientras la imagen aún está siendo captada, encontrará que no hay imagen (todavía) y continuará como si no hubiera imagen encontró. Al poner el código dentro de un cierre de finalización de dispatch_async, se le dice a la computadora: "Ve, obtén esta imagen y cuando hayas terminado, completa este código". De esa manera, tendrá la imagen cuando se llame el código y las cosas funcionarán bien.

Answer 17

Utilizando Ascyimageview puedes cargar fácilmente imageurl en imageview.

let image1Url: URL = URL (string: "(imageurl)" como String)! imageview.imageURL = image1Url

Answer 18

(Actualización de Swift 4) Para responder directamente a la pregunta original, aquí está el equivalente veloz del fragmento de código de Objective-C publicado.

let url = URL(string: image.url)
let data = try? Data(contentsOf: url!) //make sure your image in this url does exist, otherwise unwrap in a if let check / try-catch
imageView.image = UIImage(data: data!)

RENUNCIA:

Es importante tener en cuenta que el método Data(contentsOf:) descargará el contenido de la url de forma síncrona en el mismo hilo en el que se ejecuta el código, por lo que no lo invoque en el hilo principal de su aplicación.

Una forma fácil de hacer que el mismo código se ejecute de forma asíncrona, sin bloquear la interfaz de usuario, es mediante el uso de GCD:

let url = URL(string: image.url)
DispatchQueue.global().async {
let data = try? Data(contentsOf: url!) //make sure your image in this url does exist, otherwise unwrap in a if let check / try-catch
DispatchQueue.main.async {
imageView.image = UIImage(data: data!)
}
}

Dicho esto, en las aplicaciones de la vida real, si desea tener la mejor experiencia de usuario y evitar múltiples descargas de la misma imagen, es posible que también desee que no solo se descarguen, sino que se almacenen en caché. Ya hay bastantes bibliotecas que lo hacen muy bien y todas son muy fáciles de usar. Personalmente recomiendo Kingfisher :

import Kingfisher
let url = URL(string: "url_of_your_image")
// this downloads the image asynchronously if it''s not cached yet
imageView.kf.setImage(with: url)

Y eso es

Answer 19

Swift 2 con manejador de error y encabezado de solicitud personalizado

Simplemente agregue la extensión a UIImageView:

extension UIImageView {
public func imageFromUrl(urlString: String) {
if let url = NSURL(string: urlString) {
let request = NSMutableURLRequest(URL: url)
request.setValue("<YOUR_HEADER_VALUE>", forHTTPHeaderField: "<YOUR_HEADER_KEY>")
NSURLSession.sharedSession().dataTaskWithRequest(request) {
(data, response, error) in
guard let data = data where error == nil else{
NSLog("Image download error: /(error)")
return
}
if let httpResponse = response as? NSHTTPURLResponse{
if httpResponse.statusCode > 400 {
let errorMsg = NSString(data: data, encoding: NSUTF8StringEncoding)
NSLog("Image download error, statusCode: /(httpResponse.statusCode), error: /(errorMsg!)")
return
}
}
dispatch_async(dispatch_get_main_queue(), {
NSLog("Image download success")
self.image = UIImage(data: data)
})
}.resume()
}
}
}

Y luego, use el nuevo imageFromUrl(urlString: String) para descargar la imagen

Uso:

imageView.imageFromUrl("https://i.imgur.com/ONaprQV.png")

Answer 20

Swift 2.0:

1)

if let url = NSURL(string: "http://etc...") {
if let data = NSData(contentsOfURL: url) {
imageURL.image = UIImage(data: data)
}
}

O

imageURL.image =
NSURL(string: "http:// image name...")
.flatMap { NSData(contentsOfURL: $0) }
.flatMap { UIImage(data: $0) }

2) Agregue este método a VC o Extensión.

func load_image(urlString:String)
{ let imgURL: NSURL = NSURL(string: urlString)!
let request: NSURLRequest = NSURLRequest(URL: imgURL)
NSURLConnection.sendAsynchronousRequest(request, queue: NSOperationQueue.mainQueue()) { (response: NSURLResponse?, data: NSData?, error: NSError?) in
if error == nil {
self.image_element.image = UIImage(data: data)
}
}
}

Uso:

self.load_image(" url strig here")

Answer 21

Swift 2.2 || Xcode 7.3

¡Conseguí resultados asombrosos !! con la biblioteca swift de AlamofireImage

Proporciona múltiples características como:

• Descarga asíncrona
• Auto Purging Image Cache si ocurren advertencias de memoria para la aplicación
• URL de imagen en caché
• Imagen de caché
• Evite descargas duplicadas

y muy fácil de implementar para tu aplicación

Paso.1 instalar pods

Alamofire 3.3.x

vaina ''Alamofire''

AlamofireImage 2.4.x

pod ''AlamofireImage''

Paso 2 importación y uso

import Alamofire
import AlamofireImage
let downloadURL = NSURL(string: "http://cdn.sstatic.net/Sites//company/Img/photos/big/6.jpg?v=f4b7c5fee820")!
imageView.af_setImageWithURL(downloadURL)

¡¡Eso es!! se encargará de todo

Muchas gracias a los chicos de Alamofire , por hacer la vida de iDevelopers fácil;)

Answer 22

Swift 4: un cargador simple para imágenes pequeñas (ej: miniaturas) que usa NSCache y siempre se ejecuta en el hilo principal:

class ImageLoader {
private static let cache = NSCache<NSString, NSData>()
class func image(for url: URL, completionHandler: @escaping(_ image: UIImage?) -> ()) {
DispatchQueue.global(qos: DispatchQoS.QoSClass.background).async {
if let data = self.cache.object(forKey: url.absoluteString as NSString) {
DispatchQueue.main.async { completionHandler(UIImage(data: data as Data)) }
return
}
guard let data = NSData(contentsOf: url) else {
DispatchQueue.main.async { completionHandler(nil) }
return
}
self.cache.setObject(data, forKey: url.absoluteString as NSString)
DispatchQueue.main.async { completionHandler(UIImage(data: data as Data)) }
}
}
}

Uso:

ImageLoader.image(for: imageURL) { image in
self.imageView.image = image
}

Answer 23

Swift 4 ::

Esto mostrará el cargador mientras se carga la imagen. Puedes usar NSCache que almacena imagen temporalmente

let imageCache = NSCache<NSString, UIImage>()
extension UIImageView {
func loadImageUsingCache(withUrl urlString : String) {
let url = URL(string: urlString)
if url == nil {return}
self.image = nil
// check cached image
if let cachedImage = imageCache.object(forKey: urlString as NSString) {
self.image = cachedImage
return
}
let activityIndicator: UIActivityIndicatorView = UIActivityIndicatorView.init(activityIndicatorStyle: .gray)
addSubview(activityIndicator)
activityIndicator.startAnimating()
activityIndicator.center = self.center
// if not, download image from url
URLSession.shared.dataTask(with: url!, completionHandler: { (data, response, error) in
if error != nil {
print(error!)
return
}
DispatchQueue.main.async {
if let image = UIImage(data: data!) {
imageCache.setObject(image, forKey: urlString as NSString)
self.image = image
activityIndicator.removeFromSuperview()
}
}
}).resume()
}
}

Uso:-

truckImageView.loadImageUsingCache(withUrl: currentTruck.logoString)

Answer 24

Usa este código en Swift

imageView.image=UIImage(data: NSData(contentsOfURL: NSURL(string: "http://myURL/ios8.png")!)!

Answer 25

Xcode 8 • Swift 3

Sincrónicamente:

if let filePath = Bundle.main.path(forResource: "imageName", ofType: "jpg"), let image = UIImage(contentsOfFile: filePath) {
imageView.contentMode = .scaleAspectFit
imageView.image = image
}

Asincrónicamente:

Cree un método con un controlador de finalización para obtener los datos de imagen de su url

func getData(from url: URL, completion: @escaping (Data?, URLResponse?, Error?) -> ()) {
URLSession.shared.dataTask(with: url, completionHandler: completion).resume()
}

Crear un método para descargar la imagen (iniciar la tarea)

func downloadImage(from url: URL) {
print("Download Started")
getData(from: url) { data, response, error in
guard let data = data, error == nil else { return }
print(response?.suggestedFilename ?? url.lastPathComponent)
print("Download Finished")
DispatchQueue.main.async() {
self.imageView.image = UIImage(data: data)
}
}
}

Uso:

override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
print("Begin of code")
if let url = URL(string: "http://www.apple.com/euro/ios/ios8/a/generic/images/og.png") {
imageView.contentMode = .scaleAspectFit
downloadImage(from: url)
}
print("End of code. The image will continue downloading in the background and it will be loaded when it ends.")
}

Extensión :

extension UIImageView {
func downloaded(from url: URL, contentMode mode: UIViewContentMode = .scaleAspectFit) {
contentMode = mode
URLSession.shared.dataTask(with: url) { data, response, error in
guard
let httpURLResponse = response as? HTTPURLResponse, httpURLResponse.statusCode == 200,
let mimeType = response?.mimeType, mimeType.hasPrefix("image"),
let data = data, error == nil,
let image = UIImage(data: data)
else { return }
DispatchQueue.main.async() {
self.image = image
}
}.resume()
}
func downloaded(from link: String, contentMode mode: UIViewContentMode = .scaleAspectFit) {
guard let url = URL(string: link) else { return }
downloaded(from: url, contentMode: mode)
}
}

Uso:

imageView.downloaded(from: "http://www.apple.com/euro/ios/ios8/a/generic/images/og.png")

Answer 26

Xcode 8 • Swift 3

¡La respuesta de Leo Dabus es increíble! Solo quería proporcionar una solución de función todo en uno:

let url = URL(string:
"http://www.apple.com/euro/ios/ios8/a/generic/images/og.png")
let task = URLSession.shared.dataTask(with: url!) { data, response, error in
guard let data = data, error == nil else { return }
DispatchQueue.main.async() { // execute on main thread
self.imageView.image = UIImage(data: data)
}
}
task.resume()

Answer 27

Para Swift-3 y superior:

extension UIImageView {
public func imageFromUrl(urlString: String) {
if let url = URL(string: urlString) {
let request = URLRequest(url: url)
NSURLConnection.sendAsynchronousRequest(request as URLRequest, queue: .main, completionHandler: { (response, data, error) in
if let imageData = data as NSData? {
self.image = UIImage(data: imageData as Data)
}
})
}
}
}

Answer 28

class func downloadImageFromUrl(with urlStr: String, andCompletionHandler:@escaping (_ result:Bool) -> Void) {
guard let url = URL(string: urlStr) else {
andCompletionHandler(false)
return
}
DispatchQueue.global(qos: .background).async {
URLSession.shared.dataTask(with: url, completionHandler: { (data, response, error) -> Void in
if error == nil {
let httpURLResponse = response as? HTTPURLResponse
Utils.print( "status code ID : /(String(describing: httpURLResponse?.statusCode))")
if httpURLResponse?.statusCode == 200 {
if let data = data {
if let image = UIImage(data: data) {
ImageCaching.sharedInterface().setImage(image, withID: url.absoluteString as NSString)
DispatchQueue.main.async {
andCompletionHandler(true)
}
}else {
andCompletionHandler(false)
}
}else {
andCompletionHandler(false)
}
}else {
andCompletionHandler(false)
}
}else {
andCompletionHandler(false)
}
}).resume()
}
}

He creado una función de clase simple en mi clase Utils.swift para llamar a ese método al que simplemente puede acceder mediante classname.methodname y sus imágenes se guardan en NSCache usando la clase ImageCaching.swift

Utils.downloadImageFromUrl(with: URL, andCompletionHandler: { (isDownloaded) in
if isDownloaded {
if let image = ImageCaching.sharedInterface().getImage(URL as NSString) {
self.btnTeam.setBackgroundImage(image, for: .normal)
}
}else {
DispatchQueue.main.async {
self.btnTeam.setBackgroundImage(#imageLiteral(resourceName: "com"), for: .normal)
}
}
})

Codificación feliz. Aclamaciones:)

Answer 29

let url = NSURL.URLWithString("http://live-wallpaper.net/iphone/img/app/i/p/iphone-4s-wallpapers-mobile-backgrounds-dark_2466f886de3472ef1fa968033f1da3e1_raw_1087fae1932cec8837695934b7eb1250_raw.jpg");
var err: NSError?
var imageData :NSData = NSData.dataWithContentsOfURL(url,options: NSDataReadingOptions.DataReadingMappedIfSafe, error: &err)
var bgImage = UIImage(data:imageData)