#import "Photo.h"

#import "Thumbnail.h"

#import "PhotoGalleryContext.h"

#import "MakeThumbnailOperation.h"

#import "NetworkManager.h"

#import "RetryingHTTPOperation.h"

#import "QHTTPOperation.h"

#import "Logging.h"

const CGFloat kThumbnailSize = 60.0f;

@interface Photo ()

@property (nonatomic, retain, readwrite) NSString * photoID;

@property (nonatomic, retain, readwrite) NSString * displayName;

@property (nonatomic, retain, readwrite) NSDate * date;

@property (nonatomic, retain, readwrite) NSString * localPhotoPath;

@property (nonatomic, retain, readwrite) NSString * remotePhotoPath;

@property (nonatomic, retain, readwrite) NSString * remoteThumbnailPath;

@property (nonatomic, retain, readwrite) Thumbnail * thumbnail;

@property (nonatomic, copy, readwrite) NSError * photoGetError;

@property (nonatomic, retain, readonly ) PhotoGalleryContext * photoGalleryContext;

@property (nonatomic, retain, readwrite) RetryingHTTPOperation * thumbnailGetOperation;

@property (nonatomic, retain, readwrite) MakeThumbnailOperation * thumbnailResizeOperation;

@property (nonatomic, retain, readwrite) RetryingHTTPOperation * photoGetOperation;

@property (nonatomic, copy, readwrite) NSString * photoGetFilePath;

@property (nonatomic, assign, readwrite) BOOL thumbnailImageIsPlaceholder;

- (void)updateThumbnail;

- (void)updatePhoto;

- (void)thumbnailCommitImage:(UIImage *)image isPlaceholder:(BOOL)isPlaceholder;

- (void)thumbnailCommitImageData:(UIImage *)image;

@implementation Photo

+ (Photo *)insertNewPhotoWithProperties:(NSDictionary *)properties inManagedObjectContext:(NSManagedObjectContext *)managedObjectContext

// See comment in header.

{

Photo * result;

assert(properties != nil);

assert( [[properties objectForKey:@"photoID"] isKindOfClass:[NSString class]] );

assert( [[properties objectForKey:@"displayName"] isKindOfClass:[NSString class]] );

assert( [[properties objectForKey:@"date"] isKindOfClass:[NSDate class]] );

assert( [[properties objectForKey:@"remotePhotoPath"] isKindOfClass:[NSString class]] );

assert( [[properties objectForKey:@"remoteThumbnailPath"] isKindOfClass:[NSString class]] );

assert(managedObjectContext != nil);

result = (Photo *) [NSEntityDescription insertNewObjectForEntityForName:@"Photo" inManagedObjectContext:managedObjectContext];

if (result != nil) {

assert([result isKindOfClass:[Photo class]]);

result.photoID = [[[properties objectForKey:@"photoID"] copy] autorelease];

assert(result.photoID != nil);

#if MVCNETWORKING_KEEP_PHOTO_ID_BACKUP

result->_photoIDBackup = [result.photoID copy];

#endif

result.displayName = [[[properties objectForKey:@"displayName"] copy] autorelease];

result.date = [[[properties objectForKey:@"date"] copy] autorelease];

result.remotePhotoPath = [[[properties objectForKey:@"remotePhotoPath"] copy] autorelease];

result.remoteThumbnailPath = [[[properties objectForKey:@"remoteThumbnailPath"] copy] autorelease];

}

return result;

}

#if MVCNETWORKING_KEEP_PHOTO_ID_BACKUP

- (id)initWithEntity:(NSEntityDescription *)entity insertIntoManagedObjectContext:(NSManagedObjectContext *)context

// In the debug build we maintain _photoIDBackup to assist with debugging.

{

self = [super initWithEntity:entity insertIntoManagedObjectContext:context];

if (self != nil) {

self->_photoIDBackup = [self.photoID copy];

}

return self;

}

#endif

- (void)dealloc

