//

//  GrowlApplicationBridge.m

//  Growl

//

//  Created by Evan Schoenberg on Wed Jun 16 2004.

//  Copyright 2004-2006 The Growl Project. All rights reserved.

//

#import "GrowlApplicationBridge.h"

#ifdef GROWL_WITH_INSTALLER

#import "GrowlInstallationPrompt.h"

#import "GrowlVersionUtilities.h"

#endif

#include "CFGrowlAdditions.h"

#include "CFURLAdditions.h"

#include "CFMutableDictionaryAdditions.h"

#import "GrowlDefinesInternal.h"

#import "GrowlPathUtilities.h"

#import "GrowlPathway.h"

#import <ApplicationServices/ApplicationServices.h>

/*!

 * The 10.3+ exception handling can only work if -fobjc-exceptions is enabled

 */

#if 0

	#if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_3

	# define TRY		@try {

	# define ENDTRY		}

	# define CATCH		@catch(NSException *localException) {

	# define ENDCATCH	}

	#else

	# define TRY		NS_DURING

	# define ENDTRY

	# define CATCH		NS_HANDLER

	# define ENDCATCH	NS_ENDHANDLER

	#endif

#else

	# define TRY		NS_DURING

	# define ENDTRY

	# define CATCH		NS_HANDLER

	# define ENDCATCH	NS_ENDHANDLER

#endif

@interface GrowlApplicationBridge (PRIVATE)

/*!

 *	@method launchGrowlIfInstalled

 *	@abstract Launches GrowlHelperApp.

 *	@discussion Launches the GrowlHelperApp if it's not already running.

 *	 GROWL_IS_READY will be posted to the distributed notification center

 *	 once it is ready.

 *

 *	 Uses <code>+_launchGrowlIfInstalledWithRegistrationDictionary:</code>.

 *	@result Returns YES if GrowlHelperApp began launching or was already running, NO if Growl isn't installed

 */

+ (BOOL) launchGrowlIfInstalled;

/*!

 *	@method _launchGrowlIfInstalledWithRegistrationDictionary:

 *	@abstract Launches GrowlHelperApp and registers.

 *	@discussion Launches the GrowlHelperApp if it's not already running, and passes it a registration dictionary.

 *	 If Growl is turned on in the Growl prefpane, GROWL_IS_READY will be posted

 *	 to the distributed notification center when Growl is listening for

 *	 notifications.

 *	@param regDict The dictionary with which to register.

 *	@result Returns YES if GrowlHelperApp began launching or was already running, NO if Growl isn't installed

 */

+ (BOOL) _launchGrowlIfInstalledWithRegistrationDictionary:(NSDictionary *)regDict;

#ifdef GROWL_WITH_INSTALLER

+ (void) _checkForPackagedUpdateForGrowlPrefPaneBundle:(NSBundle *)growlPrefPaneBundle;

#endif

/*!	@method	_applicationNameForGrowlSearchingRegistrationDictionary:

 *	@abstract Obtain the name of the current application.

 *	@param regDict	The dictionary to search, or <code>nil</code> not to.

 *	@result	The name of the current application.

 *	@discussion	Does not call +bestRegistrationDictionary, and is therefore safe to call from it.

 */

+ (NSString *) _applicationNameForGrowlSearchingRegistrationDictionary:(NSDictionary *)regDict;

/*!	@method	_applicationNameForGrowlSearchingRegistrationDictionary:

 *	@abstract Obtain the icon of the current application.

 *	@param regDict	The dictionary to search, or <code>nil</code> not to.

 *	@result	The icon of the current application, in IconFamily format (same as is used in 'icns' resources and .icns files).

 *	@discussion	Does not call +bestRegistrationDictionary, and is therefore safe to call from it.

 */

+ (NSData *) _applicationIconDataForGrowlSearchingRegistrationDictionary:(NSDictionary *)regDict;

/*! @method growlProxy

 *  @abstract Obtain (creating a connection if needed) a proxy to the Growl Helper Application

 */

+ (NSProxy<GrowlNotificationProtocol> *) growlProxy;

@end

static NSDictionary *cachedRegistrationDictionary = nil;

static NSString	*appName = nil;

static NSData	*appIconData = nil;

static id		delegate = nil;

static BOOL		growlLaunched = NO;

static NSProxy<GrowlNotificationProtocol> *growlProxy = nil;

#ifdef GROWL_WITH_INSTALLER

static NSMutableArray	*queuedGrowlNotifications = nil;

static BOOL				userChoseNotToInstallGrowl = NO;

static BOOL				promptedToInstallGrowl = NO;

static BOOL				promptedToUpgradeGrowl = NO;

#endif

