appjam 0.1.8.8 → 0.1.8.9

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/frameworks/SDWebImage/SDWebImageManager.m

@@ -0,0 +1,244 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import "SDWebImageManager.h"
+#import <objc/message.h>
+
+@interface SDWebImageCombinedOperation : NSObject <SDWebImageOperation>
+
+@property (assign, nonatomic, getter = isCancelled) BOOL cancelled;
+@property (copy, nonatomic) void (^cancelBlock)();
+
+@end
+
+@interface SDWebImageManager ()
+
+@property (strong, nonatomic, readwrite) SDImageCache *imageCache;
+@property (strong, nonatomic, readwrite) SDWebImageDownloader *imageDownloader;
+@property (strong, nonatomic) NSMutableArray *failedURLs;
+@property (strong, nonatomic) NSMutableArray *runningOperations;
+
+@end
+
+@implementation SDWebImageManager
+
++ (id)sharedManager
+{
+    static dispatch_once_t once;
+    static id instance;
+    dispatch_once(&once, ^{instance = self.new;});
+    return instance;
+}
+
+- (id)init
+{
+    if ((self = [super init]))
+    {
+        _imageCache = [SDImageCache sharedImageCache];
+        _imageDownloader = SDWebImageDownloader.new;
+        _failedURLs = NSMutableArray.new;
+        _runningOperations = NSMutableArray.new;
+    }
+    return self;
+}
+
+
+- (NSString *)cacheKeyForURL:(NSURL *)url
+{
+    if (self.cacheKeyFilter)
+    {
+        return self.cacheKeyFilter(url);
+    }
+    else
+    {
+        return [url absoluteString];
+    }
+}
+
+- (id<SDWebImageOperation>)downloadWithURL:(NSURL *)url options:(SDWebImageOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDWebImageCompletedWithFinishedBlock)completedBlock
+{    
+    // Very common mistake is to send the URL using NSString object instead of NSURL. For some strange reason, XCode won't
+    // throw any warning for this type mismatch. Here we failsafe this error by allowing URLs to be passed as NSString.
+    if ([url isKindOfClass:NSString.class])
+    {
+        url = [NSURL URLWithString:(NSString *)url];
+    }
+
+    // Prevents app crashing on argument type error like sending NSNull instead of NSURL
+    if (![url isKindOfClass:NSURL.class])
+    {
+        url = nil;
+    }
+
+    __block SDWebImageCombinedOperation *operation = SDWebImageCombinedOperation.new;
+    __weak SDWebImageCombinedOperation *weakOperation = operation;
+    
+    if (!url || !completedBlock || (!(options & SDWebImageRetryFailed) && [self.failedURLs containsObject:url]))
+    {
+        if (completedBlock) completedBlock(nil, nil, SDImageCacheTypeNone, NO);
+        return operation;
+    }
+
+    @synchronized(self.runningOperations)
+    {
+        [self.runningOperations addObject:operation];
+    }
+    NSString *key = [self cacheKeyForURL:url];
+
+    [self.imageCache queryDiskCacheForKey:key done:^(UIImage *image, SDImageCacheType cacheType)
+    {
+        if (operation.isCancelled) return;
+
+        if ((!image || options & SDWebImageRefreshCached) && (![self.delegate respondsToSelector:@selector(imageManager:shouldDownloadImageForURL:)] || [self.delegate imageManager:self shouldDownloadImageForURL:url]))
+        {
+            if (image && options & SDWebImageRefreshCached)
+            {
+                // If image was found in the cache bug SDWebImageRefreshCached is provided, notify about the cached image
+                // AND try to re-download it in order to let a chance to NSURLCache to refresh it from server.
+                completedBlock(image, nil, cacheType, YES);
+            }
+
+            // download if no image or requested to refresh anyway, and download allowed by delegate
+            SDWebImageDownloaderOptions downloaderOptions = 0;
+            if (options & SDWebImageLowPriority) downloaderOptions |= SDWebImageDownloaderLowPriority;
+            if (options & SDWebImageProgressiveDownload) downloaderOptions |= SDWebImageDownloaderProgressiveDownload;
+            if (options & SDWebImageRefreshCached) downloaderOptions |= SDWebImageDownloaderUseNSURLCache;
+            if (image && options & SDWebImageRefreshCached)
+            {
+                // force progressive off if image already cached but forced refreshing
+                downloaderOptions &= ~SDWebImageDownloaderProgressiveDownload;
+                // ignore image read from NSURLCache if image if cached but force refreshing
+                downloaderOptions |= SDWebImageDownloaderIgnoreCachedResponse;
+            }
+            __block id<SDWebImageOperation> subOperation = [self.imageDownloader downloadImageWithURL:url options:downloaderOptions progress:progressBlock completed:^(UIImage *downloadedImage, NSData *data, NSError *error, BOOL finished)
+            {
+                if (weakOperation.cancelled)
+                {
+                    completedBlock(nil, nil, SDImageCacheTypeNone, finished);
+                }
+                else if (error)
+                {
+                    completedBlock(nil, error, SDImageCacheTypeNone, finished);
+
+                    if (error.code != NSURLErrorNotConnectedToInternet)
+                    {
+                        @synchronized(self.failedURLs)
+                        {
+                            [self.failedURLs addObject:url];
+                        }
+                    }
+                }
+                else
+                {
+                    BOOL cacheOnDisk = !(options & SDWebImageCacheMemoryOnly);
+
+                    if (options & SDWebImageRefreshCached && image && !downloadedImage)
+                    {
+                        // Image refresh hit the NSURLCache cache, do not call the completion block
+                    }
+                    else if (downloadedImage && [self.delegate respondsToSelector:@selector(imageManager:transformDownloadedImage:withURL:)])
+                    {
+                        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^
+                        {
+                            UIImage *transformedImage = [self.delegate imageManager:self transformDownloadedImage:downloadedImage withURL:url];
+
+                            dispatch_async(dispatch_get_main_queue(), ^
+                            {
+                                completedBlock(transformedImage, nil, SDImageCacheTypeNone, finished);
+                            });
+
+                            if (transformedImage && finished)
+                            {
+                                [self.imageCache storeImage:transformedImage imageData:nil forKey:key toDisk:cacheOnDisk];
+                            }
+                        });
+                    }
+                    else
+                    {
+                        completedBlock(downloadedImage, nil, SDImageCacheTypeNone, finished);
+
+                        if (downloadedImage && finished)
+                        {
+                            [self.imageCache storeImage:downloadedImage imageData:data forKey:key toDisk:cacheOnDisk];
+                        }
+                    }
+                }
+
+                if (finished)
+                {
+                    @synchronized(self.runningOperations)
+                    {
+                        [self.runningOperations removeObject:operation];
+                    }
+                }
+            }];
+            operation.cancelBlock = ^{[subOperation cancel];};
+        }
+        else if (image)
+        {
+            completedBlock(image, nil, cacheType, YES);
+            @synchronized(self.runningOperations)
+            {
+                [self.runningOperations removeObject:operation];
+            }
+        }
+        else
+        {
+            // Image not in cache and download disallowed by delegate
+            completedBlock(nil, nil, SDImageCacheTypeNone, YES);
+            @synchronized(self.runningOperations)
+            {
+                [self.runningOperations removeObject:operation];
+            }
+        }
+    }];
+
+    return operation;
+}
+
+- (void)cancelAll
+{
+    @synchronized(self.runningOperations)
+    {
+        [self.runningOperations makeObjectsPerformSelector:@selector(cancel)];
+        [self.runningOperations removeAllObjects];
+    }
+}
+
+- (BOOL)isRunning
+{
+    return self.runningOperations.count > 0;
+}
+
+@end
+
+@implementation SDWebImageCombinedOperation
+
+- (void)setCancelBlock:(void (^)())cancelBlock
+{
+    if (self.isCancelled)
+    {
+        if (cancelBlock) cancelBlock();
+    }
+    else
+    {
+        _cancelBlock = [cancelBlock copy];
+    }
+}
+
+- (void)cancel
+{
+    self.cancelled = YES;
+    if (self.cancelBlock)
+    {
+        self.cancelBlock();
+        self.cancelBlock = nil;
+    }
+}
+
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/frameworks/SDWebImage/SDWebImageOperation.h

