//

// JSONCache.m

//

// @version 0.9.0

// @author Marin Todorov, http://www.touch-code-magazine.com

//

// Copyright (c) 2012 Marin Todorov, Underplot ltd.

// This code is distributed under the terms and conditions of the MIT license.

//

// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//

// The MIT License in plain English: http://www.touch-code-magazine.com/JSONModel/MITLicense

#import "JSONCache.h"

#import <CommonCrypto/CommonDigest.h>

#import <SystemConfiguration/SystemConfiguration.h>

#import <netinet/in.h>

#import <netinet6/in6.h>

#pragma mark - constants

float kNeverRevalidate = FLT_MAX;

float kAlwaysRevalidate = 0.0f;

float kNeverExpire = FLT_MAX;

float kImmediatelyExpire = 0.0f;

#define kJSONCacheDirectory @"JSONCache"

#define kDefaultExpirationTimeInHours 1 //1 hour

#define kDefaultExpirationTimeInHoursWhenOffline 168 //1 week

#define kIfModifiedSinceHTTPHeaderName @"If-Modified-Since"

#define kETagHTTPHeaderName @"ETag"

#define kIfModifiedSinceHTTPHeaderNameXd @"X-If-Modified-Since"

#define kETagHTTPHeaderNameXd @"X-ETag"

BOOL JCFEqual(f1, f2) { return (fabs((f1) - (f2)) < FLT_EPSILON); }

static JSONCache* instance = nil;

#pragma mark - cache implementation

@implementation JSONCache

{

NSString* cacheDirectory;

NSFileManager* fm;

NSMutableDictionary* cacheFiles;

NSTimeInterval _expirationOnlineTimeInterval;

NSTimeInterval _expirationOfflineTimeInterval;

NSTimeInterval _revalidateFromServerTimeInterval;

NSTimeInterval _revalidateFromServerWithETagTimeInterval;

SCNetworkReachabilityRef reachabilityRef;

BOOL observingConnection;

}

#pragma mark - initializers

-(instancetype)init

{

NSAssert(NO, @"use [JSONCache sharedCache] instead");

return nil;

}

-(id)_initPrivate

{

self = [super init];

if (self!=nil) {

//do initial configuration

self.expirationTimeInHours = kDefaultExpirationTimeInHours;

self.expirationTimeInHoursWhenOffline = kDefaultExpirationTimeInHoursWhenOffline;

self.revalidateCacheFromServerAfterTimeInHours = kNeverRevalidate;

self.revalidateCacheViaETagAfterTimeInHours = kNeverRevalidate;

self.isUsingXdHTTPHeaderNames = YES;

_isOnline = YES;

cacheFiles = [[NSMutableDictionary alloc] initWithCapacity: 5];

}

return self;

}

+(instancetype)sharedCache

{

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

instance = [[[self class] alloc] _initPrivate];

});

return instance;

}

#pragma mark - load cached objects

-(void)loadCacheFromDisc

{

//setup the directories

NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory , NSUserDomainMask, YES);

cacheDirectory = [[paths objectAtIndex:0] stringByAppendingPathComponent:kJSONCacheDirectory];

fm = [[NSFileManager alloc] init];

//create the cache directory

if (![fm fileExistsAtPath:cacheDirectory]) {

//empty cache

[fm createDirectoryAtPath:cacheDirectory withIntermediateDirectories:YES attributes:nil error:nil];

cacheFiles = [[NSMutableDictionary alloc] initWithCapacity:10];

} else {

//read the current cache folder

NSArray *directoryContents = [fm contentsOfDirectoryAtPath:cacheDirectory error:nil];

//read the current cache contents

for (NSString* fileName in directoryContents) {

NSLog(@"load cache file: %@", fileName);

NSString* fullFilePath = [cacheDirectory stringByAppendingPathComponent: fileName];

NSDate* modifiedDate = [[fm attributesOfItemAtPath:fullFilePath error:NULL] fileModificationDate];

JSONCacheFile* file = [[JSONCacheFile alloc] init];

file.modificationTime= [modifiedDate timeIntervalSinceReferenceDate];

file.fileName = fileName;

[cacheFiles setValue:file forKey:file.key];

}

//trim the cache

[self trimExpiredObjects];

}

