appjam 0.1.8.8 → 0.1.8.9

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

@@ -0,0 +1,25 @@
+/*
+ * 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 "SDWebImageDownloader.h"
+#import "SDWebImageOperation.h"
+
+@interface SDWebImageDownloaderOperation : NSOperation <SDWebImageOperation>
+
+@property (strong, nonatomic, readonly) NSURLRequest *request;
+@property (assign, nonatomic, readonly) SDWebImageDownloaderOptions options;
+
+- (id)initWithRequest:(NSURLRequest *)request
+                queue:(dispatch_queue_t)queue
+              options:(SDWebImageDownloaderOptions)options
+             progress:(SDWebImageDownloaderProgressBlock)progressBlock
+            completed:(SDWebImageDownloaderCompletedBlock)completedBlock
+            cancelled:(void (^)())cancelBlock;
+
+@end

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

@@ -0,0 +1,339 @@
+/*
+ * 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 "SDWebImageDownloaderOperation.h"
+#import "SDWebImageDecoder.h"
+#import <ImageIO/ImageIO.h>
+
+@interface SDWebImageDownloaderOperation ()
+
+@property (copy, nonatomic) SDWebImageDownloaderProgressBlock progressBlock;
+@property (copy, nonatomic) SDWebImageDownloaderCompletedBlock completedBlock;
+@property (copy, nonatomic) void (^cancelBlock)();
+
+@property (assign, nonatomic, getter = isExecuting) BOOL executing;
+@property (assign, nonatomic, getter = isFinished) BOOL finished;
+@property (assign, nonatomic) long long expectedSize;
+@property (strong, nonatomic) NSMutableData *imageData;
+@property (strong, nonatomic) NSURLConnection *connection;
+@property (SDDispatchQueueSetterSementics, nonatomic) dispatch_queue_t queue;
+
+@end
+
+@implementation SDWebImageDownloaderOperation
+{
+    size_t width, height;
+    BOOL responseFromCached;
+}
+
+- (id)initWithRequest:(NSURLRequest *)request queue:(dispatch_queue_t)queue options:(SDWebImageDownloaderOptions)options progress:(void (^)(NSUInteger, long long))progressBlock completed:(void (^)(UIImage *, NSData *, NSError *, BOOL))completedBlock cancelled:(void (^)())cancelBlock
+{
+    if ((self = [super init]))
+    {
+        _queue = queue;
+        _request = request;
+        _options = options;
+        _progressBlock = [progressBlock copy];
+        _completedBlock = [completedBlock copy];
+        _cancelBlock = [cancelBlock copy];
+        _executing = NO;
+        _finished = NO;
+        _expectedSize = 0;
+        responseFromCached = YES; // Initially wrong until `connection:willCacheResponse:` is called or not called
+    }
+    return self;
+}
+
+- (void)start
+{
+    dispatch_async(dispatch_get_main_queue(), ^
+    {
+        if (self.isCancelled)
+        {
+            self.finished = YES;
+            [self reset];
+            return;
+        }
+
+        self.executing = YES;
+        self.connection = [NSURLConnection.alloc initWithRequest:self.request delegate:self startImmediately:NO];
+
+        // If not in low priority mode, ensure we aren't blocked by UI manipulations (default runloop mode for NSURLConnection is NSEventTrackingRunLoopMode)
+        if (!(self.options & SDWebImageDownloaderLowPriority))
+        {
+            [self.connection scheduleInRunLoop:[NSRunLoop currentRunLoop] forMode:NSRunLoopCommonModes];
+        }
+
+        [self.connection start];
+
+        if (self.connection)
+        {
+            if (self.progressBlock)
+            {
+                self.progressBlock(0, -1);
+            }
+            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStartNotification object:self];
+        }
+        else
+        {
+            if (self.completedBlock)
+            {
+                self.completedBlock(nil, nil, [NSError errorWithDomain:NSURLErrorDomain code:0 userInfo:@{NSLocalizedDescriptionKey: @"Connection can't be initialized"}], YES);
+            }
+        }
+    });
+}
+
+- (void)cancel
+{
+    if (self.isFinished) return;
+    [super cancel];
+    if (self.cancelBlock) self.cancelBlock();
+
+    if (self.connection)
+    {
+        [self.connection cancel];
+        [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:self];
+
+        // As we cancelled the connection, its callback won't be called and thus won't
+        // maintain the isFinished and isExecuting flags.
+        if (self.isExecuting) self.executing = NO;
+        if (!self.isFinished) self.finished = YES;
+    }
+
+    [self reset];
+}
+
+- (void)done
+{
+    self.finished = YES;
+    self.executing = NO;
+    [self reset];
+}
+
+- (void)reset
+{
+    dispatch_async(dispatch_get_main_queue(), ^
+    {
+        self.cancelBlock = nil;
+        self.completedBlock = nil;
+        self.progressBlock = nil;
+        self.connection = nil;
+        self.imageData = nil;
+    });
+}
+
+- (void)setFinished:(BOOL)finished
+{
+    [self willChangeValueForKey:@"isFinished"];
+    _finished = finished;
+    [self didChangeValueForKey:@"isFinished"];
+}
+
+- (void)setExecuting:(BOOL)executing
+{
+    [self willChangeValueForKey:@"isExecuting"];
+    _executing = executing;
+    [self didChangeValueForKey:@"isExecuting"];
+}
+
+- (BOOL)isConcurrent
+{
+    return YES;
+}
+
+#pragma mark NSURLConnection (delegate)
+
+- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response
+{
+    if (![response respondsToSelector:@selector(statusCode)] || [((NSHTTPURLResponse *)response) statusCode] < 400)
+    {
+        NSUInteger expected = response.expectedContentLength > 0 ? (NSUInteger)response.expectedContentLength : 0;
+        self.expectedSize = expected;
+        if (self.progressBlock)
+        {
+            self.progressBlock(0, expected);
+        }
+
+        dispatch_async(self.queue, ^
+        {
+            self.imageData = [NSMutableData.alloc initWithCapacity:expected];
+        });
+    }
+    else
+    {
+        [self.connection cancel];
+
+        [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:nil];
+
+        if (self.completedBlock)
+        {
+            self.completedBlock(nil, nil, [NSError errorWithDomain:NSURLErrorDomain code:[((NSHTTPURLResponse *)response) statusCode] userInfo:nil], YES);
+        }
+
+        [self done];
+    }
+}
+
+- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data
+{
+    dispatch_async(self.queue, ^
+    {
+        [self.imageData appendData:data];
+
+        if ((self.options & SDWebImageDownloaderProgressiveDownload) && self.expectedSize > 0 && self.completedBlock)
+        {
+            // The following code is from http://www.cocoaintheshell.com/2011/05/progressive-images-download-imageio/
+            // Thanks to the author @Nyx0uf
+
+            // Get the total bytes downloaded
+            const NSUInteger totalSize = self.imageData.length;
+
+            // Update the data source, we must pass ALL the data, not just the new bytes
+            CGImageSourceRef imageSource = CGImageSourceCreateIncremental(NULL);
+            CGImageSourceUpdateData(imageSource, (__bridge  CFDataRef)self.imageData, totalSize == self.expectedSize);
+
+            if (width + height == 0)
+            {
+                CFDictionaryRef properties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, NULL);
+                if (properties)
+                {
+                    CFTypeRef val = CFDictionaryGetValue(properties, kCGImagePropertyPixelHeight);
+                    if (val) CFNumberGetValue(val, kCFNumberLongType, &height);
+                    val = CFDictionaryGetValue(properties, kCGImagePropertyPixelWidth);
+                    if (val) CFNumberGetValue(val, kCFNumberLongType, &width);
+                    CFRelease(properties);
+                }
+            }
+
+            if (width + height > 0 && totalSize < self.expectedSize)
+            {
+                // Create the image
+                CGImageRef partialImageRef = CGImageSourceCreateImageAtIndex(imageSource, 0, NULL);
+
+#ifdef TARGET_OS_IPHONE
+                // Workaround for iOS anamorphic image
+                if (partialImageRef)
+                {
+                    const size_t partialHeight = CGImageGetHeight(partialImageRef);
+                    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+                    CGContextRef bmContext = CGBitmapContextCreate(NULL, width, height, 8, width * 4, colorSpace, kCGBitmapByteOrderDefault | kCGImageAlphaPremultipliedFirst);
+                    CGColorSpaceRelease(colorSpace);
+                    if (bmContext)
+                    {
+                        CGContextDrawImage(bmContext, (CGRect){.origin.x = 0.0f, .origin.y = 0.0f, .size.width = width, .size.height = partialHeight}, partialImageRef);
+                        CGImageRelease(partialImageRef);
+                        partialImageRef = CGBitmapContextCreateImage(bmContext);
+                        CGContextRelease(bmContext);
+                    }
+                    else
+                    {
+                        CGImageRelease(partialImageRef);
+                        partialImageRef = nil;
+                    }
+                }
+#endif
+
+                if (partialImageRef)
+                {
+                    UIImage *image = [UIImage decodedImageWithImage:SDScaledImageForPath(self.request.URL.absoluteString, [UIImage imageWithCGImage:partialImageRef])];
+                    CGImageRelease(partialImageRef);
+                    dispatch_async(dispatch_get_main_queue(), ^
+                    {
+                        if (self.completedBlock)
+                        {
+                            self.completedBlock(image, nil, nil, NO);
+                        }
+                    });
+                }
+            }
+
+            CFRelease(imageSource);
+        }
+        NSUInteger received = self.imageData.length;
+        dispatch_async(dispatch_get_main_queue(), ^
+        {
+            if (self.progressBlock)
+            {
+                self.progressBlock(received, self.expectedSize);
+            }
+        });
+    });
+}
+
+- (void)connectionDidFinishLoading:(NSURLConnection *)aConnection
+{
+    self.connection = nil;
+
+    [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:nil];
+
+    SDWebImageDownloaderCompletedBlock completionBlock = self.completedBlock;
+
+    if (completionBlock)
+    {
+        if (self.options & SDWebImageDownloaderIgnoreCachedResponse && responseFromCached)
+        {
+            completionBlock(nil, nil, nil, YES);
+            self.completionBlock = nil;
+            [self done];
+        }
+        else
+        {
+            dispatch_async(self.queue, ^
+            {
+                UIImage *image = [UIImage decodedImageWithImage:SDScaledImageForPath(self.request.URL.absoluteString, self.imageData)];
+                dispatch_async(dispatch_get_main_queue(), ^
+                {
+                    if (CGSizeEqualToSize(image.size, CGSizeZero))
+                    {
+                        completionBlock(nil, nil, [NSError errorWithDomain:@"SDWebImageErrorDomain" code:0 userInfo:@{NSLocalizedDescriptionKey: @"Downloaded image has 0 pixels"}], YES);
+                    }
+                    else
+                    {
+                        completionBlock(image, self.imageData, nil, YES);
+                    }
+                    self.completionBlock = nil;
+                    [self done];
+                });
+            });
+        }
+    }
+    else
+    {
+        [self done];
+    }
+}
+
+- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error
+{
+    [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:nil];
+
+    if (self.completedBlock)
+    {
+        self.completedBlock(nil, nil, error, YES);
+    }
+
+    [self done];
+}
+
+- (NSCachedURLResponse *)connection:(NSURLConnection *)connection willCacheResponse:(NSCachedURLResponse *)cachedResponse
+{
+    responseFromCached = NO; // If this method is called, it means the response wasn't read from cache
+    if (self.request.cachePolicy == NSURLRequestReloadIgnoringLocalCacheData)
+    {
+        // Prevents caching of responses
+        return nil;
+    }
+    else
+    {
+        return cachedResponse;
+    }
+}
+
+
+@end

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

@@ -0,0 +1,167 @@
+/*
+ * 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 "SDWebImageOperation.h"
+#import "SDWebImageDownloader.h"
+#import "SDImageCache.h"
+
+typedef enum
+{
+    /**
+     * By default, when a URL fail to be downloaded, the URL is blacklisted so the library won't keep trying.
+     * This flag disable this blacklisting.
+     */
+    SDWebImageRetryFailed = 1 << 0,
+    /**
+     * By default, image downloads are started during UI interactions, this flags disable this feature,
+     * leading to delayed download on UIScrollView deceleration for instance.
+     */
+    SDWebImageLowPriority = 1 << 1,
+    /**
+     * This flag disables on-disk caching
+     */
+    SDWebImageCacheMemoryOnly = 1 << 2,
+    /**
+     * This flag enables progressive download, the image is displayed progressively during download as a browser would do.
+     * By default, the image is only displayed once completely downloaded.
+     */
+    SDWebImageProgressiveDownload = 1 << 3,
+    /**
+     * Even if the image is cached, respect the HTTP response cache control, and refresh the image from remote location if needed.
+     * The disk caching will be handled by NSURLCache instead of SDWebImage leading to slight performance degradation.
+     * This option helps deal with images changing behind the same request URL, e.g. Facebook graph api profile pics.
+     * If a cached image is refreshed, the completion block is called once with the cached image and again with the final image.
+     *
+     * Use this flag only if you can't make your URLs static with embeded cache busting parameter.
+     */
+    SDWebImageRefreshCached = 1 << 4
+} SDWebImageOptions;
+
+typedef void(^SDWebImageCompletedBlock)(UIImage *image, NSError *error, SDImageCacheType cacheType);
+typedef void(^SDWebImageCompletedWithFinishedBlock)(UIImage *image, NSError *error, SDImageCacheType cacheType, BOOL finished);
+
+
+@class SDWebImageManager;
+
+@protocol SDWebImageManagerDelegate <NSObject>
+
+@optional
+
+/**
+ * Controls which image should be downloaded when the image is not found in the cache.
+ *
+ * @param imageManager The current `SDWebImageManager`
+ * @param imageURL The url of the image to be downloaded
+ *
+ * @return Return NO to prevent the downloading of the image on cache misses. If not implemented, YES is implied.
+ */
+- (BOOL)imageManager:(SDWebImageManager *)imageManager shouldDownloadImageForURL:(NSURL *)imageURL;
+
+/**
+ * Allows to transform the image immediately after it has been downloaded and just before to cache it on disk and memory.
+ * NOTE: This method is called from a global queue in order to not to block the main thread.
+ *
+ * @param imageManager The current `SDWebImageManager`
+ * @param image The image to transform
+ * @param imageURL The url of the image to transform
+ *
+ * @return The transformed image object.
+ */
+- (UIImage *)imageManager:(SDWebImageManager *)imageManager transformDownloadedImage:(UIImage *)image withURL:(NSURL *)imageURL;
+
+@end
+
+/**
+ * The SDWebImageManager is the class behind the UIImageView+WebCache category and likes.
+ * It ties the asynchronous downloader (SDWebImageDownloader) with the image cache store (SDImageCache).
+ * You can use this class directly to benefit from web image downloading with caching in another context than
+ * a UIView.
+ *
+ * Here is a simple example of how to use SDWebImageManager:
+ *
+ *  SDWebImageManager *manager = [SDWebImageManager sharedManager];
+ *  [manager downloadWithURL:imageURL
+ *                  delegate:self
+ *                   options:0
+ *                  progress:nil
+ *                 completed:^(UIImage *image, NSError *error, BOOL fromCache)
+ *                 {
+ *                     if (image)
+ *                     {
+ *                         // do something with image
+ *                     }
+ *                 }];
+ */
+@interface SDWebImageManager : NSObject
+
+@property (weak, nonatomic) id<SDWebImageManagerDelegate> delegate;
+
+@property (strong, nonatomic, readonly) SDImageCache *imageCache;
+@property (strong, nonatomic, readonly) SDWebImageDownloader *imageDownloader;
+
+/**
+ * The cache filter is a block used each time SDWebImageManager need to convert an URL into a cache key. This can
+ * be used to remove dynamic part of an image URL.
+ *
+ * The following example sets a filter in the application delegate that will remove any query-string from the
+ * URL before to use it as a cache key:
+ *
+ * 	[[SDWebImageManager sharedManager] setCacheKeyFilter:^(NSURL *url)
+ *	{
+ *	    url = [[NSURL alloc] initWithScheme:url.scheme host:url.host path:url.path];
+ *	    return [url absoluteString];
+ *	}];
+ */
+@property (strong) NSString *(^cacheKeyFilter)(NSURL *url);
+
+/**
+ * Returns global SDWebImageManager instance.
+ *
+ * @return SDWebImageManager shared instance
+ */
++ (SDWebImageManager *)sharedManager;
+
+/**
+ * Downloads the image at the given URL if not present in cache or return the cached version otherwise.
+ *
+ * @param url The URL to the image
+ * @param delegate The delegate object used to send result back
+ * @param options A mask to specify options to use for this request
+ * @param progressBlock A block called while image is downloading
+ * @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.
+ *
+ *                       The last parameter is set to NO when the SDWebImageProgressiveDownload option is used and
+ *                       the image is downloading. This block is thus called repetidly with a partial image. When
+ *                       image is fully downloaded, the block is called a last time with the full image and the last
+ *                       parameter set to YES.
+ *
+ * @return Returns a cancellable NSOperation
+ */
+- (id<SDWebImageOperation>)downloadWithURL:(NSURL *)url
+                                   options:(SDWebImageOptions)options
+                                  progress:(SDWebImageDownloaderProgressBlock)progressBlock
+                                 completed:(SDWebImageCompletedWithFinishedBlock)completedBlock;
+
+/**
+ * Cancel all current opreations
+ */
+- (void)cancelAll;
+
+/**
+ * Check one or more operations running
+ */
+- (BOOL)isRunning;
+
+@end