//used primarily by GIP, but could be useful elsewhere.

static BOOL		registerWhenGrowlIsReady = NO;

#pragma mark -

@implementation GrowlApplicationBridge

+ (void) setGrowlDelegate:(NSObject<GrowlApplicationBridgeDelegate> *)inDelegate {

	NSDistributedNotificationCenter *NSDNC = [NSDistributedNotificationCenter defaultCenter];

	if (inDelegate != delegate) {

		[delegate release];

		delegate = [inDelegate retain];

	}

	[cachedRegistrationDictionary release];

	cachedRegistrationDictionary = [[self bestRegistrationDictionary] retain];

	//Cache the appName from the delegate or the process name

	[appName autorelease];

	appName = [[self _applicationNameForGrowlSearchingRegistrationDictionary:cachedRegistrationDictionary] retain];

	if (!appName) {

		NSLog(@"%@", @"GrowlApplicationBridge: Cannot register because the application name was not supplied and could not be determined");

		return;

	}

	/* Cache the appIconData from the delegate if it responds to the

	 * applicationIconDataForGrowl selector, or the application if not

	 */

	[appIconData autorelease];

	appIconData = [[self _applicationIconDataForGrowlSearchingRegistrationDictionary:cachedRegistrationDictionary] retain];

	//Add the observer for GROWL_IS_READY which will be triggered later if all goes well

	[NSDNC addObserver:self

			  selector:@selector(_growlIsReady:)

				  name:GROWL_IS_READY

				object:nil];

	/* Watch for notification clicks if our delegate responds to the

	 * growlNotificationWasClicked: selector. Notifications will come in on a

	 * unique notification name based on our app name, pid and

	 * GROWL_NOTIFICATION_CLICKED.

	 */

	int pid = [[NSProcessInfo processInfo] processIdentifier];

	NSString *growlNotificationClickedName = [[NSString alloc] initWithFormat:@"%@-%d-%@",

		appName, pid, GROWL_NOTIFICATION_CLICKED];

	if ([delegate respondsToSelector:@selector(growlNotificationWasClicked:)])

		[NSDNC addObserver:self

				  selector:@selector(growlNotificationWasClicked:)

					  name:growlNotificationClickedName

					object:nil];

	else

		[NSDNC removeObserver:self

						 name:growlNotificationClickedName

					   object:nil];

	[growlNotificationClickedName release];

	NSString *growlNotificationTimedOutName = [[NSString alloc] initWithFormat:@"%@-%d-%@",

		appName, pid, GROWL_NOTIFICATION_TIMED_OUT];

	if ([delegate respondsToSelector:@selector(growlNotificationTimedOut:)])

		[NSDNC addObserver:self

				  selector:@selector(growlNotificationTimedOut:)

					  name:growlNotificationTimedOutName

					object:nil];

	else

		[NSDNC removeObserver:self

						 name:growlNotificationTimedOutName

					   object:nil];

	[growlNotificationTimedOutName release];

#ifdef GROWL_WITH_INSTALLER

	//Determine if the user has previously told us not to ever request installation again

	userChoseNotToInstallGrowl = [[NSUserDefaults standardUserDefaults] boolForKey:@"Growl Installation:Do Not Prompt Again"];

#endif

	growlLaunched = [self _launchGrowlIfInstalledWithRegistrationDictionary:cachedRegistrationDictionary];

}

+ (NSObject<GrowlApplicationBridgeDelegate> *) growlDelegate {

	return delegate;

}

#pragma mark -

+ (void) notifyWithTitle:(NSString *)title

			 description:(NSString *)description

		notificationName:(NSString *)notifName

				iconData:(NSData *)iconData

				priority:(int)priority

				isSticky:(BOOL)isSticky

			clickContext:(id)clickContext

{

	[GrowlApplicationBridge notifyWithTitle:title

								description:description

						   notificationName:notifName

								   iconData:iconData

								   priority:priority

								   isSticky:isSticky

							   clickContext:clickContext

								 identifier:nil];

}

/* Send a notification to Growl for display.

 * title, description, and notifName are required.

 * All other id parameters may be nil to accept defaults.

 * priority is 0 by default; isSticky is NO by default.

 */

+ (void) notifyWithTitle:(NSString *)title

			 description:(NSString *)description

		notificationName:(NSString *)notifName

				iconData:(NSData *)iconData

				priority:(int)priority

				isSticky:(BOOL)isSticky

			clickContext:(id)clickContext

			  identifier:(NSString *)identifier