if (cacheFiles.count>0 && observingConnection==NO) {

//observe connectivity changes

[self startConnectivityObserver];

NSLog(@"JSONCache.isOnline = %@", _isOnline?@"YES":@"NO" );

}

}

#pragma mark - manage cache objects

-(BOOL)addObject:(id)object forMethod:(NSString*)method andParams:(id)params

{

return [self addObject:object forMethod:method andParams:params etag:nil];

}

-(BOOL)addObject:(id)object forMethod:(NSString*)method andParams:(id)params etag:(NSString*)etag

{

//expire objects

[self trimExpiredObjects];

//add new objects

NSString* key = [self keyForMethod:method andParams:params];

//remove previous versions of the object

if (cacheFiles[key]) [self trimObjectForKey:key];

//store the file

NSData * data = [NSKeyedArchiver archivedDataWithRootObject:object];

//save the cache file

JSONCacheFile* file = [[JSONCacheFile alloc] initWithKey:key andEtag:etag];

NSString* filePath = [cacheDirectory stringByAppendingPathComponent: file.fileName];

BOOL success = [data writeToFile:filePath atomically:YES];

if (success) {

//save the object to the disc

[cacheFiles setValue: file forKey:key];

}

if (cacheFiles.count>0 && observingConnection==NO) {

//observe connectivity changes

[self startConnectivityObserver];

NSLog(@"JSONCache.isOnline = %@", _isOnline?@"YES":@"NO");

}

return success;

}

-(JSONCacheResponse*)objectForMethod:(NSString*)method andParams:(id)params

{

NSString* key = [self keyForMethod:method andParams:params];

JSONCacheFile* file = cacheFiles[key];

if (!file) return nil;

if ([self isObjectExpired: file]) {

//expired content

[self trimObjectForKey: key];

return nil;

}

NSString* filePath = [cacheDirectory stringByAppendingPathComponent:file.fileName];

NSData* data = [NSData dataWithContentsOfFile: filePath];

id object;

@try {

object = [NSKeyedUnarchiver unarchiveObjectWithData:data];

} @catch (NSException* e) {

return nil;

}

JSONCacheResponse* response = [[JSONCacheResponse alloc] init];

response.object = object;

response.isOfflineVersion = !self.isOnline;

NSTimeInterval now = [[NSDate date] timeIntervalSinceReferenceDate] + 1;

if (self.isOnline && JCFEqual(self.revalidateCacheFromServerAfterTimeInHours, kNeverRevalidate)) {

//check for revalidation rules

NSTimeInterval expiration = _revalidateFromServerTimeInterval;

if (now > file.modificationTime + expiration) {

response.mustRevalidate = YES;

NSDateFormatter *dateFormatter = [[NSDateFormatter alloc] init];

[dateFormatter setDateFormat:@"yyyy-MM-dd'T'HH:mm:ssZZZZ"];

NSDate* lastModificationDate = [NSDate dateWithTimeIntervalSinceReferenceDate:file.modificationTime];

[response.revalidateHeaders setValue: [dateFormatter stringFromDate: lastModificationDate]

forKey: self.isUsingXdHTTPHeaderNames? kIfModifiedSinceHTTPHeaderNameXd: kIfModifiedSinceHTTPHeaderName ];

}

}

if (self.isOnline && JCFEqual(self.revalidateCacheViaETagAfterTimeInHours,kNeverRevalidate)==NO ) {

//check for the revalidation rules

NSTimeInterval expiration = _revalidateFromServerWithETagTimeInterval;

if (now > file.modificationTime + expiration) {

response.mustRevalidate = YES;

if (file.etag != nil) {

[response.revalidateHeaders setValue: file.etag

forKey: self.isUsingXdHTTPHeaderNames? kETagHTTPHeaderNameXd: kETagHTTPHeaderName ];

}

}

}

NSLog(@"CASHED RESULT!!!");

return response;

}

