Synnefo » Pithos MacOS Client

//

//  pithos_macosAppDelegate.m

//  pithos-macos

//

// Copyright 2011-2012 GRNET S.A. All rights reserved.

//

// Redistribution and use in source and binary forms, with or

// without modification, are permitted provided that the following

// conditions are met:

// 

//   1. Redistributions of source code must retain the above

//      copyright notice, this list of conditions and the following

//      disclaimer.

// 

//   2. Redistributions in binary form must reproduce the above

//      copyright notice, this list of conditions and the following

//      disclaimer in the documentation and/or other materials

//      provided with the distribution.

// 

// THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

// USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

// 

// The views and conclusions contained in the software and

// documentation are those of the authors and should not be

// interpreted as representing official policies, either expressed

// or implied, of GRNET S.A.

#import "pithos_macosAppDelegate.h"

#import "PithosAccount.h"

#import "PithosBrowserController.h"

#import "PithosPreferencesController.h"

#import "PithosSyncDaemon.h"

#import "ASIPithosRequest.h"

#import "ASIPithos.h"

#import "ASIDownloadCache.h"

#import "LastCompletedSyncTransformer.h"

@implementation pithos_macosAppDelegate

@synthesize pithosBrowserController, pithosPreferencesController, alwaysNo, activated, 

currentPithosAccount, pithosAccounts, pithosAccountsDictionary, syncPithosAccount, activityFacilityTimeInterval;

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {

    [[NSAppleEventManager sharedAppleEventManager] setEventHandler:self 

                                                       andSelector:@selector(handleAppleEvent:withReplyEvent:) 

                                                     forEventClass:kInternetEventClass 

                                                        andEventID:kAEGetURL];

    userDefaults = [[NSUserDefaults standardUserDefaults] retain];

    syncTimeInterval = [userDefaults doubleForKey:@"syncTimeInterval"];

    if (syncTimeInterval <= 0.0) {

        syncTimeInterval = 180.0;

        [userDefaults setDouble:syncTimeInterval forKey:@"syncTimeInterval"];

        [userDefaults synchronize];

    }

    activityFacilityTimeInterval = [userDefaults doubleForKey:@"activityFacilityTimeInterval"];

    if (activityFacilityTimeInterval <= 0.0) {

        activityFacilityTimeInterval = 0.05;

        [userDefaults setDouble:activityFacilityTimeInterval forKey:@"activityFacilityTimeInterval"];

        [userDefaults synchronize];

    }

    NSData *tmpData = [userDefaults objectForKey:@"pithosAccounts"];

    NSArray *tmpArray;

    if (tmpData && (tmpArray = [NSKeyedUnarchiver unarchiveObjectWithData:tmpData]))

        self.pithosAccounts = [NSMutableArray arrayWithArray:tmpArray];

    else

        self.pithosAccounts = [NSMutableArray array];

    if (![pithosAccounts count]) {

        [pithosAccounts addObject:[PithosAccount pithosAccount]];

        self.pithosAccounts = self.pithosAccounts;

    } else {

        self.activated = YES;

    }

    pithosAccountsDictionary = [[NSMutableDictionary alloc] initWithCapacity:[pithosAccounts count]];

    for (PithosAccount *pithosAccount in pithosAccounts) {

        [pithosAccountsDictionary setObject:pithosAccount forKey:pithosAccount.name];

        if (!currentPithosAccount && pithosAccount.active)

            currentPithosAccount = [pithosAccount retain];

    }

    if (!currentPithosAccount)

        self.currentPithosAccount = [pithosAccounts objectAtIndex:0];

    if (currentPithosAccount.active) {

        [self savePithosAccounts:self];

        [self showPithosBrowser:self];

        self.pithosBrowserController.pithos = currentPithosAccount.pithos;

    } else {

        // XXX maybe call specifically to go to new account tab

        [self showPithosPreferences:self];

    }

    syncTimer = [[NSTimer scheduledTimerWithTimeInterval:syncTimeInterval 

                                                  target:self 

                                                selector:@selector(sync) 

                                                userInfo:nil 

                                                 repeats:YES] retain];

    [syncTimer fire];

}

// Based on: http://cocoatutorial.grapewave.com/2010/01/creating-a-status-bar-application/

// and: http://www.cocoadev.com/index.pl?ThumbnailImages