{

	NSParameterAssert(notifName);	//Notification name is required.

	NSParameterAssert(title || description);	//At least one of title or description is required.

	// Build our noteDict from all passed parameters

	NSMutableDictionary *noteDict = [[NSMutableDictionary alloc] initWithObjectsAndKeys:

		notifName,	 GROWL_NOTIFICATION_NAME,

		nil];

	if (title)			setObjectForKey(noteDict, GROWL_NOTIFICATION_TITLE, title);

	if (description)	setObjectForKey(noteDict, GROWL_NOTIFICATION_DESCRIPTION, description);

	if (iconData)		setObjectForKey(noteDict, GROWL_NOTIFICATION_ICON, iconData);

	if (clickContext)	setObjectForKey(noteDict, GROWL_NOTIFICATION_CLICK_CONTEXT, clickContext);

	if (priority)		setIntegerForKey(noteDict, GROWL_NOTIFICATION_PRIORITY, priority);

	if (isSticky)		setBooleanForKey(noteDict, GROWL_NOTIFICATION_STICKY, isSticky);

	if (identifier)		setObjectForKey(noteDict, GROWL_NOTIFICATION_IDENTIFIER, identifier);

	[self notifyWithDictionary:noteDict];

	[noteDict release];

}

+ (void) notifyWithDictionary:(NSDictionary *)userInfo {

	//post it.

	if (growlLaunched) {		

		NSProxy<GrowlNotificationProtocol> *currentGrowlProxy = [self growlProxy];

		//Make sure we have everything that we need (that we can retrieve from the registration dictionary).

		userInfo = [self notificationDictionaryByFillingInDictionary:userInfo];

		if (currentGrowlProxy) {

			//Post to Growl via GrowlApplicationBridgePathway

			TRY

				[currentGrowlProxy postNotificationWithDictionary:userInfo];

			ENDTRY

			CATCH

				NSLog(@"GrowlApplicationBridge: exception while sending notification: %@", localException);

			ENDCATCH

		} else {

			//NSLog(@"GrowlApplicationBridge: could not find local GrowlApplicationBridgePathway, falling back to NSDistributedNotificationCenter");

			//DNC needs a plist. this means we must pass data, not an NSImage.

			Class     NSImageClass = [NSImage class];

			NSImage          *icon = [userInfo objectForKey:GROWL_NOTIFICATION_ICON];

			NSImage       *appIcon = [userInfo objectForKey:GROWL_NOTIFICATION_APP_ICON];

			BOOL       iconIsImage =    icon &&    [icon isKindOfClass:NSImageClass];

			BOOL    appIconIsImage = appIcon && [appIcon isKindOfClass:NSImageClass];

			if (iconIsImage || appIconIsImage) {

				NSMutableDictionary *mUserInfo = [userInfo mutableCopy];

				//notification icon.

				if (iconIsImage)

					[mUserInfo setObject:[icon TIFFRepresentation] forKey:GROWL_NOTIFICATION_ICON];

				//per-notification application icon.

				if (appIconIsImage)

					[mUserInfo setObject:[appIcon TIFFRepresentation] forKey:GROWL_NOTIFICATION_APP_ICON];

				userInfo = [mUserInfo autorelease];

			}

			//Post to Growl via NSDistributedNotificationCenter

			[[NSDistributedNotificationCenter defaultCenter] postNotificationName:GROWL_NOTIFICATION

																		   object:nil

																		 userInfo:userInfo

															   deliverImmediately:NO];

		}

	} else {

#ifdef GROWL_WITH_INSTALLER

		/*if Growl launches, and the user hasn't already said NO to installing

		 *	it, store this notification for posting

		 */

		if (!userChoseNotToInstallGrowl) {

			if (!queuedGrowlNotifications)

				queuedGrowlNotifications = [[NSMutableArray alloc] init];

			[queuedGrowlNotifications addObject:userInfo];

			//if we have not already asked the user to install Growl, do it now

			if (!promptedToInstallGrowl) {

				[GrowlInstallationPrompt showInstallationPrompt];

				promptedToInstallGrowl = YES;

			}

		}

#endif

	}

}

#pragma mark -

+ (BOOL) isGrowlInstalled {

	return ([GrowlPathUtilities growlPrefPaneBundle] != nil);

}

+ (BOOL) isGrowlRunning {

	BOOL growlIsRunning = NO;

	ProcessSerialNumber PSN = { kNoProcess, kNoProcess };

	while (GetNextProcess(&PSN) == noErr) {

		CFDictionaryRef infoDict = ProcessInformationCopyDictionary(&PSN, kProcessDictionaryIncludeAllInformationMask);

		CFStringRef bundleId = CFDictionaryGetValue(infoDict, kCFBundleIdentifierKey);

		if (bundleId && CFStringCompare(bundleId, CFSTR("com.Growl.GrowlHelperApp"), 0) == kCFCompareEqualTo) {

			growlIsRunning = YES;

			CFRelease(infoDict);

			break;

		}

		CFRelease(infoDict);

	}

	return growlIsRunning;

}