-(NSString*)keyForMethod:(NSString*)method andParams:(id)params

{

if (params==nil) return method;

NSData* data = [NSJSONSerialization dataWithJSONObject: @{@"m":method,@"p":params}

options: kNilOptions error:NULL];

NSString* key = [[NSString alloc] initWithData:data encoding: NSUTF8StringEncoding];

return [self MD5:key];

}

-(void)trimExpiredObjects

{

NSTimeInterval now = [[NSDate date] timeIntervalSinceReferenceDate];

NSLog(@"trim expired objects...");

for (NSString* key in [cacheFiles allKeys]) {

JSONCacheFile* object = cacheFiles[key];

if (now > object.modificationTime + MAX(_expirationOnlineTimeInterval, _expirationOfflineTimeInterval)) {

//expired content - remove the file

NSLog(@"expired content for key %@", key);

NSLog(@"now: %.f %@", now, [NSDate dateWithTimeIntervalSinceReferenceDate: now]);

NSLog(@"object mod time: %.f %@", object.modificationTime, [NSDate dateWithTimeIntervalSinceReferenceDate:object.modificationTime]);

NSLog(@"expiration: %.f %@", object.modificationTime + MAX(_expirationOnlineTimeInterval, _expirationOfflineTimeInterval), [NSDate dateWithTimeIntervalSinceReferenceDate:object.modificationTime + MAX(_expirationOnlineTimeInterval, _expirationOfflineTimeInterval)]);

[self trimObjectForKey: key];

}

}

}

-(void)trimObjectForMethod:(NSString*)method andParams:(id)params

{

[self trimObjectForKey: [self keyForMethod:method andParams:params] ];

}

-(void)trimObjectForKey:(NSString*)key

{

NSLog(@"delete file: %@", key);

JSONCacheFile* file = cacheFiles[key];

NSString* filePath = [cacheDirectory stringByAppendingPathComponent: file.fileName];

[fm removeItemAtPath:filePath error:NULL];

[cacheFiles removeObjectForKey: key];

if (cacheFiles.count==0 && observingConnection==YES) {

//observe connectivity changes

[self stopConnectivityObserver];

}

}

-(void)purgeCache

{

for (NSString* key in [cacheFiles allKeys]) {

[self trimObjectForKey: key];

}

}

#pragma mark - connectivity methods

static void ReachabilityCallback(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void *info)

{

#pragma unused (target, flags, info)

[instance updateConnectivity];

}

-(void)startConnectivityObserver

{

if (reachabilityRef==NULL) {

[self updateConnectivity];

}

SCNetworkReachabilityContext context = {0, (__bridge void *)(self), NULL, NULL, NULL};

if(SCNetworkReachabilitySetCallback(reachabilityRef, ReachabilityCallback, &context))

{

if(SCNetworkReachabilityScheduleWithRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode))

{

observingConnection = YES;

}

}

}

-(void)stopConnectivityObserver

{

if(reachabilityRef!= NULL)

{

SCNetworkReachabilityUnscheduleFromRunLoop(reachabilityRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);

}

observingConnection = NO;

}

-(void)updateConnectivity

{

struct sockaddr_in zeroAddress;

bzero(&zeroAddress, sizeof(zeroAddress));

zeroAddress.sin_len = sizeof(zeroAddress);

zeroAddress.sin_family = AF_INET;

reachabilityRef = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr*)&zeroAddress);