{

#if MVCNETWORKING_KEEP_PHOTO_ID_BACKUP

[self->_photoIDBackup release];

#endif

[self->_thumbnailImage release];

assert(self->_thumbnailGetOperation == nil); // As far as I can tell there are only two ways for these objects to get deallocated,

assert(self->_thumbnailResizeOperation == nil); // namely, the object being deleted and the entire managed object context going away

assert(self->_photoGetOperation == nil); // (which turns the object into a fault). In both cases -stop runs, which shuts down

assert(self->_photoGetFilePath == nil); // this stuff. But the asserts are here, just to be sure.

[self->_photoGetError release];

[super dealloc];

}

- (void)updateWithProperties:(NSDictionary *)properties

// See comment in header.

{

#pragma unused(properties)

BOOL thumbnailNeedsUpdate;

BOOL photoNeedsUpdate;

assert( [self.photoID isEqual:[properties objectForKey:@"photoID"]] );

assert( [[properties objectForKey:@"displayName"] isKindOfClass:[NSString class]] );

assert( [[properties objectForKey:@"date"] isKindOfClass:[NSDate class]] );

assert( [[properties objectForKey:@"remotePhotoPath"] isKindOfClass:[NSString class]] );

assert( [[properties objectForKey:@"remoteThumbnailPath"] isKindOfClass:[NSString class]] );

if ( ! [self.displayName isEqual:[properties objectForKey:@"displayName"]] ) {

self.displayName = [[[properties objectForKey:@"displayName"] copy] autorelease];

}

thumbnailNeedsUpdate = NO;

photoNeedsUpdate = NO;

// Look at the date and the various remote paths and decide what needs updating.

if ( ! [self.date isEqual:[properties objectForKey:@"date"]] ) {

self.date = [[[properties objectForKey:@"date"] copy] autorelease];

thumbnailNeedsUpdate = YES;

photoNeedsUpdate = YES;

}

if ( ! [self.remotePhotoPath isEqual:[properties objectForKey:@"remotePhotoPath"]] ) {

self.remotePhotoPath = [[[properties objectForKey:@"remotePhotoPath"] copy] autorelease];

photoNeedsUpdate = YES;

}

if ( ! [self.remoteThumbnailPath isEqual:[properties objectForKey:@"remoteThumbnailPath"]] ) {

self.remoteThumbnailPath = [[[properties objectForKey:@"remoteThumbnailPath"] copy] autorelease];

thumbnailNeedsUpdate = YES;

}

// Do the updates.

if (thumbnailNeedsUpdate) {

[self updateThumbnail];

}

if (photoNeedsUpdate) {

[self updatePhoto];

}

}

@dynamic photoID;

@dynamic displayName;

@dynamic date;

@dynamic localPhotoPath;

@dynamic remotePhotoPath;

@dynamic remoteThumbnailPath;

@dynamic thumbnail;

- (PhotoGalleryContext *)photoGalleryContext

{

PhotoGalleryContext * result;

result = (PhotoGalleryContext *) [self managedObjectContext];

assert( [result isKindOfClass:[PhotoGalleryContext class]] );

return result;

}

- (BOOL)stopThumbnail

{

BOOL didSomething;

didSomething = NO;

if (self.thumbnailGetOperation != nil) {

[self.thumbnailGetOperation removeObserver:self forKeyPath:@"hasHadRetryableFailure"];

[[NetworkManager sharedManager] cancelOperation:self.thumbnailGetOperation];

self.thumbnailGetOperation = nil;

didSomething = YES;

}

if (self.thumbnailResizeOperation != nil) {

[[NetworkManager sharedManager] cancelOperation:self.thumbnailResizeOperation];

self.thumbnailResizeOperation = nil;

didSomething = YES;

}

return didSomething;

}

- (void)stop

// Stops all async activity on the object.