+ (void) displayInstallationPromptIfNeeded {

#ifdef GROWL_WITH_INSTALLER

    //if we have not already asked the user to install Growl, do it now

    if (!promptedToInstallGrowl) {

        [GrowlInstallationPrompt showInstallationPrompt];

        promptedToInstallGrowl = YES;

    }

#endif

}

#pragma mark -

+ (BOOL) registerWithDictionary:(NSDictionary *)regDict {

	if (regDict)

		regDict = [self registrationDictionaryByFillingInDictionary:regDict];

	else

		regDict = [self bestRegistrationDictionary];

	[cachedRegistrationDictionary release];

	cachedRegistrationDictionary = [regDict retain];

	return [self _launchGrowlIfInstalledWithRegistrationDictionary:regDict];

}

+ (void) reregisterGrowlNotifications {

	[self registerWithDictionary:nil];

}

+ (void) setWillRegisterWhenGrowlIsReady:(BOOL)flag {

	registerWhenGrowlIsReady = flag;

}

+ (BOOL) willRegisterWhenGrowlIsReady {

	return registerWhenGrowlIsReady;

}

#pragma mark -

+ (NSDictionary *) registrationDictionaryFromDelegate {

	NSDictionary *regDict = nil;

	if (delegate && [delegate respondsToSelector:@selector(registrationDictionaryForGrowl)])

		regDict = [delegate registrationDictionaryForGrowl];

	return regDict;

}

+ (NSDictionary *) registrationDictionaryFromBundle:(NSBundle *)bundle {

	if (!bundle) bundle = [NSBundle mainBundle];

	NSDictionary *regDict = nil;

	NSString *regDictPath = [bundle pathForResource:@"Growl Registration Ticket" ofType:GROWL_REG_DICT_EXTENSION];

	if (regDictPath) {

		regDict = [NSDictionary dictionaryWithContentsOfFile:regDictPath];

		if (!regDict)

			NSLog(@"GrowlApplicationBridge: The bundle at %@ contains a registration dictionary, but it is not a valid property list. Please tell this application's developer.", [bundle bundlePath]);

	}

	return regDict;

}

+ (NSDictionary *) bestRegistrationDictionary {

	NSDictionary *registrationDictionary = [self registrationDictionaryFromDelegate];

	if (!registrationDictionary) {

		registrationDictionary = [self registrationDictionaryFromBundle:nil];

		if (!registrationDictionary)

			NSLog(@"GrowlApplicationBridge: The Growl delegate did not supply a registration dictionary, and the app bundle at %@ does not have one. Please tell this application's developer.", [[NSBundle mainBundle] bundlePath]);

	}

	return [self registrationDictionaryByFillingInDictionary:registrationDictionary];

}

#pragma mark -

+ (NSDictionary *) registrationDictionaryByFillingInDictionary:(NSDictionary *)regDict {

	return [self registrationDictionaryByFillingInDictionary:regDict restrictToKeys:nil];

}

+ (NSDictionary *) registrationDictionaryByFillingInDictionary:(NSDictionary *)regDict restrictToKeys:(NSSet *)keys {

	if (!regDict) return nil;

	NSMutableDictionary *mRegDict = [regDict mutableCopy];

	if ((!keys) || [keys containsObject:GROWL_APP_NAME]) {

		if (![mRegDict objectForKey:GROWL_APP_NAME]) {

			if (!appName)

				appName = [[self _applicationNameForGrowlSearchingRegistrationDictionary:regDict] retain];

			[mRegDict setObject:appName

			             forKey:GROWL_APP_NAME];

		}

	}

	if ((!keys) || [keys containsObject:GROWL_APP_ICON]) {

		if (![mRegDict objectForKey:GROWL_APP_ICON]) {

			if (!appIconData)

				appIconData = [[self _applicationIconDataForGrowlSearchingRegistrationDictionary:regDict] retain];

			if (appIconData)

				[mRegDict setObject:appIconData forKey:GROWL_APP_ICON];

		}

	}

	if ((!keys) || [keys containsObject:GROWL_APP_LOCATION]) {

		if (![mRegDict objectForKey:GROWL_APP_LOCATION]) {

			NSURL *myURL = copyCurrentProcessURL();

			if (myURL) {

				NSDictionary *file_data = createDockDescriptionWithURL(myURL);

				if (file_data) {

					NSDictionary *location = [[NSDictionary alloc] initWithObjectsAndKeys:file_data, @"file-data", nil];

					[file_data release];

					[mRegDict setObject:location forKey:GROWL_APP_LOCATION];

					[location release];

				} else {

					[mRegDict removeObjectForKey:GROWL_APP_LOCATION];

				}

				[myURL release];

			}

		}

	}

	if ((!keys) || [keys containsObject:GROWL_NOTIFICATIONS_DEFAULT]) {

		if (![mRegDict objectForKey:GROWL_NOTIFICATIONS_DEFAULT]) {

			NSArray *all = [mRegDict objectForKey:GROWL_NOTIFICATIONS_ALL];

			if (all)

				[mRegDict setObject:all forKey:GROWL_NOTIFICATIONS_DEFAULT];

		}

	}

	if ((!keys) || [keys containsObject:GROWL_APP_ID])

		if (![mRegDict objectForKey:GROWL_APP_ID])

			[mRegDict setObject:(NSString *)CFBundleGetIdentifier(CFBundleGetMainBundle()) forKey:GROWL_APP_ID];

	return [mRegDict autorelease];

}