if(reachabilityRef != NULL) {

SCNetworkReachabilityFlags flags;

if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags)) {

if ((flags & kSCNetworkReachabilityFlagsReachable) == 0)

{

_isOnline = NO;

return;

}

if ((flags & kSCNetworkReachabilityFlagsConnectionRequired) == 0)

{

_isOnline = YES;

return;

}

if ((((flags & kSCNetworkReachabilityFlagsConnectionOnDemand ) != 0) ||

(flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) != 0))

{

if ((flags & kSCNetworkReachabilityFlagsInterventionRequired) == 0)

{

_isOnline = YES;

return;

}

}

#if TARGET_OS_IPHONE

if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN)

{

_isOnline = YES;

return;

}

#endif

}

}

_isOnline = NO;

}

#pragma mark - convenience methods

-(BOOL)isObjectExpired:(JSONCacheFile*)object

{

NSTimeInterval now = [[NSDate date] timeIntervalSinceReferenceDate];

NSTimeInterval expiration = 0;

if (self.isOnline==NO && JCFEqual(self.expirationTimeInHoursWhenOffline, kImmediatelyExpire) ) {

NSLog(@"expire %@ for Offline:offline disabled", object.key);

//it's always expired

return YES;

} else if (self.isOnline==YES && JCFEqual(self.expirationTimeInHoursWhenOffline, kImmediatelyExpire) ) {

//online cache expiration

NSLog(@"check expiration online with time: %.f", _expirationOnlineTimeInterval);

expiration = _expirationOnlineTimeInterval;

} else if (self.isOnline==YES && self.expirationTimeInHoursWhenOffline>kImmediatelyExpire) {

//offline expiration time

NSLog(@"check expiration offline with time: %.f", _expirationOfflineTimeInterval);

expiration = _expirationOfflineTimeInterval;

} else {

//just return the longer of the two exp. times

NSLog(@"check expiration combined with time: %.f", MAX(_expirationOfflineTimeInterval, _expirationOnlineTimeInterval));

expiration = MAX(_expirationOfflineTimeInterval, _expirationOnlineTimeInterval);

}

return (now > object.modificationTime + expiration);

}

//http://stackoverflow.com/questions/1524604/md5-algorithm-in-objective-c

-(NSString*)MD5:(NSString*)string

{

const char *cStr = [string UTF8String];

unsigned char result[16];

CC_MD5( cStr, (CC_LONG)strlen(cStr), result );

return [NSString stringWithFormat:

@"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",

result[0], result[1], result[2], result[3],

result[4], result[5], result[6], result[7],

result[8], result[9], result[10], result[11],

result[12], result[13], result[14], result[15]

];

}

-(NSString*)description

{

return [cacheFiles description];

}

#pragma mark - custom property getters

-(NSString*)etagHeaderName

{

return self.isUsingXdHTTPHeaderNames? kETagHTTPHeaderNameXd: kETagHTTPHeaderName;

}

#pragma mark - custom property setters

-(void)setExpirationTimeInHours:(float)hrs

{

_expirationTimeInHours = hrs;

_expirationOnlineTimeInterval = (JCFEqual(hrs,kNeverExpire))?kNeverExpire: hrs * 360;

}

-(void)setExpirationTimeInHoursWhenOffline:(float)hrs

{

_expirationTimeInHoursWhenOffline = hrs;

_expirationOfflineTimeInterval = (JCFEqual(hrs, kNeverExpire))?kNeverExpire: hrs * 360;

NSLog(@"exp. offline time: %.f", _expirationOfflineTimeInterval);

}

-(void)setRevalidateCacheFromServerAfterTimeInHours:(float)hrs

{

_revalidateCacheFromServerAfterTimeInHours = hrs;

_revalidateFromServerTimeInterval = (JCFEqual(hrs, kNeverRevalidate))?kNeverRevalidate: hrs * 360;

}

-(void)setRevalidateCacheViaETagAfterTimeInHours:(float)hrs

{

_revalidateCacheViaETagAfterTimeInHours = hrs;

_revalidateFromServerWithETagTimeInterval = (JCFEqual(hrs, kNeverRevalidate))?kNeverRevalidate: hrs * 360;

}

@end