{

BOOL didSomething;

// If we're currently fetching the thumbnail, cancel that.

didSomething = [self stopThumbnail];

if (didSomething) {

[[QLog log] logWithFormat:@"photo %@ thumbnail get stopped", self.photoID];

}

// If we're currently fetching the photo, cancel that.

if (self.photoGetOperation != nil) {

[[NetworkManager sharedManager] cancelOperation:self.photoGetOperation];

self.photoGetOperation = nil;

if (self.photoGetFilePath != nil) {

(void) [[NSFileManager defaultManager] removeItemAtPath:self.photoGetFilePath error:NULL];

self.photoGetFilePath = nil;

}

[[QLog log] logWithFormat:@"photo %@ photo get stopped", self.photoID];

}

}

- (void)prepareForDeletion

// We have to override prepareForDeletion in order to get rid of the photo

// file. We take the opportunity to stop any async operations at the

// same time. We'll get a second bite of that cherry in -willTurnIntoFault,

// but we might as well do it now.

{

BOOL success;

[[QLog log] logWithFormat:@"photo %@ deleted", self.photoID];

// Stop any asynchronous operations.

[self stop];

// Delete the photo file if it exists on disk.

if (self.localPhotoPath != nil) {

success = [[NSFileManager defaultManager] removeItemAtPath:[self.photoGalleryContext.photosDirectoryPath stringByAppendingPathComponent:self.localPhotoPath] error:NULL];

assert(success);

}

[super prepareForDeletion];

}

- (void)willTurnIntoFault

// There are three common reasons for turning into a fault:

//

// o Core Data has decided we're uninteresting, and is reclaiming our memory.

// o We're in the process of being deleted.

// o The managed object context itself is going away.

//

// Regardless of the reason, if we turn into a fault we can any async

// operations on the object. This is especially important in the last

// case, where Core Data can't satisfy any fault requests (and, unlike in

// the delete case, we didn't get a chance to stop our async operations in

// -prepareForDelete).

{

[self stop];

[super willTurnIntoFault];

}

#pragma mark * Thumbnails

@synthesize thumbnailGetOperation = _thumbnailGetOperation;

@synthesize thumbnailResizeOperation = _thumbnailResizeOperation;

@synthesize thumbnailImageIsPlaceholder = _thumbnailImageIsPlaceholder;

- (void)startThumbnailGet

// Starts the HTTP operation to GET the photo's thumbnail.

{

NSURLRequest * request;

assert(self.remoteThumbnailPath != nil);

assert(self.thumbnailGetOperation == nil);

assert(self.thumbnailResizeOperation == nil);

request = [self.photoGalleryContext requestToGetGalleryRelativeString:self.remoteThumbnailPath];

if (request == nil) {

[[QLog log] logWithFormat:@"photo %@ thumbnail get bad path '%@'", self.photoID, self.remoteThumbnailPath];

[self thumbnailCommitImage:nil isPlaceholder:YES];

} else {

self.thumbnailGetOperation = [[[RetryingHTTPOperation alloc] initWithRequest:request] autorelease];

assert(self.thumbnailGetOperation != nil);

[self.thumbnailGetOperation setQueuePriority:NSOperationQueuePriorityLow];

self.thumbnailGetOperation.acceptableContentTypes = [NSSet setWithObjects:@"image/jpeg", @"image/png", nil];

[[QLog log] logWithFormat:@"photo %@ thumbnail get start '%@'", self.photoID, self.remoteThumbnailPath];

[self.thumbnailGetOperation addObserver:self forKeyPath:@"hasHadRetryableFailure" options:0 context:&self->_thumbnailImage];

[[NetworkManager sharedManager] addNetworkManagementOperation:self.thumbnailGetOperation finishedTarget:self action:@selector(thumbnailGetDone:)];

}

}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context

{

if (context == &self->_thumbnailImage) {

assert(object == self.thumbnailGetOperation);

assert( [keyPath isEqual:@"hasHadRetryableFailure"] );

assert([NSThread isMainThread]);

// If we're currently showing a placeholder and the network operation

// indicates that it's had one failure, change the placeholder to the deferred

// placeholder. The test for thumbnailImageIsPlaceholder is necessary in the

// -updateThumbnail case because we don't want to replace a valid (but old)

// thumbnail with a placeholder.

if (self.thumbnailImageIsPlaceholder && self.thumbnailGetOperation.hasHadRetryableFailure) {

[self thumbnailCommitImage:[UIImage imageNamed:@"Placeholder-Deferred.png"] isPlaceholder:YES];

}

} else if (NO) { // Disabled because the super class does nothing useful with it.

[super observeValueForKeyPath:keyPath ofObject:object change:change context:context];

}

}