+ (NSDictionary *) notificationDictionaryByFillingInDictionary:(NSDictionary *)notifDict {

	NSMutableDictionary *mNotifDict = [notifDict mutableCopy];

	if (![mNotifDict objectForKey:GROWL_APP_NAME]) {

		if (!appName)

			appName = [[self _applicationNameForGrowlSearchingRegistrationDictionary:cachedRegistrationDictionary] retain];

		if (appName) {

			[mNotifDict setObject:appName

			               forKey:GROWL_APP_NAME];

		}

	}

	if (![mNotifDict objectForKey:GROWL_APP_ICON]) {

		if (!appIconData)

			appIconData = [[self _applicationIconDataForGrowlSearchingRegistrationDictionary:cachedRegistrationDictionary] retain];

		if (appIconData) {

			[mNotifDict setObject:appIconData

			               forKey:GROWL_APP_ICON];

		}

	}

	//Only include the PID when there's a click context. We do this because NSDNC imposes a 15-MiB limit on the serialized notification, and we wouldn't want to overrun it because of a 4-byte PID.

	if ([mNotifDict objectForKey:GROWL_NOTIFICATION_CLICK_CONTEXT] && ![mNotifDict objectForKey:GROWL_APP_PID]) {

		NSNumber *pidNum = [[NSNumber alloc] initWithInt:[[NSProcessInfo processInfo] processIdentifier]];

		[mNotifDict setObject:pidNum

		               forKey:GROWL_APP_PID];

		[pidNum release];

	}

	return [mNotifDict autorelease];

}

+ (NSDictionary *) frameworkInfoDictionary {

#ifdef GROWL_WITH_INSTALLER

	return (NSDictionary *)CFBundleGetInfoDictionary(CFBundleGetBundleWithIdentifier(CFSTR("com.growl.growlwithinstallerframework")));

#else

	return (NSDictionary *)CFBundleGetInfoDictionary(CFBundleGetBundleWithIdentifier(CFSTR("com.growl.growlframework")));

#endif

}

#pragma mark -

#pragma mark Private methods

+ (NSString *) _applicationNameForGrowlSearchingRegistrationDictionary:(NSDictionary *)regDict {

	NSString *applicationNameForGrowl = nil;

	if (delegate && [delegate respondsToSelector:@selector(applicationNameForGrowl)])

		applicationNameForGrowl = [delegate applicationNameForGrowl];

	if (!applicationNameForGrowl) {

		applicationNameForGrowl = [regDict objectForKey:GROWL_APP_NAME];

		if (!applicationNameForGrowl)

			applicationNameForGrowl = [[NSProcessInfo processInfo] processName];

	}

	return applicationNameForGrowl;

}

+ (NSData *) _applicationIconDataForGrowlSearchingRegistrationDictionary:(NSDictionary *)regDict {

	NSData *iconData = nil;

	if (delegate) {

		if ([delegate respondsToSelector:@selector(applicationIconForGrowl)])

			iconData = (NSData *)[delegate applicationIconForGrowl];

		else if ([delegate respondsToSelector:@selector(applicationIconDataForGrowl)])

			iconData = [delegate applicationIconDataForGrowl];

	}

	if (!iconData)

		iconData = [regDict objectForKey:GROWL_APP_ICON];

	if (iconData && [iconData isKindOfClass:[NSImage class]])

		iconData = [(NSImage *)iconData TIFFRepresentation];

	if (!iconData) {

		NSURL *URL = copyCurrentProcessURL();

		iconData = [copyIconDataForURL(URL) autorelease];

		[URL release];

	}

	return iconData;

}

/*Selector called when a growl notification is clicked.  This should never be

 *	called manually, and the calling observer should only be registered if the

 *	delegate responds to growlNotificationWasClicked:.

 */

