Chargement/téléchargement de l'image à partir d'une URL sur Swift
J'aimerais charger une image à partir d'une URL dans mon application. J'ai donc d'abord essayé avec Objective-C et cela a fonctionné, mais avec Swift, j'ai une erreur de compilation:
'imageWithData' n'est pas disponible: utilisez la construction d'objet 'UIImage (data :)'
Ma fonction:
@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";
}
Quelqu'un peut-il m'expliquer s'il vous plaît pourquoi le imageWithData: ne fonctionne pas avec Swift et comment puis-je résoudre le problème.
Xcode 8 ou version ultérieure • Swift 3 ou version ultérieure
Synchrone:
if let filePath = Bundle.main.path(forResource: "imageName", ofType: "jpg"), let image = UIImage(contentsOfFile: filePath) {
imageView.contentMode = .scaleAspectFit
imageView.image = image
}
Asynchrone:
Créez une méthode avec un gestionnaire d'achèvement pour extraire les données d'image de votre URL
func getData(from url: URL, completion: @escaping (Data?, URLResponse?, Error?) -> ()) {
URLSession.shared.dataTask(with: url, completionHandler: completion).resume()
}
Crée une méthode pour télécharger l'image (lance la tâche)
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)
}
}
}
Utilisation:
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.
print("Begin of code")
let url = URL(string: "http://www.Apple.com/euro/ios/ios8/a/generic/images/og.png")!
downloadImage(from: url)
print("End of code. The image will continue downloading in the background and it will be loaded when it ends.")
}
Extension :
extension UIImageView {
func downloaded(from url: URL, contentMode mode: UIViewContentMode = .scaleAspectFit) { // for Swift 4.2 syntax just use ===> mode: UIView.ContentMode
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) { // for Swift 4.2 syntax just use ===> mode: UIView.ContentMode
guard let url = URL(string: link) else { return }
downloaded(from: url, contentMode: mode)
}
}
Usage:
imageView.downloaded(from: "http://www.Apple.com/euro/ios/ios8/a/generic/images/og.png")
(Mise à jour Swift 4) Pour répondre directement à la question d'origine, voici l'équivalent Swift de l'extrait de code affiché par Objective-C.
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!)
AVERTISSEMENT:
Il est important de noter que la méthode Data(contentsOf:) téléchargera le contenu de l'URL synchrone dans le même thread que le code en cours d'exécution, afin que ne l'invoque pas dans le thread principal de votre application.
Une méthode simple pour exécuter le même code de manière asynchrone, sans bloquer l'interface utilisateur, consiste à utiliser 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!)
}
}
Cela dit, dans les applications réelles, si vous voulez avoir la meilleure expérience utilisateur possible et éviter plusieurs téléchargements de la même image, vous pouvez également souhaiter les avoir non seulement téléchargés, mais également mis en cache. Il y a déjà pas mal de bibliothèques qui font cela de manière très transparente et elles sont toutes très faciles à utiliser. Je recommande personnellement 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)
Et c'est tout
Si vous voulez juste charger l'image (asynchrone!) - ajoutez simplement cette petite extension à votre code 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)
}
}
}
}
}
Et utilisez-le de cette façon:
myImageView.imageFromUrl("https://robohash.org/123.png")
Swift 2.2 || Xcode 7.3
J'ai obtenu des résultats étonnants !! avec la bibliothèque AlamofireImage Swift
Il fournit plusieurs fonctionnalités telles que:
- Téléchargement asynchrone
- Purge automatique du cache d'image si des avertissements en matière de mémoire se produisent pour l'application}
- _ {Mise en cache de l'URL de l'image} _
- Caching Image
- _ {Éviter les téléchargements en double} _
et très facile à mettre en œuvre pour votre application
Étape 1: Installer les pods
Alamofire 3.3.x
pod 'Alamofire'
AlamofireImage 2.4.x
pod 'AlamofireImage'
Step.2 import et utilisation
import Alamofire
import AlamofireImage
let downloadURL = NSURL(string: "http://cdn.sstatic.net/Sites/stackoverflow/company/Img/photos/big/6.jpg?v=f4b7c5fee820")!
imageView.af_setImageWithURL(downloadURL)
c'est tout!! il s'occupera de tout
Merci beaucoup à Alamofire, les gars , pour avoir rendu la vie facile à iDevelopers;)
Xcode 8 • Swift 3
La réponse de Leo Dabus est géniale! Je voulais juste fournir une solution de fonction tout en un:
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()
J'ai regroupé le code des meilleures réponses à la question dans une classe unique et réutilisable, qui étend UIImageView. Vous pouvez donc utiliser directement le chargement asynchrone UIImageViews dans votre scénario (ou les créer à partir de code).
Voici ma classe:
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!)
}
}
}
}
et voici comment l'utiliser:
imageView.downloadImage("http://www.image-server.com/myImage.jpg")
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)
FYI: pour 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!)
}
}
}
}
Swift 3 avec gestion des erreurs
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")
}
}
}
}
Avec 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")
}
}
}
}
Utilisation de l'extension
myImageView. setCustomImage ("url")
Swift 2 avec erreur Handle et en-tête de demande personnalisée
Ajoutez simplement une extension à 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()
}
}
}
Et puis, utilisez la nouvelle imageFromUrl(urlString: String) pour télécharger l'image
Utilisation:
imageView.imageFromUrl("https://i.imgur.com/ONaprQV.png")
Swift 4: Un simple chargeur pour les petites images (ex: vignettes) qui utilise NSCache et qui s'exécute toujours sur le thread 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)) }
}
}
}
Usage:
ImageLoader.image(for: imageURL) { image in
self.imageView.image = image
}
Swift 4
Cette méthode téléchargera une image d'un site Web de manière asynchrone et la mettra en cache:
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()
}
Utilisé:
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
}
Swift 2.0:
1)
if let url = NSURL(string: "http://etc...") {
if let data = NSData(contentsOfURL: url) {
imageURL.image = UIImage(data: data)
}
}
OU
imageURL.image =
NSURL(string: "http:// image name...")
.flatMap { NSData(contentsOfURL: $0) }
.flatMap { UIImage(data: $0) }
2) Ajoutez cette méthode à VC ou à l'extension.
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)
}
}
}
Utilisation:
self.load_image(" url strig here")
Kingfisher est l’une des meilleures bibliothèques pour charger une image dans une URL.
URL Github - https://github.com/onevcat/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)
Je recommande d'utiliser la bibliothèque Kingfisher pour télécharger des images de manière asynchrone. L’avantage de Kingfisher est de mettre en cache toutes les images téléchargées par défaut avec l’URL de l’image comme identifiant. La prochaine fois que vous demanderez de télécharger une image avec cette URL particulière, elle sera chargée à partir du cache.
Utilisation:
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()
}
})
Si vous recherchez une implémentation très très simple. (Cela a fonctionné pour moi dans 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)
J'ai implémenté dans une table avec une cellule personnalisée qui n'a qu'une image
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
}
Une méthode permettant d’obtenir une image sûre et compatible avec Swift 2.0 et 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)
}
Vous appelleriez alors cette méthode comme suit:
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 vous mettez à jour la vue avec l'image, vous devrez l'utiliser après "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
}
Si vous utilisez l'image dans l'interface utilisateur, cette dernière partie est nécessaire car les appels réseau prennent du temps. Si vous essayez de mettre à jour l'interface utilisateur à l'aide de l'image sans appeler dispatch_async comme ci-dessus, l'ordinateur recherchera l'image pendant l'extraction de l'image, s'apercevra qu'il n'y a pas d'image (pour le moment) et continue comme s'il n'y avait pas d'image. a trouvé. Placer votre code à l'intérieur d'une fermeture d'achèvement dispatch_async dit à l'ordinateur: "Va chercher cette image et quand tu as terminé, puis complète ce code." De cette façon, vous aurez l'image quand le code sera appelé et tout fonctionnera bien.
Swift 4::
Cela affichera le chargeur pendant le chargement de l'image . Vous pouvez utiliser NSCache qui stocke l'image temporairement
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()
}
}
Utilisation: -
truckImageView.loadImageUsingCache(withUrl: currentTruck.logoString)
Vous pouvez utiliser pod SDWebImage pour obtenir le même résultat. C'est facile à utiliser. Vous pouvez obtenir une documentation ici SDWebImage
Voici l exemple de code
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)
}
})
Réponse Swift 2.x qui télécharge une image dans un fichier (par opposition à la réponse de Leo Dabus, qui stocke l'image en mémoire). Basé sur la réponse de Leo Dabus et la réponse de Rob de Obtenir les données de NSURLSession DownloadTaskWithRequest à partir du gestionnaire d'achèvement :
// 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
}
Swift 4.1 J'ai créé une fonction qui ne fait que passer l'URL de l'image, la clé de cache après la génération de l'image, le définit comme bloc d'achèvement.
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()
})
}
}
}
La seule chose qui manque, c'est 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!)
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()
}
}
J'ai créé une fonction de classe simple dans ma classe Utils.Swift pour appeler cette méthode. Vous pouvez simplement y accéder par classname.methodname et vos images sont enregistrées dans NSCache à l'aide de la classe 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)
}
}
})
Joyeux Codding. À votre santé:)
Voici le code de travail pour charger/télécharger une image à partir d'une URL. NSCache automatiquement et Afficher l'image de remplacement avant le téléchargement et le chargement de l'image réelle (code 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!
}
}
}
}
}
}
}
Utilisez comme ceci:
// 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 }
Utilisez ce code dans Swift
imageView.image=UIImage(data: NSData(contentsOfURL: NSURL(string: "http://myURL/ios8.png")!)!
Swift 4.2 et AlamofireImage
Si l’utilisation d’une bibliothèque n’est pas un problème, vous pouvez le faire à l’aide de la AlamofireImage. Mes exemples proviennent de son Github
Placeholder Images Exemple:
let imageView = UIImageView(frame: frame)
let url = URL(string: "https://httpbin.org/image/png")!
let placeholderImage = UIImage(named: "placeholder")!
imageView.af_setImage(withURL: url, placeholderImage: placeholderImage)
il possède de nombreuses fonctions pratiques et une extension pour travailler avec des images. de la mise en cache à la mise à l'échelle et au redimensionnement ou même à l'application de filtres sur l'image. Si les images sont importantes dans votre application, je vous suggère d'utiliser ce cadre et de gagner du temps.
En utilisant Ascyimageview, vous pouvez facilement charger imageurl dans imageview.
let image1Url: URL = URL (chaîne: "(imageurl)" en tant que chaîne)! imageview.imageURL = image1Url
Chargement de l'image depuis le serveur: -
func downloadImage(from url: URL , success:@escaping((_ image:UIImage)->()),failure:@escaping ((_ msg:String)->())){
print("Download Started")
getData(from: url) { data, response, error in
guard let data = data, error == nil else {
failure("Image cant download from G+ or fb server")
return
}
print(response?.suggestedFilename ?? url.lastPathComponent)
print("Download Finished")
DispatchQueue.main.async() {
if let _img = UIImage(data: data){
success(_img)
}
}
}
}
func getData(from url: URL, completion: @escaping (Data?, URLResponse?, Error?) -> ()) {
URLSession.shared.dataTask(with: url, completionHandler: completion).resume()
}
Utilisation: -
if let url = URL(string: "http://www.Apple.com/euro/ios/ios8/a/generic/images/og.png") {
self.downloadImage(from:url , success: { (image) in
print(image)
}, failure: { (failureReason) in
print(failureReason)
})
}