- (void)thumbnailGetDone:(RetryingHTTPOperation *)operation

// Called when the HTTP operation to GET the photo's thumbnail completes.

// If all is well, we start a resize operation to reduce it the appropriate

// size.

{

assert([NSThread isMainThread]);

assert([operation isKindOfClass:[RetryingHTTPOperation class]]);

assert(operation == self.thumbnailGetOperation);

assert([self.thumbnailGetOperation isFinished]);

assert(self.thumbnailResizeOperation == nil);

[[QLog log] logWithFormat:@"photo %@ thumbnail get done", self.photoID];

if (operation.error != nil) {

[[QLog log] logWithFormat:@"photo %@ thumbnail get error %@", self.photoID, operation.error];

[self thumbnailCommitImage:nil isPlaceholder:YES];

(void) [self stopThumbnail];

} else {

[[QLog log] logOption:kLogOptionNetworkData withFormat:@"receive %@", operation.responseContent];

// Got the data successfully. Let's start the resize operation.

self.thumbnailResizeOperation = [[[MakeThumbnailOperation alloc] initWithImageData:operation.responseContent MIMEType:operation.responseMIMEType] autorelease];

assert(self.thumbnailResizeOperation != nil);

self.thumbnailResizeOperation.thumbnailSize = kThumbnailSize;

// We want thumbnails resizes to soak up unused CPU time, but the main thread should

// always run if it can. The operation priority is a relative value (courtesy of the

// underlying Mach THREAD_PRECEDENCE_POLICY), that is, it sets the priority relative

// to other threads in the same process. A value of 0.5 is the default, so we set a

// value significantly lower than that.

if ( [self.thumbnailResizeOperation respondsToSelector:@selector(setThreadPriority:)] ) {

[self.thumbnailResizeOperation setThreadPriority:0.2];

}

[self.thumbnailResizeOperation setQueuePriority:NSOperationQueuePriorityLow];

[[NetworkManager sharedManager] addCPUOperation:self.thumbnailResizeOperation finishedTarget:self action:@selector(thumbnailResizeDone:)];

}

}

- (void)thumbnailResizeDone:(MakeThumbnailOperation *)operation

// Called when the operation to resize the thumbnail completes.

// If all is well, we commit the thumbnail to our database.

{

UIImage * image;

assert([NSThread isMainThread]);

assert([operation isKindOfClass:[MakeThumbnailOperation class]]);

assert(operation == self.thumbnailResizeOperation);

assert([self.thumbnailResizeOperation isFinished]);

[[QLog log] logWithFormat:@"photo %@ thumbnail resize done", self.photoID];

if (operation.thumbnail == NULL) {

[[QLog log] logWithFormat:@"photo %@ thumbnail resize failed", self.photoID];

image = nil;

} else {

image = [UIImage imageWithCGImage:operation.thumbnail];

assert(image != nil);

}

[self thumbnailCommitImage:image isPlaceholder:NO];

[self stopThumbnail];

}

- (void)thumbnailCommitImage:(UIImage *)image isPlaceholder:(BOOL)isPlaceholder

// Commits the thumbnail image to the object itself and to the Core Data database.