@@ -0,0 +1,15 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import <Foundation/Foundation.h>
+
+@protocol SDWebImageOperation <NSObject>
+
+- (void)cancel;
+
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/frameworks/SDWebImage/SDWebImagePrefetcher.h

@@ -0,0 +1,58 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import <Foundation/Foundation.h>
+#import "SDWebImageManager.h"
+
+/**
+ * Prefetch some URLs in the cache for future use. Images are downloaded in low priority.
+ */
+@interface SDWebImagePrefetcher : NSObject
+
+/**
+ * Maximum number of URLs to prefetch at the same time. Defaults to 3.
+ */
+@property (nonatomic, assign) NSUInteger maxConcurrentDownloads;
+
+/**
+ * SDWebImageOptions for prefetcher. Defaults to SDWebImageLowPriority.
+ */
+@property (nonatomic, assign) SDWebImageOptions options;
+
+
+/**
+ * Return the global image prefetcher instance.
+ */
++ (SDWebImagePrefetcher *)sharedImagePrefetcher;
+
+/**
+ * Assign list of URLs to let SDWebImagePrefetcher to queue the prefetching,
+ * currently one image is downloaded at a time,
+ * and skips images for failed downloads and proceed to the next image in the list
+ *
+ * @param urls list of URLs to prefetch
+ */
+- (void)prefetchURLs:(NSArray *)urls;
+
+/**
+ * Assign list of URLs to let SDWebImagePrefetcher to queue the prefetching,
+ * currently one image is downloaded at a time,
+ * and skips images for failed downloads and proceed to the next image in the list
+ *
+ * @param urls list of URLs to prefetch
+ * @param completionBlock block to be called when prefetching is completed
+ */
+- (void)prefetchURLs:(NSArray *)urls completed:(void (^)(NSUInteger finishedCount, NSUInteger skippedCount))completionBlock;
+
+/**
+ * Remove and cancel queued list
+ */
+- (void)cancelPrefetching;
+
+
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/frameworks/SDWebImage/SDWebImagePrefetcher.m

