appjam 0.1.8.8 → 0.1.8.9

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/frameworks/SDWebImage/MKAnnotationView+WebCache.m

@@ -0,0 +1,78 @@
+//
+//  MKAnnotationView+WebCache.m
+//  SDWebImage
+//
+//  Created by Olivier Poitrey on 14/03/12.
+//  Copyright (c) 2012 Dailymotion. All rights reserved.
+//
+
+#import "MKAnnotationView+WebCache.h"
+#import "objc/runtime.h"
+
+static char operationKey;
+
+@implementation MKAnnotationView (WebCache)
+
+- (void)setImageWithURL:(NSURL *)url
+{
+    [self setImageWithURL:url placeholderImage:nil options:0 completed:nil];
+}
+
+- (void)setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder
+{
+    [self setImageWithURL:url placeholderImage:placeholder options:0 completed:nil];
+}
+
+- (void)setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options
+{
+    [self setImageWithURL:url placeholderImage:placeholder options:options completed:nil];
+}
+
+- (void)setImageWithURL:(NSURL *)url completed:(SDWebImageCompletedBlock)completedBlock
+{
+    [self setImageWithURL:url placeholderImage:nil options:0 completed:completedBlock];
+}
+
+- (void)setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder completed:(SDWebImageCompletedBlock)completedBlock
+{
+    [self setImageWithURL:url placeholderImage:placeholder options:0 completed:completedBlock];
+}
+
+- (void)setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDWebImageCompletedBlock)completedBlock
+{
+    [self cancelCurrentImageLoad];
+
+    self.image = placeholder;
+    
+    if (url)
+    {
+        __weak MKAnnotationView *wself = self;
+        id<SDWebImageOperation> operation = [SDWebImageManager.sharedManager downloadWithURL:url options:options progress:nil completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType, BOOL finished)
+        {
+            __strong MKAnnotationView *sself = wself;
+            if (!sself) return;
+            if (image)
+            {
+                sself.image = image;
+            }
+            if (completedBlock && finished)
+            {
+                completedBlock(image, error, cacheType);
+            }
+        }];
+        objc_setAssociatedObject(self, &operationKey, operation, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    }
+}
+
+- (void)cancelCurrentImageLoad
+{
+    // Cancel in progress downloader from queue
+    id<SDWebImageOperation> operation = objc_getAssociatedObject(self, &operationKey);
+    if (operation)
+    {
+        [operation cancel];
+        objc_setAssociatedObject(self, &operationKey, nil, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
+    }
+}
+
+@end

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

@@ -0,0 +1,144 @@
+/*
+ * 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"
+
+enum SDImageCacheType
+{
+    /**
+     * The image wasn't available the SDWebImage caches, but was downloaded from the web.
+     */
+    SDImageCacheTypeNone = 0,
+    /**
+     * The image was obtained from the disk cache.
+     */
+    SDImageCacheTypeDisk,
+    /**
+     * The image was obtained from the memory cache.
+     */
+    SDImageCacheTypeMemory
+};
+typedef enum SDImageCacheType SDImageCacheType;
+
+/**
+ * SDImageCache maintains a memory cache and an optional disk cache. Disk cache write operations are performed
+ * asynchronous so it doesn’t add unnecessary latency to the UI.
+ */
+@interface SDImageCache : NSObject
+
+/**
+ * The maximum length of time to keep an image in the cache, in seconds
+ */
+@property (assign, nonatomic) NSInteger maxCacheAge;
+
+/**
+ * Returns global shared cache instance
+ *
+ * @return SDImageCache global instance
+ */
++ (SDImageCache *)sharedImageCache;
+
+/**
+ * Init a new cache store with a specific namespace
+ *
+ * @param ns The namespace to use for this cache store
+ */
+- (id)initWithNamespace:(NSString *)ns;
+
+/**
+ * Store an image into memory and disk cache at the given key.
+ *
+ * @param image The image to store
+ * @param key The unique image cache key, usually it's image absolute URL
+ */
+- (void)storeImage:(UIImage *)image forKey:(NSString *)key;
+
+/**
+ * Store an image into memory and optionally disk cache at the given key.
+ *
+ * @param image The image to store
+ * @param key The unique image cache key, usually it's image absolute URL
+ * @param toDisk Store the image to disk cache if YES
+ */
+- (void)storeImage:(UIImage *)image forKey:(NSString *)key toDisk:(BOOL)toDisk;
+
+/**
+ * Store an image into memory and optionally disk cache at the given key.
+ *
+ * @param image The image to store
+ * @param data The image data as returned by the server, this representation will be used for disk storage
+ *             instead of converting the given image object into a storable/compressed image format in order
+ *             to save quality and CPU
+ * @param key The unique image cache key, usually it's image absolute URL
+ * @param toDisk Store the image to disk cache if YES
+ */
+- (void)storeImage:(UIImage *)image imageData:(NSData *)data forKey:(NSString *)key toDisk:(BOOL)toDisk;
+
+/**
+ * Query the disk cache asynchronously.
+ *
+ * @param key The unique key used to store the wanted image
+ */
+- (void)queryDiskCacheForKey:(NSString *)key done:(void (^)(UIImage *image, SDImageCacheType cacheType))doneBlock;
+
+/**
+ * Query the memory cache synchronously.
+ *
+ * @param key The unique key used to store the wanted image
+ */
+- (UIImage *)imageFromMemoryCacheForKey:(NSString *)key;
+
+/**
+ * Query the disk cache synchronously after checking the memory cache.
+ *
+ * @param key The unique key used to store the wanted image
+ */
+- (UIImage *)imageFromDiskCacheForKey:(NSString *)key;
+
+/**
+ * Remove the image from memory and disk cache synchronously
+ *
+ * @param key The unique image cache key
+ */
+- (void)removeImageForKey:(NSString *)key;
+
+/**
+ * Remove the image from memory and optionaly disk cache synchronously
+ *
+ * @param key The unique image cache key
+ * @param fromDisk Also remove cache entry from disk if YES
+ */
+- (void)removeImageForKey:(NSString *)key fromDisk:(BOOL)fromDisk;
+
+/**
+ * Clear all memory cached images
+ */
+- (void)clearMemory;
+
+/**
+ * Clear all disk cached images
+ */
+- (void)clearDisk;
+
+/**
+ * Remove all expired cached image from disk
+ */
+- (void)cleanDisk;
+
+/**
+ * Get the size used by the disk cache
+ */
+- (unsigned long long)getSize;
+
+/**
+ * Get the number of images in the disk cache
+ */
+- (int)getDiskCount;
+
+@end

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