{

// If we were given no image, that's a shortcut for the bad image placeholder. In

// that case we ignore the incoming value of placeholder and force it to YES.

if (image == nil) {

isPlaceholder = YES;

image = [UIImage imageNamed:@"Placeholder-Bad.png"];

assert(image != nil);

}

// If it was a placeholder, someone else has logged about the failure, so

// we only log for real thumbnails.

if ( ! isPlaceholder ) {

[[QLog log] logWithFormat:@"photo %@ thumbnail commit", self.photoID];

}

// If we got a non-placeholder image, commit its PNG representation into our thumbnail

// database. To avoid the scroll view stuttering, we only want to do this if the run loop

// is running in the default mode. Thus, we check the mode and either do it directly or

// defer the work until the next time the default run loop mode runs.

//

// If we were running on iOS 4 or later we could get the PNG representation using

// ImageIO, but I want to maintain iOS 3 compatibility for the moment and on that

// system we have to use UIImagePNGRepresentation.

if ( ! isPlaceholder ) {

if ( [[[NSRunLoop currentRunLoop] currentMode] isEqual:NSDefaultRunLoopMode] ) {

[self thumbnailCommitImageData:image];

} else {

[self performSelector:@selector(thumbnailCommitImageData:) withObject:image afterDelay:0.0 inModes:[NSArray arrayWithObject:NSDefaultRunLoopMode]];

}

}

// Commit the change to our thumbnailImage property.

[self willChangeValueForKey:@"thumbnailImage"];

[self->_thumbnailImage release];

self->_thumbnailImage = [image retain];

[self didChangeValueForKey:@"thumbnailImage"];

}

- (void)thumbnailCommitImageData:(UIImage *)image

// Commits the thumbnail data to the Core Data database.

{

[[QLog log] logWithFormat:@"photo %@ thumbnail commit image data", self.photoID];

// If we have no thumbnail object, create it.

if (self.thumbnail == nil) {

self.thumbnail = [NSEntityDescription insertNewObjectForEntityForName:@"Thumbnail" inManagedObjectContext:self.managedObjectContext];

assert(self.thumbnail != nil);

}

// Stash the data in the thumbnail object's imageData property.

if (self.thumbnail.imageData == nil) {

self.thumbnail.imageData = UIImagePNGRepresentation(image);

assert(self.thumbnail.imageData != nil);

}

}

- (UIImage *)thumbnailImage

{

if (self->_thumbnailImage == nil) {

if ( (self.thumbnail != nil) && (self.thumbnail.imageData != nil) ) {

// If we have a thumbnail from the database, return that.

self.thumbnailImageIsPlaceholder = NO;

self->_thumbnailImage = [[UIImage alloc] initWithData:self.thumbnail.imageData];

assert(self->_thumbnailImage != nil);

} else {

assert(self.thumbnailGetOperation == nil); // These should be nil because the only code paths that start

assert(self.thumbnailResizeOperation == nil); // a get also ensure there's a thumbnail in place (either a

// placeholder or the old thumbnail).

// Otherwise, return the placeholder and kick off a get (unless we're

// already getting).

self.thumbnailImageIsPlaceholder = YES;

self->_thumbnailImage = [[UIImage imageNamed:@"Placeholder.png"] retain];

assert(self->_thumbnailImage != nil);

[self startThumbnailGet];

}

}

return self->_thumbnailImage;

}

- (void)updateThumbnail

// Updates the thumbnail is response to a change in the photo's XML entity.

{

[[QLog log] logWithFormat:@"photo %@ update thumbnail", self.photoID];

// We only do an update if we've previously handed out a thumbnail image.

// If not, the thumbnail will be fetched normally when the client first

// requests an image.

if (self->_thumbnailImage != nil) {

// If we're already getting a thumbnail, stop that get (it may be getting from

// the old path).

(void) [self stopThumbnail];

// Nix our thumbnail data. This ensures that, if we quit before the get is complete,

// then, on relaunch, we will notice that we need to get the thumbnail.

if (self.thumbnail != nil) {

self.thumbnail.imageData = nil;

}

// Kick off the network get. Note that we don't nix _thumbnailImage here. The client

// will continue to see the old thumbnail (which might be a placeholder) until the

// get completes.

[self startThumbnailGet];

}

}

#pragma mark * Photos

@synthesize photoGetOperation = _photoGetOperation;

@synthesize photoGetFilePath = _photoGetFilePath;