+ (void) growlNotificationWasClicked:(NSNotification *)notification {

	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

	[delegate growlNotificationWasClicked:

		[[notification userInfo] objectForKey:GROWL_KEY_CLICKED_CONTEXT]];

	[pool drain];

}

+ (void) growlNotificationTimedOut:(NSNotification *)notification {

	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

	[delegate growlNotificationTimedOut:

		[[notification userInfo] objectForKey:GROWL_KEY_CLICKED_CONTEXT]];

	[pool drain];

}

#pragma mark -

//When a connection dies, release our reference to its proxy

+ (void) connectionDidDie:(NSNotification *)notification {

	[[NSNotificationCenter defaultCenter] removeObserver:self

													name:NSConnectionDidDieNotification

												  object:[notification object]];

	[growlProxy release]; growlProxy = nil;

}

+ (NSProxy<GrowlNotificationProtocol> *) growlProxy {

	if (!growlProxy) {

		NSConnection *connection = [NSConnection connectionWithRegisteredName:@"GrowlApplicationBridgePathway" host:nil];

		if (connection) {

			[[NSNotificationCenter defaultCenter] addObserver:self

													 selector:@selector(connectionDidDie:)

														 name:NSConnectionDidDieNotification

													   object:connection];

			TRY

			{

				NSDistantObject *theProxy = [connection rootProxy];

				if ([theProxy respondsToSelector:@selector(registerApplicationWithDictionary:)]) {

					[theProxy setProtocolForProxy:@protocol(GrowlNotificationProtocol)];

					growlProxy = [(NSProxy<GrowlNotificationProtocol> *)theProxy retain];

				} else {

					NSLog(@"Received a fake GrowlApplicationBridgePathway object. Some other application is interfering with Growl, or something went horribly wrong. Please file a bug report.");

					growlProxy = nil;

				}

			}

			ENDTRY

				CATCH

			{

				NSLog(@"GrowlApplicationBridge: exception while sending notification: %@", localException);

				growlProxy = nil;

			}

			ENDCATCH

		}

	}

	return growlProxy;

}

+ (void) _growlIsReady:(NSNotification *)notification {

#pragma unused(notification)

	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

	//Growl has now launched; we may get here with (growlLaunched == NO) when the user first installs

	growlLaunched = YES;

	//Inform our delegate if it is interested

	if ([delegate respondsToSelector:@selector(growlIsReady)])

		[delegate growlIsReady];

	//Post a notification locally

	[[NSNotificationCenter defaultCenter] postNotificationName:GROWL_IS_READY

														object:nil

													  userInfo:nil];

	//Stop observing for GROWL_IS_READY

	[[NSDistributedNotificationCenter defaultCenter] removeObserver:self

															   name:GROWL_IS_READY

															 object:nil];

	//register (fixes #102: this is necessary if we got here by Growl having just been installed)

	if (registerWhenGrowlIsReady) {

		[self reregisterGrowlNotifications];

		registerWhenGrowlIsReady = NO;

	}

#ifdef GROWL_WITH_INSTALLER

	//Perform any queued notifications

	NSEnumerator *enumerator = [queuedGrowlNotifications objectEnumerator];

	NSDictionary *noteDict;

	//Configure the growl proxy if it isn't currently configured

	NSProxy<GrowlNotificationProtocol> *currentGrowlProxy = [self growlProxy];

	while ((noteDict = [enumerator nextObject])) {		

		if (currentGrowlProxy) {

			//Post to Growl via GrowlApplicationBridgePathway

			NS_DURING

				[currentGrowlProxy postNotificationWithDictionary:noteDict];

			NS_HANDLER

				NSLog(@"GrowlApplicationBridge: exception while sending notification: %@", localException);

			NS_ENDHANDLER

		} else {

			//Post to Growl via NSDistributedNotificationCenter

			NSLog(@"GrowlApplicationBridge: could not find local GrowlApplicationBridgePathway, falling back to NSDistributedNotificationCenter");

			[[NSDistributedNotificationCenter defaultCenter] postNotificationName:GROWL_NOTIFICATION

																		   object:NULL

																		 userInfo:noteDict

															   deliverImmediately:FALSE];

		}

	}

	[queuedGrowlNotifications release]; queuedGrowlNotifications = nil;

#endif

	[pool drain];

}

#ifdef GROWL_WITH_INSTALLER

/*Sent to us by GrowlInstallationPrompt if the user clicks Cancel so we can

 *	avoid prompting again this session (or ever if they checked Don't Ask Again)

 */