- (void)awakeFromNib {

    NSImage *sourceImage = [NSImage imageNamed:@"pithos-large.png"];

    NSImage *smallImage = [[[NSImage alloc] initWithSize:NSMakeSize(18, 18)] autorelease];

    [smallImage lockFocus];

    [[NSGraphicsContext currentContext] setImageInterpolation:NSImageInterpolationHigh];

    [sourceImage setSize:NSMakeSize(18, 18)];

    [sourceImage compositeToPoint:NSZeroPoint operation:NSCompositeCopy];

    [smallImage unlockFocus];

    statusItem = [[[NSStatusBar systemStatusBar] statusItemWithLength:NSSquareStatusItemLength] retain];

    [statusItem setMenu:statusMenu];

    [statusItem setImage:sourceImage];

    [statusItem setHighlightMode:YES];

    self.alwaysNo = NO;

}

- (void)handleAppleEvent:(NSAppleEventDescriptor *)event withReplyEvent: (NSAppleEventDescriptor *)replyEvent {

    NSURL *url = [NSURL URLWithString:[[event paramDescriptorForKeyword:keyDirectObject] stringValue]];

    NSString *host = [url host];

	NSString *query = [url query];

    PithosAccount *pithosAccount = [pithosAccountsDictionary objectForKey:[url lastPathComponent]];

    NSProcessInfo *processInfo = [NSProcessInfo processInfo];

    if ([host isEqualToString:[NSString stringWithFormat:@"%@_%d", [processInfo processName], [processInfo processIdentifier]]] && 

        pithosAccount && query) {

        // user=

        NSString *authUser;

        NSRange userRange = [query rangeOfString:@"user=" options:NSCaseInsensitiveSearch];

        if (userRange.length == 0)

            // XXX maybe show an error message?

            return;

        NSUInteger authUserStartLocation = userRange.location + userRange.length;

        NSRange userEndRange = [query rangeOfString:@"&" options:NSCaseInsensitiveSearch 

                                              range:NSMakeRange(authUserStartLocation, [query length] - authUserStartLocation)];

        if (userEndRange.length) {

            authUser = [[query substringWithRange:NSMakeRange(authUserStartLocation, userEndRange.location - authUserStartLocation)]

                        stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];

        } else {

            authUser = [[query substringFromIndex:authUserStartLocation]

                        stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];

        }

        // token=

        NSString *authToken;

        NSRange tokenRange = [query rangeOfString:@"token=" options:NSCaseInsensitiveSearch];

        if (tokenRange.length == 0)

            // XXX maybe show an error message?

            return;

        NSUInteger authTokenStartLocation = tokenRange.location + tokenRange.length;

        NSRange tokenEndRange = [query rangeOfString:@"&" options:NSCaseInsensitiveSearch 

                                              range:NSMakeRange(authTokenStartLocation, [query length] - authTokenStartLocation)];

        if (tokenEndRange.length) {

            authToken = [[query substringWithRange:NSMakeRange(authTokenStartLocation, tokenEndRange.location - authTokenStartLocation)]

                         stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];

        } else {

            authToken = [[query substringFromIndex:authTokenStartLocation]

                         stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];

        }

        NSLog(@"query authUser: '%@', authToken: '%@'", authUser, authToken);

        if ([authUser length] && [authToken length]) {

            [pithosAccount authenticateWithServerURL:nil authUser:authUser authToken:authToken];

            [self savePithosAccounts:self];

            if (self.pithosPreferencesController && [self.pithosPreferencesController.selectedPithosAccount isEqualTo:pithosAccount]) {

                self.pithosPreferencesController.authUser = pithosAccount.authUser;

                self.pithosPreferencesController.authToken = pithosAccount.authToken;

            }

            self.activated = YES;

            if ([pithosAccount isEqualTo:currentPithosAccount]) {

                [self showPithosBrowser:self];

                self.pithosBrowserController.pithos = pithosAccount.pithos;

            }

        }

        // XXX else maybe show an error message?

    }

    // XXX else maybe show an error message?

}

- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender {

    [self savePithosAccounts:self];

    if ([self.pithosBrowserController operationsPending]) {

        NSAlert *alert = [[[NSAlert alloc] init] autorelease];

        [alert setMessageText:@"Pending Operations"];

        [alert setInformativeText:@"There are pending operations in the browser, do you want to quit and cancel them?"];

        [alert addButtonWithTitle:@"OK"];

        [alert addButtonWithTitle:@"Cancel"];

        NSInteger choice = [alert runModal];

        if (choice == NSAlertSecondButtonReturn) 

            return NSTerminateCancel;

    }

    return NSTerminateNow;

}

#pragma mark -

#pragma mark Properties

- (PithosBrowserController *)pithosBrowserController {

    if (!pithosBrowserController) {

        pithosBrowserController = [[PithosBrowserController alloc] init];

    }

    return pithosBrowserController;

}