@synthesize photoGetError = _photoGetError;

- (void)startPhotoGet

// Starts the HTTP operation to GET the photo itself.

{

NSURLRequest * request;

assert(self.remotePhotoPath != nil);

// assert(self.localPhotoPath == nil); -- May be non-nil when we're updating the photo.

assert( ! self.photoGetting );

assert(self.photoGetOperation == nil);

assert(self.photoGetFilePath == nil);

self.photoGetError = nil;

request = [self.photoGalleryContext requestToGetGalleryRelativeString:self.remotePhotoPath];

if (request == nil) {

[[QLog log] logWithFormat:@"photo %@ photo get bad path '%@'", self.photoID, self.remotePhotoPath];

self.photoGetError = [NSError errorWithDomain:kQHTTPOperationErrorDomain code:400 userInfo:nil];

} else {

// We start by downloading the photo to a temporary file. Create an output stream

// for that file.

self.photoGetFilePath = [NSTemporaryDirectory() stringByAppendingPathComponent:[NSString stringWithFormat:@"PhotoTemp-%.9f", [NSDate timeIntervalSinceReferenceDate]]];

assert(self.photoGetFilePath != nil);

// Create, configure, and start the download operation.

self.photoGetOperation = [[[RetryingHTTPOperation alloc] initWithRequest:request] autorelease];

assert(self.photoGetOperation != nil);

[self.photoGetOperation setQueuePriority:NSOperationQueuePriorityHigh];

self.photoGetOperation.responseFilePath = self.photoGetFilePath;

self.photoGetOperation.acceptableContentTypes = [NSSet setWithObjects:@"image/jpeg", @"image/png", nil];

[[QLog log] logWithFormat:@"photo %@ photo get start '%@'", self.photoID, self.remotePhotoPath];

[[NetworkManager sharedManager] addNetworkManagementOperation:self.photoGetOperation finishedTarget:self action:@selector(photoGetDone:)];

}

}

- (void)photoGetDone:(RetryingHTTPOperation *)operation

// Called when the HTTP operation to GET the photo completes.

// If all is well, we commit the photo to the database.

{

assert([NSThread isMainThread]);

assert([operation isKindOfClass:[RetryingHTTPOperation class]]);

assert(operation == self.photoGetOperation);

[[QLog log] logWithFormat:@"photo %@ photo get done", self.photoID];

if (operation.error != nil) {

[[QLog log] logWithFormat:@"photo %@ photo get error %@", self.photoID, operation.error];

self.photoGetError = operation.error;

} else {

BOOL success;

NSString * type;

NSString * extension;

NSString * fileName;

NSUInteger fileCounter;

NSError * error;

// Can't log the incoming data becauses it went directly to disk.

//

// [[QLog log] logOption:kLogOptionNetworkData withFormat:@"receive %@", operation.responseContent];

// Just to keep things sane, we set the file name extension based on the MIME type.

type = operation.responseMIMEType;

assert(type != nil);

if ([type isEqual:@"image/png"]) {

extension = @"png";

} else {

assert([type isEqual:@"image/jpeg"]);

extension = @"jpg";

}

// Move the file to the gallery's photo directory, and if that's successful, set localPhotoPath

// to point to it. We automatically rename the file to avoid conflicts. Conflicts do happen

// in day-to-day operations (specifically, in the case where we update a photo while actually

// displaying that photo).

fileCounter = 0;

do {

fileName = [NSString stringWithFormat:@"Photo-%@-%zu.%@", self.photoID, (size_t) fileCounter, extension];

assert(fileName != nil);

success = [[NSFileManager defaultManager] moveItemAtPath:self.photoGetFilePath toPath:[self.photoGalleryContext.photosDirectoryPath stringByAppendingPathComponent:fileName] error:&error];

if ( success ) {

self.photoGetFilePath = nil;

break;

}

fileCounter += 1;

if (fileCounter > 100) {

break;

}

} while (YES);

// On success, update localPhotoPath to point to the newly downloaded photo

// and then delete the previous photo (if any).

if (success) {

NSString * oldLocalPhotoPath;

oldLocalPhotoPath = [[self.localPhotoPath copy] autorelease];

[[QLog log] logWithFormat:@"photo %@ photo get commit '%@'", self.photoID, fileName];

self.localPhotoPath = fileName;

assert(self.photoGetError == nil);

if (oldLocalPhotoPath != nil) {

[[QLog log] logWithFormat:@"photo %@ photo cleanup '%@'", self.photoID, oldLocalPhotoPath];

(void) [[NSFileManager defaultManager] removeItemAtPath:[self.photoGalleryContext.photosDirectoryPath stringByAppendingPathComponent:oldLocalPhotoPath] error:NULL];

}

} else {

assert(error != nil);

[[QLog log] logWithFormat:@"photo %@ photo get commit failed %@", self.photoID, error];

self.photoGetError = error;

}

}

// Clean up.

self.photoGetOperation = nil;

if (self.photoGetFilePath != nil) {

(void) [[NSFileManager defaultManager] removeItemAtPath:self.photoGetFilePath error:NULL];

self.photoGetFilePath = nil;

}

}

