appjam 0.1.8.8 → 0.1.8.9

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

@@ -0,0 +1,40 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ * (c) Jamie Pinkham
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import <TargetConditionals.h>
+
+#ifdef __OBJC_GC__
+#error SDWebImage does not support Objective-C Garbage Collection
+#endif
+
+#if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_0
+#error SDWebImage doesn't support Deployement Target version < 5.0
+#endif
+
+#if !TARGET_OS_IPHONE
+#import <AppKit/AppKit.h>
+#ifndef UIImage
+#define UIImage NSImage
+#endif
+#ifndef UIImageView
+#define UIImageView NSImageView
+#endif
+#else
+#import <UIKit/UIKit.h>
+#endif
+
+#if OS_OBJECT_USE_OBJC
+    #define SDDispatchQueueRelease(q)
+    #define SDDispatchQueueSetterSementics strong
+#else
+    #define SDDispatchQueueRelease(q) (dispatch_release(q))
+    #define SDDispatchQueueSetterSementics assign
+#endif
+
+extern inline UIImage *SDScaledImageForPath(NSString *path, NSObject *imageOrData);

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

@@ -0,0 +1,54 @@
+//
+//  SDWebImageCompat.m
+//  SDWebImage
+//
+//  Created by Olivier Poitrey on 11/12/12.
+//  Copyright (c) 2012 Dailymotion. All rights reserved.
+//
+
+#import "SDWebImageCompat.h"
+
+#if !__has_feature(objc_arc)
+#error SDWebImage is ARC only. Either turn on ARC for the project or use -fobjc-arc flag
+#endif
+
+inline UIImage *SDScaledImageForPath(NSString *path, NSObject *imageOrData)
+{
+    if (!imageOrData)
+    {
+        return nil;
+    }
+
+    UIImage *image = nil;
+    if ([imageOrData isKindOfClass:[NSData class]])
+    {
+        image = [[UIImage alloc] initWithData:(NSData *)imageOrData];
+    }
+    else if ([imageOrData isKindOfClass:[UIImage class]])
+    {
+        image = (UIImage *)imageOrData;
+    }
+    else
+    {
+        return nil;
+    }
+
+    if ([[UIScreen mainScreen] respondsToSelector:@selector(scale)])
+    {
+        CGFloat scale = 1.0;
+        if (path.length >= 8)
+        {
+            // Search @2x. at the end of the string, before a 3 to 4 extension length (only if key len is 8 or more @2x. + 4 len ext)
+            NSRange range = [path rangeOfString:@"@2x." options:0 range:NSMakeRange(path.length - 8, 5)];
+            if (range.location != NSNotFound)
+            {
+                scale = 2.0;
+            }
+        }
+
+        UIImage *scaledImage = [[UIImage alloc] initWithCGImage:image.CGImage scale:scale orientation:image.imageOrientation];
+        image = scaledImage;
+    }
+
+    return image;
+}

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

@@ -0,0 +1,18 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * Created by james <https://github.com/mystcolor> on 9/28/11.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import <Foundation/Foundation.h>
+#import "SDWebImageCompat.h"
+
+@interface UIImage (ForceDecode)
+
++ (UIImage *)decodedImageWithImage:(UIImage *)image;
+
+@end

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