+ (void) _userChoseNotToInstallGrowl {

	//Note the user's action so we stop queueing notifications, etc.

	userChoseNotToInstallGrowl = YES;

	//Clear our queued notifications; we won't be needing them

	[queuedGrowlNotifications release]; queuedGrowlNotifications = nil;

}

// Check against our current version number and ensure the installed Growl pane is the same or later

+ (void) _checkForPackagedUpdateForGrowlPrefPaneBundle:(NSBundle *)growlPrefPaneBundle {

	NSString *ourGrowlPrefPaneInfoPath;

	NSDictionary *infoDictionary;

	NSString *packagedVersion, *installedVersion;

	BOOL upgradeIsAvailable;

	ourGrowlPrefPaneInfoPath = [[NSBundle bundleWithIdentifier:@"com.growl.growlwithinstallerframework"] pathForResource:@"GrowlPrefPaneInfo"

																												  ofType:@"plist"];

	NSObject *infoPropertyList = createPropertyListFromURL([NSURL fileURLWithPath:ourGrowlPrefPaneInfoPath],

														   kCFPropertyListImmutable,

														   /* outFormat */ NULL, /* outErrorString */ NULL);

	NSDictionary *infoDict = ([infoPropertyList isKindOfClass:[NSDictionary class]] ? (NSDictionary *)infoPropertyList : nil);

	packagedVersion = [infoDict objectForKey:(NSString *)kCFBundleVersionKey];

	infoDictionary = [growlPrefPaneBundle infoDictionary];

	installedVersion = [infoDictionary objectForKey:(NSString *)kCFBundleVersionKey];

	//If the installed version is earlier than our packaged version, we can offer an upgrade.

	upgradeIsAvailable = (compareVersionStringsTranslating1_0To0_5(packagedVersion, installedVersion) == kCFCompareGreaterThan);

	if (upgradeIsAvailable && !promptedToUpgradeGrowl) {

		NSString	*lastDoNotPromptVersion = [[NSUserDefaults standardUserDefaults] objectForKey:@"Growl Update:Do Not Prompt Again:Last Version"];

		if (!lastDoNotPromptVersion ||

			(compareVersionStringsTranslating1_0To0_5(packagedVersion, lastDoNotPromptVersion) == kCFCompareGreaterThan))

		{

			[GrowlInstallationPrompt showUpdatePromptForVersion:packagedVersion];

			promptedToUpgradeGrowl = YES;

		}

	}

	[infoDict release];

}

#endif

#pragma mark -