+ (NSSet *)keyPathsForValuesAffectingPhotoImage

{

return [NSSet setWithObject:@"localPhotoPath"];

}

- (UIImage *)photoImage

// See comment in header.

{

UIImage * result;

// Note that we don't retain the photo here. Photos are large, and holding on to them here

// is probably a mistake. It's likely that the caller is going to retain the photo anyway

// (by putting it into an image view, say).

if (self.localPhotoPath == nil) {

result = nil;

} else {

result = [UIImage imageWithContentsOfFile:[self.photoGalleryContext.photosDirectoryPath stringByAppendingPathComponent:self.localPhotoPath]];

if (result == nil) {

[[QLog log] logWithFormat:@"photo %@ photo data bad", self.photoID];

}

}

return result;

}

+ (NSSet *)keyPathsForValuesAffectingPhotoGetting

{

return [NSSet setWithObject:@"photoGetOperation"];

}

- (BOOL)photoGetting

// See comment in header.

{

return (self.photoGetOperation != nil);

}

- (void)assertPhotoNeeded

// See comment in header.

{

self->_photoNeededAssertions += 1;

if ( (self.localPhotoPath == nil) && ! self.photoGetting ) {

[self startPhotoGet];

}

}

- (void)deassertPhotoNeeded

// See comment in header.

{

assert(self->_photoNeededAssertions != 0);

self->_photoNeededAssertions -= 1;

}

- (void)updatePhoto

// Updates the photo is response to a change in the photo's XML entity.

{

[[QLog log] logWithFormat:@"photo %@ update photo", self.photoID];

// We only fetch the photo is someone is actively looking at it. Otherwise

// we just nix our record of the photo and fault it in as per usual the next

// time that someone asserts that they need it.

if (self->_photoNeededAssertions == 0) {

// No one is actively looking at the photo. If we have the photo downloaded,

// just forget about it.

if (self.localPhotoPath != nil) {

[[QLog log] logWithFormat:@"photo %@ photo delete old photo '%@'", self.photoID, self.localPhotoPath];

[[NSFileManager defaultManager] removeItemAtPath:[self.photoGalleryContext.photosDirectoryPath stringByAppendingPathComponent:self.localPhotoPath] error:NULL];

self.localPhotoPath = nil;

}

} else {

// If we're already getting the photo, stop that get (it may be getting from

// the old path).

if (self.photoGetOperation != nil) {

[[NetworkManager sharedManager] cancelOperation:self.photoGetOperation];

self.photoGetOperation = nil;

}

// Someone is actively looking at the photo. We start a new download, which

// will download the new photo to a new file. When that completes, it will

// change localPhotoPath to point to the new file and then delete the old

// file.

//

// Note that we don't trigger a KVO notification on photoImage at this point.

// Instead we leave the user looking at the old photo; it's better than nothing (-:

[self startPhotoGet];

}

}