@@ -0,0 +1,70 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * Created by james <https://github.com/mystcolor> on 9/28/11.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import "SDWebImageDecoder.h"
+
+@implementation UIImage (ForceDecode)
+
++ (UIImage *)decodedImageWithImage:(UIImage *)image
+{	
+    CGImageRef imageRef = image.CGImage;
+    CGSize imageSize = CGSizeMake(CGImageGetWidth(imageRef), CGImageGetHeight(imageRef));
+    CGRect imageRect = (CGRect){.origin = CGPointZero, .size = imageSize};
+
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+    CGBitmapInfo bitmapInfo = CGImageGetBitmapInfo(imageRef);
+
+    int infoMask = (bitmapInfo & kCGBitmapAlphaInfoMask);
+    BOOL anyNonAlpha = (infoMask == kCGImageAlphaNone ||
+                        infoMask == kCGImageAlphaNoneSkipFirst ||
+                        infoMask == kCGImageAlphaNoneSkipLast);
+
+    // CGBitmapContextCreate doesn't support kCGImageAlphaNone with RGB.
+    // https://developer.apple.com/library/mac/#qa/qa1037/_index.html
+    if (infoMask == kCGImageAlphaNone && CGColorSpaceGetNumberOfComponents(colorSpace) > 1)
+    {
+        // Unset the old alpha info.
+        bitmapInfo &= ~kCGBitmapAlphaInfoMask;
+       
+        // Set noneSkipFirst.
+        bitmapInfo |= kCGImageAlphaNoneSkipFirst;
+    }
+    // Some PNGs tell us they have alpha but only 3 components. Odd.
+    else if (!anyNonAlpha && CGColorSpaceGetNumberOfComponents(colorSpace) == 3)
+    {
+        // Unset the old alpha info.
+        bitmapInfo &= ~kCGBitmapAlphaInfoMask;
+        bitmapInfo |= kCGImageAlphaPremultipliedFirst;
+    }
+
+    // It calculates the bytes-per-row based on the bitsPerComponent and width arguments.
+    CGContextRef context = CGBitmapContextCreate(NULL,
+                                                 imageSize.width,
+                                                 imageSize.height,
+                                                 CGImageGetBitsPerComponent(imageRef),
+                                                 0,
+                                                 colorSpace,
+                                                 bitmapInfo);
+    CGColorSpaceRelease(colorSpace);
+
+    // If failed, return undecompressed image
+    if (!context) return image;
+	
+    CGContextDrawImage(context, imageRect, imageRef);
+    CGImageRef decompressedImageRef = CGBitmapContextCreateImage(context);
+	
+    CGContextRelease(context);
+	
+    UIImage *decompressedImage = [UIImage imageWithCGImage:decompressedImageRef scale:image.scale orientation:image.imageOrientation];
+    CGImageRelease(decompressedImageRef);
+    return decompressedImage;
+}
+
+@end

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