@@ -0,0 +1,311 @@
+/*
+ * 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 "SDImageCache.h"
+#import "SDWebImageDecoder.h"
+#import <CommonCrypto/CommonDigest.h>
+#import <mach/mach.h>
+#import <mach/mach_host.h>
+
+static const NSInteger kDefaultCacheMaxCacheAge = 60 * 60 * 24 * 7; // 1 week
+
+@interface SDImageCache ()
+
+@property (strong, nonatomic) NSCache *memCache;
+@property (strong, nonatomic) NSString *diskCachePath;
+@property (SDDispatchQueueSetterSementics, nonatomic) dispatch_queue_t ioQueue;
+
+@end
+
+
+@implementation SDImageCache
+
++ (SDImageCache *)sharedImageCache
+{
+    static dispatch_once_t once;
+    static id instance;
+    dispatch_once(&once, ^{instance = self.new;});
+    return instance;
+}
+
+- (id)init
+{
+    return [self initWithNamespace:@"default"];
+}
+
+- (id)initWithNamespace:(NSString *)ns
+{
+    if ((self = [super init]))
+    {
+        NSString *fullNamespace = [@"com.hackemist.SDWebImageCache." stringByAppendingString:ns];
+
+        // Create IO serial queue
+        _ioQueue = dispatch_queue_create("com.hackemist.SDWebImageCache", DISPATCH_QUEUE_SERIAL);
+
+        // Init default values
+        _maxCacheAge = kDefaultCacheMaxCacheAge;
+
+        // Init the memory cache
+        _memCache = [[NSCache alloc] init];
+        _memCache.name = fullNamespace;
+
+        // Init the disk cache
+        NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
+        _diskCachePath = [paths[0] stringByAppendingPathComponent:fullNamespace];
+
+#if TARGET_OS_IPHONE
+        // Subscribe to app events
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(clearMemory)
+                                                     name:UIApplicationDidReceiveMemoryWarningNotification
+                                                   object:nil];
+
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(cleanDisk)
+                                                     name:UIApplicationWillTerminateNotification
+                                                   object:nil];
+#endif
+    }
+
+    return self;
+}
+
+- (void)dealloc
+{
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    SDDispatchQueueRelease(_ioQueue);
+}
+
+#pragma mark SDImageCache (private)
+
+- (NSString *)cachePathForKey:(NSString *)key
+{
+    const char *str = [key UTF8String];
+    unsigned char r[CC_MD5_DIGEST_LENGTH];
+    CC_MD5(str, (CC_LONG)strlen(str), r);
+    NSString *filename = [NSString stringWithFormat:@"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
+                          r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8], r[9], r[10], r[11], r[12], r[13], r[14], r[15]];
+
+    return [self.diskCachePath stringByAppendingPathComponent:filename];
+}
+
+#pragma mark ImageCache
+
+- (void)storeImage:(UIImage *)image imageData:(NSData *)imageData forKey:(NSString *)key toDisk:(BOOL)toDisk
+{
+    if (!image || !key)
+    {
+        return;
+    }
+
+    [self.memCache setObject:image forKey:key cost:image.size.height * image.size.width * image.scale];
+
+    if (toDisk)
+    {
+        dispatch_async(self.ioQueue, ^
+        {
+            NSData *data = imageData;
+
+            if (!data)
+            {
+                if (image)
+                {
+#if TARGET_OS_IPHONE
+                    data = UIImageJPEGRepresentation(image, (CGFloat)1.0);
+#else
+                    data = [NSBitmapImageRep representationOfImageRepsInArray:image.representations usingType: NSJPEGFileType properties:nil];
+#endif
+                }
+            }
+
+            if (data)
+            {
+                // Can't use defaultManager another thread
+                NSFileManager *fileManager = NSFileManager.new;
+
+                if (![fileManager fileExistsAtPath:_diskCachePath])
+                {
+                    [fileManager createDirectoryAtPath:_diskCachePath withIntermediateDirectories:YES attributes:nil error:NULL];
+                }
+
+                [fileManager createFileAtPath:[self cachePathForKey:key] contents:data attributes:nil];
+            }
+        });
+    }
+}
+
+- (void)storeImage:(UIImage *)image forKey:(NSString *)key
+{
+    [self storeImage:image imageData:nil forKey:key toDisk:YES];
+}
+
+- (void)storeImage:(UIImage *)image forKey:(NSString *)key toDisk:(BOOL)toDisk
+{
+    [self storeImage:image imageData:nil forKey:key toDisk:toDisk];
+}
+
+- (UIImage *)imageFromMemoryCacheForKey:(NSString *)key
+{
+    return [self.memCache objectForKey:key];
+}
+
+- (UIImage *)imageFromDiskCacheForKey:(NSString *)key
+{
+    // First check the in-memory cache...
+    UIImage *image = [self imageFromMemoryCacheForKey:key];
+    if (image)
+    {
+        return image;
+    }
+    
+    // Second check the disk cache...
+    UIImage *diskImage = [UIImage decodedImageWithImage:SDScaledImageForPath(key, [NSData dataWithContentsOfFile:[self cachePathForKey:key]])];
+    
+    if (diskImage)
+    {
+        CGFloat cost = diskImage.size.height * diskImage.size.width * diskImage.scale;
+        [self.memCache setObject:diskImage forKey:key cost:cost];
+    }
+    
+    return diskImage;
+}
+
+- (void)queryDiskCacheForKey:(NSString *)key done:(void (^)(UIImage *image, SDImageCacheType cacheType))doneBlock
+{
+    if (!doneBlock) return;
+
+    if (!key)
+    {
+        doneBlock(nil, SDImageCacheTypeNone);
+        return;
+    }
+
+    // First check the in-memory cache...
+    UIImage *image = [self imageFromMemoryCacheForKey:key];
+    if (image)
+    {
+        doneBlock(image, SDImageCacheTypeMemory);
+        return;
+    }
+
+    dispatch_async(self.ioQueue, ^
+    {
+        UIImage *diskImage = [UIImage decodedImageWithImage:SDScaledImageForPath(key, [NSData dataWithContentsOfFile:[self cachePathForKey:key]])];
+
+        if (diskImage)
+        {
+            CGFloat cost = diskImage.size.height * diskImage.size.width * diskImage.scale;
+            [self.memCache setObject:diskImage forKey:key cost:cost];
+        }
+
+        dispatch_async(dispatch_get_main_queue(), ^
+        {
+            doneBlock(diskImage, SDImageCacheTypeDisk);
+        });
+    });
+}
+
+- (void)removeImageForKey:(NSString *)key
+{
+    [self removeImageForKey:key fromDisk:YES];
+}
+
+- (void)removeImageForKey:(NSString *)key fromDisk:(BOOL)fromDisk
+{
+    if (key == nil)
+    {
+        return;
+    }
+
+    [self.memCache removeObjectForKey:key];
+
+    if (fromDisk)
+    {
+        dispatch_async(self.ioQueue, ^
+        {
+            [[NSFileManager defaultManager] removeItemAtPath:[self cachePathForKey:key] error:nil];
+        });
+    }
+}
+
+- (void)clearMemory
+{
+    [self.memCache removeAllObjects];
+}
+
+- (void)clearDisk
+{
+    dispatch_async(self.ioQueue, ^
+    {
+        [[NSFileManager defaultManager] removeItemAtPath:self.diskCachePath error:nil];
+        [[NSFileManager defaultManager] createDirectoryAtPath:self.diskCachePath
+                                  withIntermediateDirectories:YES
+                                                   attributes:nil
+                                                        error:NULL];
+    });
+}
+
+- (void)cleanDisk
+{
+    dispatch_async(self.ioQueue, ^
+    {
+        NSDate *expirationDate = [NSDate dateWithTimeIntervalSinceNow:-self.maxCacheAge];
+        // convert NSString path to NSURL path
+        NSURL *diskCacheURL = [NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];
+        // build an enumerator by also prefetching file properties we want to read
+        NSDirectoryEnumerator *fileEnumerator = [[NSFileManager defaultManager] enumeratorAtURL:diskCacheURL
+                                                                     includingPropertiesForKeys:@[ NSURLIsDirectoryKey, NSURLContentModificationDateKey ]
+                                                                                        options:NSDirectoryEnumerationSkipsHiddenFiles
+                                                                                   errorHandler:NULL];
+        for (NSURL *fileURL in fileEnumerator)
+        {
+            // skip folder
+            NSNumber *isDirectory;
+            [fileURL getResourceValue:&isDirectory forKey:NSURLIsDirectoryKey error:NULL];
+            if ([isDirectory boolValue])
+            {
+                continue;
+            }
+            
+            // compare file date with the max age
+            NSDate *fileModificationDate;
+            [fileURL getResourceValue:&fileModificationDate forKey:NSURLContentModificationDateKey error:NULL];
+            if ([[fileModificationDate laterDate:expirationDate] isEqualToDate:expirationDate])
+            {
+                [[NSFileManager defaultManager] removeItemAtURL:fileURL error:nil];
+            }
+        }
+    });
+}
+
+-(unsigned long long)getSize
+{
+    unsigned long long size = 0;
+    NSDirectoryEnumerator *fileEnumerator = [[NSFileManager defaultManager] enumeratorAtPath:self.diskCachePath];
+    for (NSString *fileName in fileEnumerator)
+    {
+        NSString *filePath = [self.diskCachePath stringByAppendingPathComponent:fileName];
+        NSDictionary *attrs = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
+        size += [attrs fileSize];
+    }
+    return size;
+}
+
+- (int)getDiskCount
+{
+    int count = 0;
+    NSDirectoryEnumerator *fileEnumerator = [[NSFileManager defaultManager] enumeratorAtPath:self.diskCachePath];
+    for (NSString *fileName in fileEnumerator)
+    {
+        count += 1;
+    }
+    
+    return count;
+}
+
+@end