daltoniam / skeets Goto Github PK

var attempted = false
request.auth = {(challenge: NSURLAuthenticationChallenge) in
    if !attempted {
        attempted = true
        return NSURLCredential(forTrust: challenge.protectionSpace.serverTrust)
    }
    return nil
}

let task = HTTPTask()
                    var attempted = false
                    task.auth = {(challenge: NSURLAuthenticationChallenge) in
                        if !attempted {
                            attempted = true
                            return NSURLCredential(forTrust: challenge.protectionSpace.serverTrust)
                        }
                        return nil
                    }

                    task.download(url, parameters: nil, progress: { (status: Double) in
                        dispatch_async(dispatch_get_main_queue(), {
                            self.doProgress(hash, status: status)
                        })
                        }, completionHandler: { (response: HTTPResponse) in
                            if let err = response.error {
                                dispatch_async(dispatch_get_main_queue(), {
                                    self.doFailure(hash, error: err)
                                })
                            }
                            self.cache.add(hash, url: response.responseObject! as! NSURL)
                            dispatch_async(dispatch_get_main_queue(), {
                                if let d = self.cache.fromMemory(hash) {
                                    self.doSuccess(hash, data: d)
                                }
                            })
                        })

return self.requestSerializer.createRequest(NSURL(string: urlVal)!,
            method: method, parameters: parameters)
    }

 func collectionView(collectionView: UICollectionView, cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {
        let cell = collectionView.dequeueReusableCellWithReuseIdentifier(reuseIdentifier, forIndexPath: indexPath) as PartCollectionViewCell

        cell.backgroundColor = UIColor.whiteColor()

        //fetch the image
        ImageManager.sharedManager.fetch(imagePath,
            progress: { (status: Double) in
            },success: { (data: NSData) in
                cell.ivIcon.image = UIImage(data: data)
            }, failure: { (error: NSError) in
                cell.ivIcon.image = nil
        })

        return cell
    }

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

    let paths = NSSearchPathForDirectoriesInDomains(.CachesDirectory, .UserDomainMask, true)
    ImageManager.sharedManager.cache.diskDirectory = "\(paths[0])/ImageCache"

    ImageManager.sharedManager.cache.clearCache()
}

var profileImageUrl:String = "" {
        didSet {
            //fetch the image
            ImageManager.fetch(profileImageUrl,
                progress: { (status: Double) in
                    println("\(status)")
                    self.ProfileImageLoading.startAnimating()
                },success: { (data: NSData) in
                    println("got image")
                    self.ProfileImage.image = UIImage(data: data) //set the image data
                    self.ProfileImage.backgroundColor = UIColor.clearColor()
                    self.ProfileImageLoading.stopAnimating()
                }, failure: { (error: NSError) in
                    self.ProfileImageLoading.stopAnimating()
            })
        }
    }

ImageManager.fetch(img1, progress: { (progress: Double) in
                    }, success: { (data: NSData) in
                        myImage1 = UIImage(data:data)
                        //do whatever stuff with image

                    }, failure: { (error: NSError) in
                        println(error)
                })

ImageManager.fetch(img2, progress: { (progress: Double) in
                    }, success: { (data: NSData) in
                         myImage2 = UIImage(data:data)
                        //do whatever stuff with image
                    }, failure: { (error: NSError) in
                        println(error)
                })

ImageManager.fetch(user.profilePic, progress: { (progress: Double) in
                    }, success: { (data: NSData) in
                        cell.imageView?.image = UIImage(data: data)
                        println("image loaded")

                    }, failure: { (error: NSError) in
                        println("failed to get image: \(error)")
                })

if self.pending[hash] == nil {
            var holder = Array<BlockHolder>()
            holder.append(BlockHolder(progress: progress, success: success, failure: failure))
            self.pending[hash] = holder
            //next check from disk asynchronously
            cache.fromDisk(hash, success: { (d: NSData) in
                self.doSuccess(hash, data: d)
                }, failure: { (Void) in
                    //lastly fetch from the network asynchronously
                    let task = HTTPTask()
                    task.download(url, parameters: nil, progress: { (status: Double) in
                        self.doProgress(hash, status: status)
                        }, success: { (response: HTTPResponse) in
                            self.cache.add(hash, url: response.responseObject! as NSURL)
                            self.doSuccess(hash, data: self.cache.fromMemory(hash)!)
                        }, failure: { (error: NSError, response: HTTPResponse?) in
                            self.doFailure(hash, error: error)
                    })
            })
        } else if var array = self.pending[hash] {
            array.append(BlockHolder(progress: progress, success: success, failure: failure))
            self.pending[hash] = array
        }