@@ -0,0 +1,102 @@
+/*
+ * 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 "SDWebImageCompat.h"
+#import "SDWebImageOperation.h"
+
+typedef enum
+{
+    SDWebImageDownloaderLowPriority = 1 << 0,
+    SDWebImageDownloaderProgressiveDownload = 1 << 1,
+    /**
+     * By default, request prevent the of NSURLCache. With this flag, NSURLCache
+     * is used with default policies.
+     */
+    SDWebImageDownloaderUseNSURLCache = 1 << 2,
+    /**
+     * Call completion block with nil image/imageData if the image was read from NSURLCache
+     * (to be combined with `SDWebImageDownloaderUseNSURLCache`).
+     */
+    SDWebImageDownloaderIgnoreCachedResponse = 1 << 3
+} SDWebImageDownloaderOptions;
+
+typedef enum
+{
+    SDWebImageDownloaderFIFOExecutionOrder,
+    /**
+     * Default value. All download operations will execute in queue style (first-in-first-out).
+     */
+    SDWebImageDownloaderLIFOExecutionOrder
+    /**
+     * All download operations will execute in stack style (last-in-first-out).
+     */
+} SDWebImageDownloaderExecutionOrder;
+
+extern NSString *const SDWebImageDownloadStartNotification;
+extern NSString *const SDWebImageDownloadStopNotification;
+
+typedef void(^SDWebImageDownloaderProgressBlock)(NSUInteger receivedSize, long long expectedSize);
+typedef void(^SDWebImageDownloaderCompletedBlock)(UIImage *image, NSData *data, NSError *error, BOOL finished);
+
+/**
+ * Asynchronous downloader dedicated and optimized for image loading.
+ */
+@interface SDWebImageDownloader : NSObject
+
+@property (assign, nonatomic) NSInteger maxConcurrentDownloads;
+
+/**
+ * Changes download operations execution order. Default value is `SDWebImageDownloaderFIFOExecutionOrder`.
+ */
+@property (assign, nonatomic) SDWebImageDownloaderExecutionOrder executionOrder;
+
++ (SDWebImageDownloader *)sharedDownloader;
+
+/**
+ * Set a value for a HTTP header to be appended to each download HTTP request.
+ *
+ * @param value The value for the header field. Use `nil` value to remove the header.
+ * @param field The name of the header field to set.
+ */
+- (void)setValue:(NSString *)value forHTTPHeaderField:(NSString *)field;
+
+/**
+ * Returns the value of the specified HTTP header field.
+ *
+ * @return The value associated with the header field field, or `nil` if there is no corresponding header field.
+ */
+- (NSString *)valueForHTTPHeaderField:(NSString *)field;
+
+/**
+ * Creates a SDWebImageDownloader async downloader instance with a given URL
+ *
+ * The delegate will be informed when the image is finish downloaded or an error has happen.
+ *
+ * @see SDWebImageDownloaderDelegate
+ *
+ * @param url The URL to the image to download
+ * @param options The options to be used for this download
+ * @param progress A block called repeatedly while the image is downloading
+ * @param completed A block called once the download is completed.
+ *                  If the download succeeded, the image parameter is set, in case of error,
+ *                  error parameter is set with the error. The last parameter is always YES
+ *                  if SDWebImageDownloaderProgressiveDownload isn't use. With the
+ *                  SDWebImageDownloaderProgressiveDownload option, this block is called
+ *                  repeatedly with the partial image object and the finished argument set to NO
+ *                  before to be called a last time with the full image and finished argument
+ *                  set to YES. In case of error, the finished argument is always YES.
+ *
+ * @return A cancellable SDWebImageOperation
+ */
+- (id<SDWebImageOperation>)downloadImageWithURL:(NSURL *)url
+                                        options:(SDWebImageDownloaderOptions)options
+                                       progress:(SDWebImageDownloaderProgressBlock)progressBlock
+                                      completed:(SDWebImageDownloaderCompletedBlock)completedBlock;
+
+@end

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