+ (BOOL) _launchGrowlIfInstalledWithRegistrationDictionary:(NSDictionary *)regDict {

	BOOL success = NO;

	NSBundle *growlPrefPaneBundle;

	NSString *growlHelperAppPath;

#ifdef DEBUG

	//For a debug build, first look for a running GHA. It might not actually be within a Growl prefpane bundle.

	growlHelperAppPath = [[GrowlPathUtilities runningHelperAppBundle] bundlePath];

	if (!growlHelperAppPath) {

		growlPrefPaneBundle = [GrowlPathUtilities growlPrefPaneBundle];

		growlHelperAppPath = [growlPrefPaneBundle pathForResource:@"GrowlHelperApp"

														   ofType:@"app"];

	}

	NSLog(@"Will use GrowlHelperApp at %@", growlHelperAppPath);

#else

	growlPrefPaneBundle = [GrowlPathUtilities growlPrefPaneBundle];

	growlHelperAppPath = [growlPrefPaneBundle pathForResource:@"GrowlHelperApp"

													   ofType:@"app"];

#endif

#ifdef GROWL_WITH_INSTALLER

	if (growlPrefPaneBundle) {

		/* Check against our current version number and ensure the installed Growl pane is the same or later */

		[self _checkForPackagedUpdateForGrowlPrefPaneBundle:growlPrefPaneBundle];

	}

#endif

	//Houston, we are go for launch.

	if (growlHelperAppPath) {

		//Let's launch in the background (requires sending the Apple Event ourselves, as LS may activate the application anyway if it's already running)

		NSURL *appURL = [NSURL fileURLWithPath:growlHelperAppPath];

		if (appURL) {

			OSStatus err;

			//Find the PSN for GrowlHelperApp. (We'll need this later.)

			struct ProcessSerialNumber appPSN = {

				0, kNoProcess

			};

			while ((err = GetNextProcess(&appPSN)) == noErr) {

				NSDictionary *dict = [(id)ProcessInformationCopyDictionary(&appPSN, kProcessDictionaryIncludeAllInformationMask) autorelease];

				NSString *bundlePath = [dict objectForKey:@"BundlePath"];

				if ([bundlePath isEqualToString:growlHelperAppPath]) {

					//Match!

					break;

				}

			}

			if (err == noErr) {

				NSURL *regItemURL = nil;

				BOOL passRegDict = NO;

				if (regDict) {

					NSString *regDictFileName;

					NSString *regDictPath;

					//Obtain a truly unique file name

					CFUUIDRef uuid = CFUUIDCreate(kCFAllocatorDefault);

					CFStringRef uuidString = CFUUIDCreateString(kCFAllocatorDefault, uuid);

					CFRelease(uuid);

					regDictFileName = [[NSString stringWithFormat:@"%@-%u-%@", [self _applicationNameForGrowlSearchingRegistrationDictionary:regDict], getpid(), (NSString *)uuidString] stringByAppendingPathExtension:GROWL_REG_DICT_EXTENSION];

					CFRelease(uuidString);

					if ([regDictFileName length] > NAME_MAX)

						regDictFileName = [[regDictFileName substringToIndex:(NAME_MAX - [GROWL_REG_DICT_EXTENSION length])] stringByAppendingPathExtension:GROWL_REG_DICT_EXTENSION];

					//make sure it's within pathname length constraints

					regDictPath = [NSTemporaryDirectory() stringByAppendingPathComponent:regDictFileName];

					if ([regDictPath length] > PATH_MAX)

						regDictPath = [[regDictPath substringToIndex:(PATH_MAX - [GROWL_REG_DICT_EXTENSION length])] stringByAppendingPathExtension:GROWL_REG_DICT_EXTENSION];

					//Write the registration dictionary out to the temporary directory

					NSData *plistData;

					NSString *error;

					plistData = [NSPropertyListSerialization dataFromPropertyList:regDict

																		   format:NSPropertyListBinaryFormat_v1_0

																 errorDescription:&error];

					if (plistData) {

						if (![plistData writeToFile:regDictPath atomically:NO])

							NSLog(@"GrowlApplicationBridge: Error writing registration dictionary at %@", regDictPath);

					} else {

						NSLog(@"GrowlApplicationBridge: Error writing registration dictionary at %@: %@", regDictPath, error);

						NSLog(@"GrowlApplicationBridge: Registration dictionary follows\n%@", regDict);

						[error release];

					}

					if ([[NSFileManager defaultManager] fileExistsAtPath:regDictPath]) {

						regItemURL = [NSURL fileURLWithPath:regDictPath];

						passRegDict = YES;

					}

				}

				AEStreamRef stream = AEStreamCreateEvent(kAECoreSuite, kAEOpen,

					//Target application

					typeProcessSerialNumber, &appPSN, sizeof(appPSN),

					kAutoGenerateReturnID, kAnyTransactionID);

				if (!stream) {

					NSLog(@"%@: Could not create open-document event to register this application with Growl", [self class]);

				} else {

					if (passRegDict) {

						NSString *regItemURLString = [regItemURL absoluteString];

						NSData *regItemURLUTF8Data = [regItemURLString dataUsingEncoding:NSUTF8StringEncoding];

						err = AEStreamWriteKeyDesc(stream, keyDirectObject, typeFileURL, [regItemURLUTF8Data bytes], [regItemURLUTF8Data length]);

						if (err != noErr) {

							NSLog(@"%@: Could not set direct object of open-document event to register this application with Growl because AEStreamWriteKeyDesc returned %li/%s", [self class], (long)err, GetMacOSStatusCommentString(err));

						}

					}

					AppleEvent event;

					err = AEStreamClose(stream, &event);

					if (err != noErr) {

						NSLog(@"%@: Could not finish open-document event to register this application with Growl because AEStreamClose returned %li/%s", [self class], (long)err, GetMacOSStatusCommentString(err));

					} else {

						err = AESend(&event, /*reply*/ NULL, kAENoReply | kAEDontReconnect | kAENeverInteract | kAEDontRecord, kAENormalPriority, kAEDefaultTimeout, /*idleProc*/ NULL, /*filterProc*/ NULL);

						if (err != noErr) {

							NSLog(@"%@: Could not send open-document event to register this application with Growl because AESend returned %li/%s", [self class], (long)err, GetMacOSStatusCommentString(err));

						}

					}

					success = (err == noErr);

				}

			}

		}

	}

	return success;

}

/*	+ (BOOL)launchGrowlIfInstalled

 *

 *Returns YES if the Growl helper app began launching or was already running.

 *Returns NO and performs no other action if the Growl prefPane is not properly

 *	installed.

 *If Growl is installed but disabled, the application will be registered and

 *	GrowlHelperApp will then quit.  This method will still return YES if Growl

 *	is installed but disabled.

 */

+ (BOOL) launchGrowlIfInstalled {

	return [self _launchGrowlIfInstalledWithRegistrationDictionary:nil];

}

@end