- (PithosPreferencesController *)pithosPreferencesController {

    if (!pithosPreferencesController) {

        pithosPreferencesController = [[PithosPreferencesController alloc] init];

    }

    return pithosPreferencesController;

}

#pragma mark -

#pragma mark NSMenuDelegate

- (void)menuNeedsUpdate:(NSMenu *)menu {

    NSMenuItem *menuItem;

    [menu removeAllItems];

    if ([menu isEqualTo:accountsMenu]) {

        [menu setAutoenablesItems:NO];

        for (PithosAccount *pithosAccount in pithosAccounts) {

            menuItem = [[[NSMenuItem alloc] initWithTitle:pithosAccount.name 

                                                   action:@selector(menuChangePithosAccount:) 

                                            keyEquivalent:@""] autorelease];

            [menuItem setRepresentedObject:pithosAccount];

            [menuItem setEnabled:pithosAccount.active];

            [menuItem setState:((pithosAccount.active && [currentPithosAccount isEqualTo:pithosAccount]) ? NSOnState : NSOffState)];

            [menu addItem:menuItem];

        }

    } else if ([menu isEqualTo:lastSyncMenu]) {

        NSString *menuItemTitle;

        [menu setAutoenablesItems:NO];

        for (PithosAccount *pithosAccount in pithosAccounts) {

            menuItemTitle = [NSString stringWithFormat:@"%@: %@", 

                             pithosAccount.name, 

                             [[[[LastCompletedSyncTransformer alloc] init] autorelease] transformedValue:pithosAccount.syncLastCompleted]];

            if ([pithosAccount isEqualTo:syncPithosAccount] && [pithosAccount.syncDaemon isSyncing])

                menuItemTitle = [menuItemTitle stringByAppendingString:@" (syncing)"];

//            menuItem = [[[NSMenuItem alloc] initWithTitle:menuItemTitle 

//                                                   action:@selector(menuChangeSyncActive:) 

//                                            keyEquivalent:@""] autorelease];

//            [menuItem setRepresentedObject:pithosAccount];

//            [menuItem setEnabled:pithosAccount.active];

//            [menuItem setState:((pithosAccount.active && pithosAccount.syncActive) ? NSOnState : NSOffState)];

            menuItem = [[[NSMenuItem alloc] initWithTitle:menuItemTitle action:nil keyEquivalent:@""] autorelease];

            [menuItem setEnabled:NO];

            [menuItem setState:NO];

            [menu addItem:menuItem];

        }

        [menu addItem:[NSMenuItem separatorItem]];

        [menu addItem:[[[NSMenuItem alloc] initWithTitle:@"Next Sync" 

                                                  action:@selector(sync) 

                                           keyEquivalent:@""] autorelease]];

    }

}

#pragma mark -

#pragma mark Actions

- (IBAction)showPithosBrowser:(id)sender {

    if (!activated)

        return;

    [self.pithosBrowserController showWindow:sender];

    [[self.pithosBrowserController window] makeKeyAndOrderFront:sender];

    [NSApp activateIgnoringOtherApps:YES];

}

- (IBAction)showPithosPreferences:(id)sender {

    [self.pithosPreferencesController showWindow:sender];

    [[self.pithosPreferencesController window] makeKeyAndOrderFront:sender];

    [NSApp activateIgnoringOtherApps:YES];

}