@@ -0,0 +1,226 @@
+/*
+ * 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 "SDWebImageDownloader.h"
+#import "SDWebImageDownloaderOperation.h"
+#import <ImageIO/ImageIO.h>
+
+NSString *const SDWebImageDownloadStartNotification = @"SDWebImageDownloadStartNotification";
+NSString *const SDWebImageDownloadStopNotification = @"SDWebImageDownloadStopNotification";
+
+static NSString *const kProgressCallbackKey = @"progress";
+static NSString *const kCompletedCallbackKey = @"completed";
+
+@interface SDWebImageDownloader ()
+
+@property (strong, nonatomic) NSOperationQueue *downloadQueue;
+@property (weak, nonatomic) NSOperation *lastAddedOperation;
+@property (strong, nonatomic) NSMutableDictionary *URLCallbacks;
+@property (strong, nonatomic) NSMutableDictionary *HTTPHeaders;
+// This queue is used to serialize the handling of the network responses of all the download operation in a single queue
+@property (SDDispatchQueueSetterSementics, nonatomic) dispatch_queue_t workingQueue;
+@property (SDDispatchQueueSetterSementics, nonatomic) dispatch_queue_t barrierQueue;
+
+@end
+
+@implementation SDWebImageDownloader
+
++ (void)initialize
+{
+    // Bind SDNetworkActivityIndicator if available (download it here: http://github.com/rs/SDNetworkActivityIndicator )
+    // To use it, just add #import "SDNetworkActivityIndicator.h" in addition to the SDWebImage import
+    if (NSClassFromString(@"SDNetworkActivityIndicator"))
+    {
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+        id activityIndicator = [NSClassFromString(@"SDNetworkActivityIndicator") performSelector:NSSelectorFromString(@"sharedActivityIndicator")];
+#pragma clang diagnostic pop
+
+        // Remove observer in case it was previously added.
+        [[NSNotificationCenter defaultCenter] removeObserver:activityIndicator name:SDWebImageDownloadStartNotification object:nil];
+        [[NSNotificationCenter defaultCenter] removeObserver:activityIndicator name:SDWebImageDownloadStopNotification object:nil];
+
+        [[NSNotificationCenter defaultCenter] addObserver:activityIndicator
+                                                 selector:NSSelectorFromString(@"startActivity")
+                                                     name:SDWebImageDownloadStartNotification object:nil];
+        [[NSNotificationCenter defaultCenter] addObserver:activityIndicator
+                                                 selector:NSSelectorFromString(@"stopActivity")
+                                                     name:SDWebImageDownloadStopNotification object:nil];
+    }
+}
+
++ (SDWebImageDownloader *)sharedDownloader
+{
+    static dispatch_once_t once;
+    static id instance;
+    dispatch_once(&once, ^{instance = self.new;});
+    return instance;
+}
+
+- (id)init
+{
+    if ((self = [super init]))
+    {
+        _executionOrder = SDWebImageDownloaderFIFOExecutionOrder;
+        _downloadQueue = NSOperationQueue.new;
+        _downloadQueue.maxConcurrentOperationCount = 2;
+        _URLCallbacks = NSMutableDictionary.new;
+        _HTTPHeaders = [NSMutableDictionary dictionaryWithObject:@"image/*" forKey:@"Accept"];
+        _workingQueue = dispatch_queue_create("com.hackemist.SDWebImageDownloader", DISPATCH_QUEUE_SERIAL);
+        _barrierQueue = dispatch_queue_create("com.hackemist.SDWebImageDownloaderBarrierQueue", DISPATCH_QUEUE_CONCURRENT);
+    }
+    return self;
+}
+
+- (void)dealloc
+{
+    [self.downloadQueue cancelAllOperations];
+    SDDispatchQueueRelease(_workingQueue);
+    SDDispatchQueueRelease(_barrierQueue);
+}
+
+- (void)setValue:(NSString *)value forHTTPHeaderField:(NSString *)field
+{
+    if (value)
+    {
+        self.HTTPHeaders[field] = value;
+    }
+    else
+    {
+        [self.HTTPHeaders removeObjectForKey:field];
+    }
+}
+
+- (NSString *)valueForHTTPHeaderField:(NSString *)field
+{
+    return self.HTTPHeaders[field];
+}
+
+- (void)setMaxConcurrentDownloads:(NSInteger)maxConcurrentDownloads
+{
+    _downloadQueue.maxConcurrentOperationCount = maxConcurrentDownloads;
+}
+
+- (NSInteger)maxConcurrentDownloads
+{
+    return _downloadQueue.maxConcurrentOperationCount;
+}
+
+- (id<SDWebImageOperation>)downloadImageWithURL:(NSURL *)url options:(SDWebImageDownloaderOptions)options progress:(void (^)(NSUInteger, long long))progressBlock completed:(void (^)(UIImage *, NSData *, NSError *, BOOL))completedBlock
+{
+    __block SDWebImageDownloaderOperation *operation;
+    __weak SDWebImageDownloader *wself = self;
+
+    [self addProgressCallback:progressBlock andCompletedBlock:completedBlock forURL:url createCallback:^
+    {
+        // In order to prevent from potential duplicate caching (NSURLCache + SDImageCache) we disable the cache for image requests if told otherwise
+        NSMutableURLRequest *request = [NSMutableURLRequest.alloc initWithURL:url cachePolicy:(options & SDWebImageDownloaderUseNSURLCache ? NSURLRequestUseProtocolCachePolicy : NSURLRequestReloadIgnoringLocalCacheData) timeoutInterval:15];
+        request.HTTPShouldHandleCookies = NO;
+        request.HTTPShouldUsePipelining = YES;
+        request.allHTTPHeaderFields = wself.HTTPHeaders;
+        operation = [SDWebImageDownloaderOperation.alloc initWithRequest:request queue:wself.workingQueue options:options progress:^(NSUInteger receivedSize, long long expectedSize)
+        {
+            if (!wself) return;
+            SDWebImageDownloader *sself = wself;
+            NSArray *callbacksForURL = [sself callbacksForURL:url];
+            for (NSDictionary *callbacks in callbacksForURL)
+            {
+                SDWebImageDownloaderProgressBlock callback = callbacks[kProgressCallbackKey];
+                if (callback) callback(receivedSize, expectedSize);
+            }
+        }
+        completed:^(UIImage *image, NSData *data, NSError *error, BOOL finished)
+        {
+            if (!wself) return;
+            SDWebImageDownloader *sself = wself;
+            NSArray *callbacksForURL = [sself callbacksForURL:url];
+            if (finished)
+            {
+                [sself removeCallbacksForURL:url];
+            }
+            for (NSDictionary *callbacks in callbacksForURL)
+            {
+                SDWebImageDownloaderCompletedBlock callback = callbacks[kCompletedCallbackKey];
+                if (callback) callback(image, data, error, finished);
+            }
+        }
+        cancelled:^
+        {
+            if (!wself) return;
+            SDWebImageDownloader *sself = wself;
+            [sself callbacksForURL:url];
+            [sself removeCallbacksForURL:url];
+        }];
+        [wself.downloadQueue addOperation:operation];
+        if (wself.executionOrder == SDWebImageDownloaderLIFOExecutionOrder)
+        {
+            // Emulate LIFO execution order by systematically adding new operations as last operation's dependency
+            [wself.lastAddedOperation addDependency:operation];
+            wself.lastAddedOperation = operation;
+        }
+    }];
+
+    return operation;
+}
+
+- (void)addProgressCallback:(void (^)(NSUInteger, long long))progressBlock andCompletedBlock:(void (^)(UIImage *, NSData *data, NSError *, BOOL))completedBlock forURL:(NSURL *)url createCallback:(void (^)())createCallback
+{
+    // The URL will be used as the key to the callbacks dictionary so it cannot be nil. If it is nil immediately call the completed block with no image or data.
+    if(url == nil)
+    {
+        if (completedBlock != nil)
+        {
+            completedBlock(nil, nil, nil, NO);
+        }
+        return;
+    }
+    
+    dispatch_barrier_sync(self.barrierQueue, ^
+    {
+        BOOL first = NO;
+        if (!self.URLCallbacks[url])
+        {
+            self.URLCallbacks[url] = NSMutableArray.new;
+            first = YES;
+        }
+
+        // Handle single download of simultaneous download request for the same URL
+        NSMutableArray *callbacksForURL = self.URLCallbacks[url];
+        NSMutableDictionary *callbacks = NSMutableDictionary.new;
+        if (progressBlock) callbacks[kProgressCallbackKey] = [progressBlock copy];
+        if (completedBlock) callbacks[kCompletedCallbackKey] = [completedBlock copy];
+        [callbacksForURL addObject:callbacks];
+        self.URLCallbacks[url] = callbacksForURL;
+
+        if (first)
+        {
+            createCallback();
+        }
+    });
+}
+
+- (NSArray *)callbacksForURL:(NSURL *)url
+{
+    __block NSArray *callbacksForURL;
+    dispatch_sync(self.barrierQueue, ^
+    {
+        callbacksForURL = self.URLCallbacks[url];
+    });
+    return callbacksForURL;
+}
+
+- (void)removeCallbacksForURL:(NSURL *)url
+{
+    dispatch_barrier_async(self.barrierQueue, ^
+    {
+        [self.URLCallbacks removeObjectForKey:url];
+    });
+}
+
+@end