@@ -0,0 +1,127 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import "SDWebImagePrefetcher.h"
+#import "SDWebImageManager.h"
+
+@interface SDWebImagePrefetcher ()
+
+@property (strong, nonatomic) SDWebImageManager *manager;
+@property (strong, nonatomic) NSArray *prefetchURLs;
+@property (assign, nonatomic) NSUInteger requestedCount;
+@property (assign, nonatomic) NSUInteger skippedCount;
+@property (assign, nonatomic) NSUInteger finishedCount;
+@property (assign, nonatomic) NSTimeInterval startedTime;
+@property (SDDispatchQueueSetterSementics, nonatomic) void (^completionBlock)(NSUInteger, NSUInteger);
+
+@end
+
+@implementation SDWebImagePrefetcher
+
++ (SDWebImagePrefetcher *)sharedImagePrefetcher
+{
+    static dispatch_once_t once;
+    static id instance;
+    dispatch_once(&once, ^{instance = self.new;});
+    return instance;
+}
+
+- (id)init
+{
+    if ((self = [super init]))
+    {
+        _manager = SDWebImageManager.new;
+        _options = SDWebImageLowPriority;
+        self.maxConcurrentDownloads = 3;
+    }
+    return self;
+}
+
+- (void)setMaxConcurrentDownloads:(NSUInteger)maxConcurrentDownloads
+{
+    self.manager.imageDownloader.maxConcurrentDownloads = maxConcurrentDownloads;
+}
+
+- (NSUInteger)maxConcurrentDownloads
+{
+    return self.manager.imageDownloader.maxConcurrentDownloads;
+}
+
+- (void)startPrefetchingAtIndex:(NSUInteger)index
+{
+    if (index >= self.prefetchURLs.count) return;
+    self.requestedCount++;
+    [self.manager downloadWithURL:self.prefetchURLs[index] options:self.options progress:nil completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType, BOOL finished)
+    {
+        if (!finished) return;
+        self.finishedCount++;
+
+        if (image)
+        {
+            NSLog(@"Prefetched %d out of %d", self.finishedCount, self.prefetchURLs.count);
+        }
+        else
+        {
+            NSLog(@"Prefetched %d out of %d (Failed)", self.finishedCount, [self.prefetchURLs count]);
+
+            // Add last failed
+            self.skippedCount++;
+        }
+
+        if (self.prefetchURLs.count > self.requestedCount)
+        {
+            [self startPrefetchingAtIndex:self.requestedCount];
+        }
+        else if (self.finishedCount == self.requestedCount)
+        {
+            [self reportStatus];
+            if (self.completionBlock)
+            {
+                self.completionBlock(self.finishedCount, self.skippedCount);
+                self.completionBlock = nil;
+            }
+        }
+    }];
+}
+
+- (void)reportStatus
+{
+    NSUInteger total = [self.prefetchURLs count];
+    NSLog(@"Finished prefetching (%d successful, %d skipped, timeElasped %.2f)", total - self.skippedCount, self.skippedCount, CFAbsoluteTimeGetCurrent() - self.startedTime);
+}
+
+- (void)prefetchURLs:(NSArray *)urls
+{
+    [self prefetchURLs:urls completed:nil];
+}
+
+- (void)prefetchURLs:(NSArray *)urls completed:(void (^)(NSUInteger, NSUInteger))completionBlock
+{
+    [self cancelPrefetching]; // Prevent duplicate prefetch request
+    self.startedTime = CFAbsoluteTimeGetCurrent();
+    self.prefetchURLs = urls;
+    self.completionBlock = completionBlock;
+
+    // Starts prefetching from the very first image on the list with the max allowed concurrency
+    NSUInteger listCount = self.prefetchURLs.count;
+    for (NSUInteger i = 0; i < self.maxConcurrentDownloads && self.requestedCount < listCount; i++)
+    {
+        [self startPrefetchingAtIndex:i];
+    }
+}
+
+- (void)cancelPrefetching
+{
+    self.prefetchURLs = nil;
+    self.skippedCount = 0;
+    self.requestedCount = 0;
+    self.finishedCount = 0;
+    [self.manager cancelAll];
+}
+
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/frameworks/SDWebImage/UIButton+WebCache.h