- (void)sync {

    if (!activated || ![pithosAccounts count])

        return;

    NSUInteger syncIndex;

    BOOL syncPithosAccountFound = [pithosAccounts containsObject:syncPithosAccount];

    if (syncPithosAccountFound)

         syncIndex = [pithosAccounts indexOfObject:syncPithosAccount];

    PithosAccount *singleSyncPithosAccount = nil;

    for (PithosAccount *pithosAccount in pithosAccounts) {

        if (!singleSyncPithosAccount && pithosAccount.active && pithosAccount.syncActive && pithosAccount.syncDaemon) {

            singleSyncPithosAccount = pithosAccount;

        } else if (singleSyncPithosAccount && pithosAccount.active && pithosAccount.syncActive && pithosAccount.syncDaemon) {

            singleSyncPithosAccount = nil;

            break;

        }

    }

    if (syncPithosAccount && syncPithosAccount.active && syncPithosAccount.syncActive && syncPithosAccount.syncDaemon) {

        // An active syncDaemon was previously syncing

        if (singleSyncPithosAccount && [singleSyncPithosAccount isEqualTo:syncPithosAccount]) {

            // It's the only one, sync again

            [syncPithosAccount.syncDaemon startDaemon];

            [syncPithosAccount.syncDaemon sync];

            return;

        } else if ([syncPithosAccount.syncDaemon isSyncing]) {

            // It's still syncing, mark it as late and return

            [syncPithosAccount.syncDaemon syncLate];

            return;

        }

    }

    PithosAccount *newSyncPithosAccount = nil;

    if (syncPithosAccountFound) {

        for (PithosAccount *pithosAccount in [pithosAccounts objectsAtIndexes:[NSIndexSet indexSetWithIndexesInRange:NSMakeRange(syncIndex + 1, [pithosAccounts count] - syncIndex - 1)]]) {

            if (pithosAccount.active && pithosAccount.syncActive && pithosAccount.syncDaemon) {

                newSyncPithosAccount = pithosAccount;

                break;

            }

        }

        if (!newSyncPithosAccount) {

            for (PithosAccount *pithosAccount in [pithosAccounts objectsAtIndexes:[NSIndexSet indexSetWithIndexesInRange:NSMakeRange(0, syncIndex)]]) {

                if (pithosAccount.active && pithosAccount.syncActive && pithosAccount.syncDaemon) {

                    newSyncPithosAccount = pithosAccount;

                    break;

                }

            }

        }

    } else {

        for (PithosAccount *pithosAccount in pithosAccounts) {

            if (pithosAccount.active && pithosAccount.syncActive && pithosAccount.syncDaemon) {

                newSyncPithosAccount = pithosAccount;

                break;

            }

        }

    }        

    if (newSyncPithosAccount) {

        // A different syncDaemon is found, sync it

        self.syncPithosAccount = newSyncPithosAccount;

        [syncPithosAccount.syncDaemon startDaemon];

        [syncPithosAccount.syncDaemon sync];

    } else if (syncPithosAccountFound && syncPithosAccount && syncPithosAccount.active && syncPithosAccount.syncActive && syncPithosAccount.syncDaemon) {

        [syncPithosAccount.syncDaemon startDaemon];

        [syncPithosAccount.syncDaemon sync];

    } else {

        self.syncPithosAccount = nil;

    }

}

- (void)savePithosAccounts:(id)sender {

    [userDefaults setObject:[NSKeyedArchiver archivedDataWithRootObject:pithosAccounts] forKey:@"pithosAccounts"];

    [userDefaults synchronize];

}

- (void)removedPithosAccount:(PithosAccount *)removedPithosAccount {

    if ([self.currentPithosAccount isEqualTo:removedPithosAccount]) {

        for (PithosAccount *pithosAccount in pithosAccounts) {

            if (pithosAccount.active) {

                self.currentPithosAccount = pithosAccount;

                self.pithosBrowserController.pithos = currentPithosAccount.pithos;

                break;

            }

        }

        if ([self.currentPithosAccount isEqualTo:removedPithosAccount]) {

            self.activated = NO;

            [self.pithosBrowserController.window close];

            [self.pithosBrowserController resetBrowser];

            self.currentPithosAccount = [pithosAccounts objectAtIndex:0];

        }

    }

    if ([self.syncPithosAccount isEqualTo:removedPithosAccount])

        self.syncPithosAccount = nil;

}

#pragma mark -

#pragma mark Menu Actions

- (void)menuChangePithosAccount:(NSMenuItem *)sender {

    PithosAccount *pithosAccount = (PithosAccount *)[sender representedObject];

    if (!pithosAccount.active)

        return;

    if (![currentPithosAccount isEqualTo:pithosAccount] && [pithosAccounts containsObject:pithosAccount]) {

        if ([self.pithosBrowserController operationsPending]) {

            NSAlert *alert = [[[NSAlert alloc] init] autorelease];

            [alert setMessageText:@"Pending Operations"];

            [alert setInformativeText:@"There are pending operations in the browser, do you want to change accounts and cancel them?"];

            [alert addButtonWithTitle:@"OK"];

            [alert addButtonWithTitle:@"Cancel"];

            NSInteger choice = [alert runModal];

            if (choice == NSAlertSecondButtonReturn) 

                return;

        }

        self.currentPithosAccount = pithosAccount;

        [self showPithosBrowser:self];

        self.pithosBrowserController.pithos = currentPithosAccount.pithos;

    }

}

//- (void)menuChangeSyncActive:(NSMenuItem *)sender {

//    PithosAccount *pithosAccount = (PithosAccount *)[sender representedObject];

//    if (!pithosAccount.active)

//        return;

//    pithosAccount.syncActive = !pithosAccount.syncActive;

//    if (self.pithosPreferencesController && [self.pithosPreferencesController.selectedPithosAccount isEqualTo:pithosAccount])

//        self.pithosPreferencesController.syncActive = pithosAccount.syncActive;

//    [self savePithosAccounts:self];

//}

@end