@@ -0,0 +1,173 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import "SDWebImageCompat.h"
+#import "SDWebImageManager.h"
+
+/**
+ * Integrates SDWebImage async downloading and caching of remote images with UIButtonView.
+ */
+@interface UIButton (WebCache)
+
+/**
+ * Set the imageView `image` with an `url`.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ */
+- (void)setImageWithURL:(NSURL *)url forState:(UIControlState)state;
+
+/**
+ * Set the imageView `image` with an `url` and a placeholder.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ * @param placeholder The image to be set initially, until the image request finishes.
+ * @see setImageWithURL:placeholderImage:options:
+ */
+- (void)setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder;
+
+/**
+ * Set the imageView `image` with an `url`, placeholder and custom options.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ * @param placeholder The image to be set initially, until the image request finishes.
+ * @param options The options to use when downloading the image. @see SDWebImageOptions for the possible values.
+ */
+- (void)setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options;
+
+/**
+ * Set the imageView `image` with an `url`.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ * @param completedBlock A block called when operation has been completed. This block as no return value
+ *                       and takes the requested UIImage as first parameter. In case of error the image parameter
+ *                       is nil and the second parameter may contain an NSError. The third parameter is a Boolean
+ *                       indicating if the image was retrived from the local cache of from the network.
+ */
+- (void)setImageWithURL:(NSURL *)url forState:(UIControlState)state completed:(SDWebImageCompletedBlock)completedBlock;
+
+/**
+ * Set the imageView `image` with an `url`, placeholder.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ * @param placeholder The image to be set initially, until the image request finishes.
+ * @param completedBlock A block called when operation has been completed. This block as no return value
+ *                       and takes the requested UIImage as first parameter. In case of error the image parameter
+ *                       is nil and the second parameter may contain an NSError. The third parameter is a Boolean
+ *                       indicating if the image was retrived from the local cache of from the network.
+ */
+- (void)setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder completed:(SDWebImageCompletedBlock)completedBlock;
+
+/**
+ * Set the imageView `image` with an `url`, placeholder and custom options.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ * @param placeholder The image to be set initially, until the image request finishes.
+ * @param options The options to use when downloading the image. @see SDWebImageOptions for the possible values.
+ * @param completedBlock A block called when operation has been completed. This block as no return value
+ *                       and takes the requested UIImage as first parameter. In case of error the image parameter
+ *                       is nil and the second parameter may contain an NSError. The third parameter is a Boolean
+ *                       indicating if the image was retrived from the local cache of from the network.
+ */
+- (void)setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDWebImageCompletedBlock)completedBlock;
+
+/**
+ * Set the backgroundImageView `image` with an `url`.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ */
+- (void)setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state;
+
+/**
+ * Set the backgroundImageView `image` with an `url` and a placeholder.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ * @param placeholder The image to be set initially, until the image request finishes.
+ * @see setImageWithURL:placeholderImage:options:
+ */
+- (void)setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder;
+
+/**
+ * Set the backgroundImageView `image` with an `url`, placeholder and custom options.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ * @param placeholder The image to be set initially, until the image request finishes.
+ * @param options The options to use when downloading the image. @see SDWebImageOptions for the possible values.
+ */
+- (void)setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options;
+
+/**
+ * Set the backgroundImageView `image` with an `url`.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ * @param success A block to be executed when the image request succeed This block has no return value and takes the retrieved image as argument.
+ * @param failure A block object to be executed when the image request failed. This block has no return value and takes the error object describing the network or parsing error that occurred (may be nil).
+ */
+- (void)setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state completed:(SDWebImageCompletedBlock)completedBlock;
+
+/**
+ * Set the backgroundImageView `image` with an `url`, placeholder.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param state The state that uses the specified title. The values are described in UIControlState.
+ * @param placeholder The image to be set initially, until the image request finishes.
+ * @param success A block to be executed when the image request succeed This block has no return value and takes the retrieved image as argument.
+ * @param failure A block object to be executed when the image request failed. This block has no return value and takes the error object describing the network or parsing error that occurred (may be nil).
+ */
+- (void)setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder completed:(SDWebImageCompletedBlock)completedBlock;
+
+/**
+ * Set the backgroundImageView `image` with an `url`, placeholder and custom options.
+ *
+ * The downloand is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ * @param placeholder The image to be set initially, until the image request finishes.
+ * @param options The options to use when downloading the image. @see SDWebImageOptions for the possible values.
+ * @param success A block to be executed when the image request succeed This block has no return value and takes the retrieved image as argument.
+ * @param failure A block object to be executed when the image request failed. This block has no return value and takes the error object describing the network or parsing error that occurred (may be nil).
+ */
+- (void)setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDWebImageCompletedBlock)completedBlock;
+
+/**
+ * Cancel the current download
+ */
+- (void)cancelCurrentImageLoad;
+
+@end