Mercurialadium-1.4 / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
Plugins/Twitter Plugin/AITwitterAccount.m
author Zachary West <zacw@adium.im>
Wed Nov 25 20:01:05 2009 -0500 (2009-11-25)
changeset 2813 8c9675f4e147
parent 2812 50d3a714b11f
child 2845 d5f5178fe39c
permissions -rw-r--r--
Add underscores to the list of permissible hash tag characters. Fixes #12673. 
     1 /* 
     2  * Adium is the legal property of its developers, whose names are listed in the copyright file included
     3  * with this source distribution.
     4  * 
     5  * This program is free software; you can redistribute it and/or modify it under the terms of the GNU
     6  * General Public License as published by the Free Software Foundation; either version 2 of the License,
     7  * or (at your option) any later version.
     8  * 
     9  * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
    10  * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
    11  * Public License for more details.
    12  * 
    13  * You should have received a copy of the GNU General Public License along with this program; if not,
    14  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    15  */
    16 
    17 #import "AITwitterAccount.h"
    18 #import "AITwitterURLParser.h"
    19 #import "AITwitterReplyWindowController.h"
    20 #import "MGTwitterEngine/MGTwitterEngine.h"
    21 #import <AIUtilities/AIAttributedStringAdditions.h>
    22 #import <AIUtilities/AIStringAdditions.h>
    23 #import <AIUtilities/AIMenuAdditions.h>
    24 #import <AIUtilities/AIApplicationAdditions.h>
    25 #import <AIUtilities/AIDateFormatterAdditions.h>
    26 #import <Adium/AIChatControllerProtocol.h>
    27 #import <Adium/AIContentControllerProtocol.h>
    28 #import <Adium/AIContactControllerProtocol.h>
    29 #import <Adium/AIStatusControllerProtocol.h>
    30 #import <Adium/AIInterfaceControllerProtocol.h>
    31 #import <Adium/AIAccountControllerProtocol.h>
    32 #import <Adium/AIContactObserverManager.h>
    33 #import <Adium/AIListContact.h>
    34 #import <Adium/AIListGroup.h>
    35 #import <Adium/AIContentMessage.h>
    36 #import <Adium/AIListBookmark.h>
    37 #import <Adium/AIChat.h>
    38 #import <Adium/AIUserIcons.h>
    39 #import <Adium/AIService.h>
    40 #import <Adium/AIStatus.h>
    41 #import <Adium/AIHTMLDecoder.h>
    42 #import <Adium/AIContentEvent.h>
    43 
    44 @interface AITwitterAccount()
    45 - (void)updateUserIcon:(NSString *)url forContact:(AIListContact *)listContact;
    46 
    47 - (void)updateTimelineChat:(AIChat *)timelineChat;
    48 
    49 - (NSAttributedString *)parseMessage:(NSString *)inMessage
    50 							 tweetID:(NSString *)tweetID
    51 							  userID:(NSString *)userID
    52 					   inReplyToUser:(NSString *)replyUserID
    53 					inReplyToTweetID:(NSString *)replyTweetID;
    54 - (NSAttributedString *)parseDirectMessage:(NSString *)inMessage
    55 									withID:(NSString *)dmID
    56 								  fromUser:(NSString *)sourceUID;
    57 - (NSAttributedString *)attributedStringWithLinkLabel:(NSString *)label
    58 									  linkDestination:(NSString *)destination
    59 											linkClass:(NSString *)attributeName;
    60 
    61 - (void)setRequestType:(AITwitterRequestType)type forRequestID:(NSString *)requestID withDictionary:(NSDictionary *)info;
    62 - (AITwitterRequestType)requestTypeForRequestID:(NSString *)requestID;
    63 - (NSDictionary *)dictionaryForRequestID:(NSString *)requestID;
    64 - (void)clearRequestTypeForRequestID:(NSString *)requestID;
    65 
    66 - (void)periodicUpdate;
    67 - (void)displayQueuedUpdatesForRequestType:(AITwitterRequestType)requestType;
    68 
    69 - (void)getRateLimitAmount;
    70 @end
    71 
    72 @implementation AITwitterAccount
    73 - (void)initAccount
    74 {
    75 	[super initAccount];
    76 	
    77 	pendingRequests = [[NSMutableDictionary alloc] init];
    78 	queuedUpdates = [[NSMutableArray alloc] init];
    79 	queuedDM = [[NSMutableArray alloc] init];
    80 	queuedOutgoingDM = [[NSMutableArray alloc] init];
    81 
    82 	[[NSNotificationCenter defaultCenter] addObserver:self
    83 							     selector:@selector(chatDidOpen:) 
    84 									 name:Chat_DidOpen
    85 								   object:nil];
    86 	
    87 	[adium.preferenceController registerDefaults:[NSDictionary dictionaryWithObjectsAndKeys:
    88 												  [NSNumber numberWithInt:TWITTER_UPDATE_INTERVAL_MINUTES], TWITTER_PREFERENCE_UPDATE_INTERVAL,
    89 												  [NSNumber numberWithBool:YES], TWITTER_PREFERENCE_UPDATE_AFTER_SEND,
    90 												  [NSNumber numberWithBool:YES], TWITTER_PREFERENCE_LOAD_CONTACTS, nil]
    91 										forGroup:TWITTER_PREFERENCE_GROUP_UPDATES
    92 										  object:self];
    93 
    94 	// If we don't have a server set, set our default (if we have one)
    95 	if (!self.host && self.defaultServer) {
    96 		[self setPreference:self.defaultServer forKey:KEY_CONNECT_HOST group:GROUP_ACCOUNT_STATUS];
    97 	}
    98 
    99 	[adium.preferenceController registerPreferenceObserver:self forGroup:TWITTER_PREFERENCE_GROUP_UPDATES];
   100 	[adium.preferenceController informObserversOfChangedKey:nil inGroup:TWITTER_PREFERENCE_GROUP_UPDATES object:self];
   101 }
   102 
   103 - (void)dealloc
   104 {
   105 	[[NSNotificationCenter defaultCenter] removeObserver:self];
   106 	[adium.preferenceController unregisterPreferenceObserver:self];
   107 	
   108 	[twitterEngine release];
   109 	[pendingRequests release];
   110 	[queuedUpdates release];
   111 	[queuedDM release];
   112 	[queuedOutgoingDM release];
   113 	
   114 	[super dealloc];
   115 }
   116 
   117 /*!
   118  * @brief Our default server if none is provided.
   119  */
   120 - (NSString *)defaultServer
   121 {
   122 	return @"twitter.com";
   123 }
   124 
   125 #pragma mark AIAccount methods
   126 /*!
   127  * @brief We've been asked to connect.
   128  *
   129  * Sets our username and password for MGTwitterEngine, and validates credentials.
   130  *
   131  * Our connection procedure:
   132  * 1. Validate credentials
   133  * 2. Retrieve friends
   134  * 3. Trigger "periodic" update - DM, replies, timeline
   135  */
   136 - (void)connect
   137 {
   138 	[super connect];
   139 	
   140 	[twitterEngine release];
   141 	
   142 	twitterEngine = [[MGTwitterEngine alloc] initWithDelegate:self];
   143 	
   144 	[twitterEngine setClientName:@"Adium"
   145 						 version:[NSApp applicationVersion]
   146 							 URL:@"http://www.adiumx.com"
   147 						   token:self.sourceToken];	
   148 	
   149 	[twitterEngine setAPIDomain:[self.host stringByAppendingPathComponent:self.apiPath]];
   150 	
   151 	[twitterEngine setUsesSecureConnection:self.useSSL];
   152 	
   153 	if (self.useOAuth) {
   154 		if (!self.passwordWhileConnected.length) {
   155 			[self setLastDisconnectionError:TWITTER_OAUTH_NOT_AUTHORIZED];
   156 			
   157 			[[NSNotificationCenter defaultCenter] postNotificationName:@"AIEditAccount"
   158 																object:self];
   159 			
   160 			[self didDisconnect];
   161 			
   162 			// Don't try and connect.
   163 			return;
   164 			
   165 		} else {
   166 			twitterEngine.useOAuth = YES;
   167 			
   168 			OAToken *token = [[[OAToken alloc] initWithHTTPResponseBody:self.passwordWhileConnected] autorelease];
   169 			OAConsumer *consumer = [[[OAConsumer alloc] initWithKey:self.consumerKey secret:self.secretKey] autorelease];
   170 			
   171 			twitterEngine.accessToken = token;
   172 			twitterEngine.consumer = consumer;
   173 		}
   174 	} else {
   175 		[twitterEngine setUsername:self.UID password:self.passwordWhileConnected];
   176 	}
   177 	
   178 	AILogWithSignature(@"%@ connecting to %@", self, twitterEngine.APIDomain);
   179 	
   180 	NSString *requestID = [twitterEngine checkUserCredentials];
   181 	
   182 	if (requestID) {
   183 		[self setRequestType:AITwitterValidateCredentials forRequestID:requestID withDictionary:nil];
   184 	} else {
   185 		[self setLastDisconnectionError:AILocalizedString(@"Unable to connect to server", nil)];
   186 		[self didDisconnect];
   187 	}
   188 }
   189 
   190 /*!
   191  * @brief Connection successful
   192  *
   193  * Our credentials were validated correctly. Set up the timeline chat, and request our friends from the server.
   194  */
   195 - (void)didConnect
   196 {
   197 	[super didConnect];
   198 	
   199 	//Clear any previous disconnection error
   200 	[self setLastDisconnectionError:nil];
   201 	
   202 	// Creating the fake timeline account.
   203 	AIListBookmark *timelineBookmark = nil;
   204 	
   205 	if(!(timelineBookmark = [adium.contactController existingBookmarkForChatName:self.timelineChatName
   206 																	   onAccount:self
   207 																chatCreationInfo:nil])) {
   208 		AIChat *newTimelineChat = [adium.chatController chatWithName:self.timelineChatName
   209 														  identifier:nil
   210 														   onAccount:self 
   211 													chatCreationInfo:nil];
   212 		
   213 		[newTimelineChat setDisplayName:self.timelineChatName];
   214 		
   215 		timelineBookmark = [adium.contactController bookmarkForChat:newTimelineChat inGroup:[adium.contactController groupWithUID:TWITTER_REMOTE_GROUP_NAME]];
   216 
   217 	}
   218 	
   219 	NSTimeInterval updateInterval = [[self preferenceForKey:TWITTER_PREFERENCE_UPDATE_INTERVAL group:TWITTER_PREFERENCE_GROUP_UPDATES] integerValue] * 60;
   220 	
   221 	if(updateInterval > 0) {
   222 		[updateTimer invalidate];
   223 		updateTimer = [NSTimer scheduledTimerWithTimeInterval:updateInterval
   224 													   target:self
   225 													 selector:@selector(periodicUpdate)
   226 													 userInfo:nil
   227 													  repeats:YES];
   228 		
   229 		[self periodicUpdate];
   230 	}
   231 }
   232 
   233 /*!
   234  * @brief We've been asked to disconnect.
   235  *
   236  * End the session.
   237  */
   238 - (void)disconnect
   239 {
   240 	[super disconnect];
   241 	
   242 	[twitterEngine release]; twitterEngine = nil;
   243 	[updateTimer invalidate]; updateTimer = nil;
   244 	
   245 	[self didDisconnect];
   246 }
   247 
   248 /*!
   249  * @brief Account will be deleted
   250  */
   251 - (void)willBeDeleted
   252 {
   253 	[updateTimer invalidate]; updateTimer = nil;
   254 	
   255 	[super willBeDeleted];
   256 }
   257 
   258 /*!
   259  * @brief Session ended
   260  *
   261  * Remove all state information.
   262  */
   263 - (void)didDisconnect
   264 {
   265 	[updateTimer invalidate]; updateTimer = nil;
   266 	[pendingRequests removeAllObjects];
   267 	[queuedDM removeAllObjects];
   268 	[queuedOutgoingDM removeAllObjects];
   269 	[queuedUpdates removeAllObjects];
   270 	
   271 	[super didDisconnect];
   272 }
   273 
   274 /*!
   275  * @brief API path
   276  *
   277  * The API path extension for the given host.
   278  */
   279 - (NSString *)apiPath
   280 {
   281 	return nil;
   282 }
   283 
   284 /*!
   285  * @brief Our source token
   286  *
   287  * On Twitter, our given source token is "adiumofficial".
   288  */
   289 - (NSString *)sourceToken
   290 {
   291 	return @"adiumofficial";
   292 }
   293 
   294 /*!
   295  * @brief Returns whether or not to connect to Twitter API over HTTPS.
   296  */
   297 - (BOOL)useSSL
   298 {
   299 	return YES;
   300 }
   301 
   302 /*!
   303  * @brief Returns whether or not this account is connected via an encrypted connection.
   304  */
   305 - (BOOL)encrypted
   306 {
   307 	return (self.online && [twitterEngine usesSecureConnection]);
   308 }
   309 
   310 /*!
   311  * @brief Affirm we can open chats.
   312  */
   313 - (BOOL)openChat:(AIChat *)chat
   314 {	
   315 	[chat setValue:[NSNumber numberWithBool:YES] forProperty:@"Account Joined" notify:NotifyNow];
   316 	
   317 	return YES;
   318 }
   319 
   320 /*!
   321  * @brief Allow all chats to close.
   322  */
   323 - (BOOL)closeChat:(AIChat *)inChat
   324 {	
   325 	return YES;
   326 }
   327 
   328 /*!
   329  * @brief Rejoin the requested chat.
   330  */
   331 - (BOOL)rejoinChat:(AIChat *)inChat
   332 {	
   333 	[self displayYouHaveConnectedInChat:inChat];
   334 	
   335 	return YES;
   336 }
   337 
   338 /*!
   339  * @brief We always want to autocomplete the UID.
   340  */
   341 - (BOOL)chatShouldAutocompleteUID:(AIChat *)inChat
   342 {
   343 	return YES;
   344 }
   345 
   346 /*!
   347  * @brief A chat opened.
   348  *
   349  * If this is a group chat which belongs to us, aka a timeline chat, set it up how we want it.
   350  */
   351 - (void)chatDidOpen:(NSNotification *)notification
   352 {
   353 	AIChat *chat = [notification object];
   354 	
   355 	if(chat.isGroupChat && chat.account == self) {
   356 		[self updateTimelineChat:chat];
   357 	}	
   358 }
   359 
   360 /*!
   361  * @brief We support adding and removing follows.
   362  */
   363 - (BOOL)contactListEditable
   364 {
   365     return self.online;
   366 }
   367 
   368 /*!
   369  * @brief Move contacts
   370  *
   371  * Move existing contacts to a specific group on this account.  The passed contacts should already exist somewhere on
   372  * this account.
   373  * @param objects NSArray of AIListContact objects to remove
   374  * @param group AIListGroup destination for contacts
   375  */
   376 - (void)moveListObjects:(NSArray *)objects oldGroups:(NSSet *)oldGroups toGroups:(NSSet *)groups
   377 {
   378 	// XXX do twitter grouping
   379 }
   380 
   381 /*!
   382  * @brief Rename a group
   383  *
   384  * Rename a group on this account.
   385  * @param group AIListGroup to rename
   386  * @param newName NSString name for the group
   387  */
   388 - (void)renameGroup:(AIListGroup *)group to:(NSString *)newName
   389 {
   390 	// XXX do twitter grouping
   391 }
   392 
   393 /*!
   394  * @brief For an invalid password, fail but don't try and reconnect or report it. We do it ourself.
   395  */
   396 - (AIReconnectDelayType)shouldAttemptReconnectAfterDisconnectionError:(NSString **)disconnectionError
   397 {
   398 	AIReconnectDelayType reconnectDelayType = [super shouldAttemptReconnectAfterDisconnectionError:disconnectionError];
   399 	
   400 	if ([*disconnectionError isEqualToString:TWITTER_INCORRECT_PASSWORD_MESSAGE]) {
   401 		reconnectDelayType = AIReconnectImmediately;
   402 	} else if ([*disconnectionError isEqualToString:TWITTER_OAUTH_NOT_AUTHORIZED]) {
   403 		reconnectDelayType = AIReconnectNeverNoMessage;
   404 	}
   405 	
   406 	return reconnectDelayType;
   407 }
   408 
   409 /*!
   410  * @brief Don't allow OTR encryption.
   411  */
   412 - (BOOL)allowSecureMessagingTogglingForChat:(AIChat *)inChat
   413 {
   414 	return NO;
   415 }
   416 
   417 /*!
   418  * @brief Update our status
   419  */
   420 - (void)setSocialNetworkingStatusMessage:(NSAttributedString *)statusMessage
   421 {
   422 	NSString *requestID = [twitterEngine sendUpdate:[statusMessage string]];
   423 
   424 	if(requestID) {
   425 		[self setRequestType:AITwitterSendUpdate
   426 				forRequestID:requestID
   427 			  withDictionary:nil];
   428 	}
   429 }
   430 
   431 - (NSString *)encodedAttributedString:(NSAttributedString *)inAttributedString forListObject:(AIListObject *)inListObject
   432 {
   433 	return [[inAttributedString attributedStringByConvertingLinksToURLStrings] string];
   434 }
   435 
   436 /*!
   437  * @brief Send a message
   438  *
   439  * Sends a direct message to the user requested.
   440  * If it fails to send, i.e. the request fails, an unknown error will occur.
   441  * This is usually caused by the target not following the user.
   442  */
   443 - (BOOL)sendMessageObject:(AIContentMessage *)inContentMessage
   444 {
   445 	NSString *requestID;
   446 	
   447 	if(inContentMessage.chat.isGroupChat) {
   448 		requestID = [twitterEngine sendUpdate:inContentMessage.encodedMessage
   449 									inReplyTo:[inContentMessage.chat valueForProperty:@"TweetInReplyToStatusID"]];
   450 		
   451 		if(requestID) {
   452 			[self setRequestType:AITwitterSendUpdate
   453 					forRequestID:requestID
   454 				  withDictionary:[NSDictionary dictionaryWithObject:inContentMessage.chat
   455 															 forKey:@"Chat"]];
   456 			
   457 			inContentMessage.displayContent = NO;
   458 			
   459 			AILogWithSignature(@"%@ Sending update [in reply to %@]: %@", self, [inContentMessage.chat valueForProperty:@"TweetInReplyToStatusID"], inContentMessage.encodedMessage);
   460 		}
   461 
   462 	} else {		
   463 		requestID = [twitterEngine sendDirectMessage:inContentMessage.encodedMessage
   464 												  to:inContentMessage.destination.UID];
   465 		
   466 		if(requestID) {
   467 			[self setRequestType:AITwitterDirectMessageSend
   468 					forRequestID:requestID
   469 				  withDictionary:[NSDictionary dictionaryWithObject:inContentMessage.chat
   470 															 forKey:@"Chat"]];
   471 			
   472 			inContentMessage.displayContent = NO;
   473 			
   474 			AILogWithSignature(@"%@ Sending DM to %@: %@", self, inContentMessage.destination.UID, inContentMessage.encodedMessage);
   475 		}
   476 	}
   477 	
   478 	if (!requestID) {
   479 		AILogWithSignature(@"%@ Message immediate fail.", self);
   480 	}
   481 	
   482 	return (requestID != nil);
   483 }
   484 
   485 /*!
   486  * @brief Trigger an info update
   487  *
   488  * This is called when the info inspector wants more information on a contact.
   489  * Grab the user's profile information, set everything up accordingly in the user info method.
   490  */
   491 - (void)delayedUpdateContactStatus:(AIListContact *)inContact
   492 {
   493 	if(!self.online) {
   494 		return;
   495 	}
   496 	
   497 	NSString *requestID = [twitterEngine getUserInformationFor:inContact.UID];
   498 	
   499 	if(requestID) {
   500 		[self setRequestType:AITwitterProfileUserInfo
   501 				forRequestID:requestID
   502 			  withDictionary:[NSDictionary dictionaryWithObject:inContact forKey:@"ListContact"]];
   503 	}
   504 }
   505 
   506 /*!
   507  * @brief Should an autoreply be sent to this message?
   508  */
   509 - (BOOL)shouldSendAutoreplyToMessage:(AIContentMessage *)message
   510 {
   511 	return NO;
   512 }
   513 
   514 /*!
   515  * @brief Update the Twitter profile
   516  */
   517 - (void)setProfileName:(NSString *)name
   518 				   url:(NSString*)url
   519 			  location:(NSString *)location
   520 		   description:(NSString *)description
   521 {
   522 	NSString *requestID = [twitterEngine updateProfileName:name
   523 													 email:nil
   524 													   url:url
   525 												  location:location
   526 											   description:description];
   527 	
   528 	if (requestID) {
   529 		[self setRequestType:AITwitterProfileSelf
   530 				forRequestID:requestID
   531 			  withDictionary:nil];
   532 	}
   533 }
   534 
   535 #pragma mark OAuth
   536 /*!
   537  * @brief Should we store our password based on internal object ID?
   538  *
   539  * We only need to if we're using OAuth.
   540  */
   541 - (BOOL)useInternalObjectIDForPasswordName
   542 {
   543 	return self.useOAuth;
   544 }
   545 
   546 /*!
   547  * @brief Should we connect using OAuth?
   548  *
   549  * If enabled, the account view will display the OAuth setup. Basic authentication will not be used.
   550  */
   551 - (BOOL)useOAuth
   552 {
   553 	return YES;
   554 }
   555 
   556 /*!
   557  * @brief OAuth consumer key
   558  */
   559 - (NSString *)consumerKey
   560 {
   561 	return @"amjYVOrzKpKkkHAsdEaClA";
   562 }
   563 
   564 /*!
   565  * @brief OAuth secret key
   566  */
   567 - (NSString *)secretKey
   568 {
   569 	return @"kvqM2CQsUO3J6NHctJVhTOzlKZ0k7FsTaR5NwakYU";
   570 }
   571 
   572 /*!
   573  * @brief Token request URL
   574  */
   575 - (NSString *)tokenRequestURL
   576 {
   577 	return @"https://twitter.com/oauth/request_token";
   578 }
   579 
   580 /*!
   581  * @brief Token access URL
   582  */
   583 - (NSString *)tokenAccessURL
   584 {
   585 	return @"https://twitter.com/oauth/access_token";	
   586 }
   587 
   588 /*!
   589  * @brief Token authorize URL
   590  */
   591 - (NSString *)tokenAuthorizeURL
   592 {
   593 	return @"https://twitter.com/oauth/authorize";
   594 }
   595 
   596 #pragma mark Menu Items
   597 /*!
   598  * @brief Menu items for contact
   599  *
   600  * Returns an array of menu items for a contact on this account.  This is the best place to add protocol-specific
   601  * actions that aren't otherwise supported by Adium.
   602  * @param inContact AIListContact for menu items
   603  * @return NSArray of NSMenuItem instances for the passed contact
   604  */
   605 - (NSArray *)menuItemsForContact:(AIListContact *)inContact
   606 {
   607 	NSMutableArray *menuItemArray = [NSMutableArray array];
   608 	
   609 	NSMenuItem *menuItem;
   610 	
   611 	NSImage	*serviceIcon = [AIServiceIcons serviceIconForService:self.service
   612 															type:AIServiceIconSmall
   613 													   direction:AIIconNormal];
   614 	
   615 	menuItem = [[[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:[NSString stringWithFormat:AILocalizedString(@"Open %@'s user page",nil), inContact.UID]
   616 																	 target:self
   617 																	 action:@selector(openUserPage:)
   618 															  keyEquivalent:@""] autorelease];
   619 	[menuItem setImage:serviceIcon];
   620 	[menuItem setRepresentedObject:inContact];
   621 	[menuItemArray addObject:menuItem];	
   622 
   623 	menuItem = [[[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:[NSString stringWithFormat:AILocalizedString(@"Enable device notifications for %@", "Enable sending Twitter notifications to your phone (device)"), inContact.UID]
   624 																	 target:self
   625 																	 action:@selector(enableOrDisableNotifications:)
   626 															  keyEquivalent:@""] autorelease];
   627 	[menuItem setTag:YES];
   628 	[menuItem setImage:serviceIcon];
   629 	[menuItem setRepresentedObject:inContact];
   630 	[menuItemArray addObject:menuItem];
   631 
   632 	menuItem = [[[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:[NSString stringWithFormat:AILocalizedString(@"Disable device notifications for %@", "Disable sending Twitter notifications to your phone"), inContact.UID]
   633 																	 target:self
   634 																	 action:@selector(enableOrDisableNotifications:)
   635 															  keyEquivalent:@""] autorelease];
   636 	[menuItem setTag:NO];
   637 	[menuItem setImage:serviceIcon];
   638 	[menuItem setRepresentedObject:inContact];
   639 	[menuItemArray addObject:menuItem];
   640 	
   641 	return menuItemArray;	
   642 }
   643 
   644 /*!
   645  * @brief Open the represented objec'ts user page
   646  */
   647 - (void)openUserPage:(NSMenuItem *)menuItem
   648 {
   649 	[[NSWorkspace sharedWorkspace] openURL:[NSURL URLWithString:[self addressForLinkType:AITwitterLinkUserPage
   650 																				  userID:((AIListContact *)menuItem.representedObject).UID
   651 																				statusID:nil
   652 																				 context:nil]]];
   653 }
   654 
   655 /*!
   656  * @brief Enable or disable notifications for a contact.
   657  *
   658  * If the menuItem's tag is YES, we're adding. Otherwise we're removing.
   659  */
   660 - (void)enableOrDisableNotifications:(NSMenuItem *)menuItem
   661 {
   662 	if(![menuItem.representedObject isKindOfClass:[AIListContact class]]) {
   663 		return;
   664 	}
   665 
   666 	BOOL enableNotification = menuItem.tag;
   667 	AIListContact *contact = menuItem.representedObject;
   668 	
   669 	NSString *requestID = nil;
   670 	
   671 	BOOL initialFailure = NO;
   672 	
   673 	if (enableNotification) {
   674 		requestID = [twitterEngine enableNotificationsFor:contact.UID];
   675 
   676 		if (requestID) {
   677 			[self setRequestType:AITwitterNotificationEnable
   678 					forRequestID:requestID
   679 				  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:contact, @"ListContact", nil]];
   680 		} else {
   681 			initialFailure = YES;
   682 		}
   683 	
   684 	} else {
   685 		requestID = [twitterEngine disableNotificationsFor:contact.UID];
   686 		
   687 		if (requestID) {
   688 			[self setRequestType:AITwitterNotificationDisable
   689 					forRequestID:requestID
   690 				  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:contact, @"ListContact", nil]];
   691 		} else {
   692 			initialFailure = YES;
   693 		}
   694 	}
   695 	
   696 	if (initialFailure) {
   697 		[adium.interfaceController handleErrorMessage:(enableNotification ?
   698 														AILocalizedString(@"Unable to Enable Notifications", nil) :
   699 														AILocalizedString(@"Unable to Disable Notifications", nil))
   700 									  withDescription:AILocalizedString(@"Unable to connect to the Twitter server.", nil)];
   701 	}
   702 }
   703 
   704 /*!
   705  * @brief Menu items for chat
   706  *
   707  * Returns an array of menu items for a chat on this account.  This is the best place to add protocol-specific
   708  * actions that aren't otherwise supported by Adium.
   709  * @param inChat AIChat for menu items
   710  * @return NSArray of NSMenuItem instances for the passed contact
   711  */
   712 - (NSArray *)menuItemsForChat:(AIChat *)inChat
   713 {
   714 	NSMutableArray *menuItemArray = [NSMutableArray array];
   715 	
   716 	NSMenuItem *menuItem;
   717 	
   718 	NSImage	*serviceIcon = [AIServiceIcons serviceIconForService:self.service
   719 															type:AIServiceIconSmall
   720 													   direction:AIIconNormal];
   721 	
   722 	menuItem = [[[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Update Tweets",nil)
   723 																	 target:self
   724 																	 action:@selector(periodicUpdate)
   725 															  keyEquivalent:@""] autorelease];
   726 	[menuItem setImage:serviceIcon];
   727 	[menuItemArray addObject:menuItem];
   728 	
   729 	menuItem = [[[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Reply to a Tweet",nil)
   730 																	 target:self
   731 																	 action:@selector(replyToTweet)
   732 															  keyEquivalent:@""] autorelease];
   733 	[menuItem setImage:serviceIcon];
   734 	[menuItemArray addObject:menuItem];
   735 	
   736 	return menuItemArray;	
   737 }
   738 
   739 /*!
   740  * @brief Menu items for the account's actions
   741  *
   742  * Returns an array of menu items for account-specific actions.  This is the best place to add protocol-specific
   743  * actions that aren't otherwise supported by Adium.  It will only be queried if the account is online.
   744  * @return NSArray of NSMenuItem instances for this account
   745  */
   746 - (NSArray *)accountActionMenuItems
   747 {
   748 	NSMutableArray *menuItemArray = [NSMutableArray array];
   749 	
   750 	NSMenuItem *menuItem;
   751 	
   752 	menuItem = [[[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Update Tweets",nil)
   753 																	target:self
   754 																	action:@selector(periodicUpdate)
   755 															 keyEquivalent:@""] autorelease];
   756 	[menuItemArray addObject:menuItem];
   757 
   758 	menuItem = [[[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Reply to a Tweet",nil)
   759 																	 target:self
   760 																	 action:@selector(replyToTweet)
   761 															  keyEquivalent:@""] autorelease];
   762 	[menuItemArray addObject:menuItem];
   763 
   764 	menuItem = [[[NSMenuItem allocWithZone:[NSMenu menuZone]] initWithTitle:AILocalizedString(@"Get Rate Limit Amount",nil)
   765 																	 target:self
   766 																	 action:@selector(getRateLimitAmount)
   767 															  keyEquivalent:@""] autorelease];
   768 	[menuItemArray addObject:menuItem];
   769 	
   770 	return menuItemArray;	
   771 }
   772 
   773 /*!
   774  * @brief Open the reply to tweet window
   775  *
   776  * Opens a window in which the user can create a reply featuring in_reply_to_status_id being set.
   777  */
   778 - (void)replyToTweet
   779 {
   780 	[AITwitterReplyWindowController showReplyWindowForAccount:self];
   781 }
   782 
   783 /*!
   784  * @brief Gets the current rate limit amount.
   785  */
   786 - (void)getRateLimitAmount
   787 {
   788 	NSString *requestID = [twitterEngine getRateLimitStatus];
   789 	
   790 	if (requestID) {
   791 		[self setRequestType:AITwitterRateLimitStatus
   792 				forRequestID:requestID
   793 			  withDictionary:nil];
   794 	}
   795 	
   796 }
   797 
   798 #pragma mark Contact handling
   799 /*!
   800  * @brief The name of our timeline chat
   801  */
   802 - (NSString *)timelineChatName
   803 {
   804 	return [NSString stringWithFormat:TWITTER_TIMELINE_NAME, self.UID];
   805 }
   806 
   807 /*!
   808  * @brief Our timeline chat
   809  *
   810  * If the timeline chat is not already active, it is created.
   811  */
   812 - (AIChat *)timelineChat
   813 {
   814 	AIChat *timelineChat = [adium.chatController existingChatWithName:self.timelineChatName
   815 							onAccount:self];
   816 	
   817 	if (!timelineChat) {
   818 		timelineChat = [adium.chatController chatWithName:self.timelineChatName
   819 						identifier:nil
   820 						onAccount:self
   821 						chatCreationInfo:nil];
   822 	}
   823 
   824 	return timelineChat;	
   825 }
   826 
   827 /*!
   828  * @brief Update the timeline chat
   829  * 
   830  * Remove the userlist
   831  */
   832 - (void)updateTimelineChat:(AIChat *)timelineChat
   833 {
   834 	// Disable the user list on the chat.
   835 	if (timelineChat.chatContainer.chatViewController.userListVisible) {
   836 		[timelineChat.chatContainer.chatViewController toggleUserList]; 
   837 	}	
   838 	
   839 	// Update the participant list.
   840 	[timelineChat addParticipatingListObjects:self.contacts notify:NotifyNow];
   841 	
   842 	[timelineChat setValue:[NSNumber numberWithInt:140] forProperty:@"Character Counter Max" notify:NotifyNow];
   843 }
   844 
   845 /*!
   846  * @brief Update serverside icon
   847  *
   848  * This is called by AIUserIcons when it needs an icon update for a contact.
   849  * If we already have an icon set (even a cached icon), ignore it.
   850  * Otherwise return the Twitter service icon.
   851  *
   852  * This is so that when an unknown contact appears, it has an actual image
   853  * to replace in the WKMV when an actual icon update is returned.
   854  *
   855  * This service icon will not remain saved very long, I see no harm in using it.
   856  * This only occurs for "strangers".
   857  */
   858 - (NSData *)serversideIconDataForContact:(AIListContact *)listContact
   859 {
   860 	if (![AIUserIcons userIconSourceForObject:listContact] &&
   861 		![AIUserIcons cachedUserIconDataForObject:listContact]) {
   862 		return [[self.service defaultServiceIconOfType:AIServiceIconLarge] TIFFRepresentation];
   863 	} else {
   864 		return nil;
   865 	}
   866 }
   867 
   868 /*!
   869  * @brief Update a user icon from a URL if necessary
   870  */
   871 - (void)updateUserIcon:(NSString *)url forContact:(AIListContact *)listContact;
   872 {
   873 	// If we don't already have an icon for the user...
   874 	if(![[listContact valueForProperty:TWITTER_PROPERTY_REQUESTED_USER_ICON] boolValue]) {
   875 		NSString *fileName = [[url lastPathComponent] stringByReplacingOccurrencesOfString:@"_normal." withString:@"_bigger."];
   876 		
   877 		url = [[url stringByDeletingLastPathComponent] stringByAppendingPathComponent:fileName];
   878 		
   879 		// Grab the user icon and set it as their serverside icon.
   880 		NSString *requestID = [twitterEngine getImageAtURL:url];
   881 		
   882 		if(requestID) {
   883 			[self setRequestType:AITwitterUserIconPull
   884 					forRequestID:requestID
   885 				  withDictionary:[NSDictionary dictionaryWithObject:listContact forKey:@"ListContact"]];
   886 		}
   887 		
   888 		[listContact setValue:[NSNumber numberWithBool:YES] forProperty:TWITTER_PROPERTY_REQUESTED_USER_ICON notify:NotifyNever];
   889 	}
   890 }
   891 
   892 /*!
   893  * @brief Unfollow the requested contacts.
   894  */
   895 - (void)removeContacts:(NSArray *)objects fromGroups:(NSArray *)groups
   896 {	
   897 	for (AIListContact *object in objects) {
   898 		NSString *requestID = [twitterEngine disableUpdatesFor:object.UID];
   899 		
   900 		AILogWithSignature(@"%@ Requesting unfollow for: %@", self, object.UID);
   901 		
   902 		if(requestID) {
   903 			[self setRequestType:AITwitterRemoveFollow
   904 					forRequestID:requestID
   905 				  withDictionary:[NSDictionary dictionaryWithObject:object forKey:@"ListContact"]];
   906 		}	
   907 	}
   908 }
   909 
   910 /*!
   911  * @brief Follow the requested contact, trigger an information pull for them.
   912  */
   913 - (void)addContact:(AIListContact *)contact toGroup:(AIListGroup *)group
   914 {
   915 	if ([contact.UID isCaseInsensitivelyEqualToString:self.UID]) {
   916 		AILogWithSignature(@"Not adding contact %@ to group %@, it's me!", contact.UID, group.UID);
   917 		return;
   918 	}
   919 	
   920 	NSString	*requestID = [twitterEngine enableUpdatesFor:contact.UID];
   921 	
   922 	AILogWithSignature(@"%@ Requesting follow for: %@", self, contact.UID);
   923 	
   924 	if(requestID) {	
   925 		NSString	*updateRequestID = [twitterEngine getUserInformationFor:contact.UID];
   926 		
   927 		if (updateRequestID) {
   928 			[self setRequestType:AITwitterAddFollow
   929 					forRequestID:updateRequestID
   930 				  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:contact.UID, @"UID", nil]];
   931 		}
   932 	}
   933 }
   934 
   935 #pragma mark Request cataloguing
   936 /*!
   937  * @brief Set the type and optional dictionary for a request ID
   938  *
   939  * Sets the AITwitterRequestType for a particular request ID, so when the request finishes we can identify what it is for.
   940  * Optionally sets a dictionary which can be retrieved in association with the request type.
   941  */
   942 - (void)setRequestType:(AITwitterRequestType)type forRequestID:(NSString *)requestID withDictionary:(NSDictionary *)info
   943 {
   944 	[pendingRequests setObject:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithInt:type], @"Type",
   945 								info, @"Info", nil]
   946 						forKey:requestID];
   947 }
   948 
   949 /*!
   950  * @brief Get the request type for a request ID
   951  */
   952 - (AITwitterRequestType)requestTypeForRequestID:(NSString *)requestID
   953 {
   954 	return [(NSNumber *)[[pendingRequests objectForKey:requestID] objectForKey:@"Type"] intValue];
   955 }
   956 
   957 /*!
   958  * @brief Get the dictionary associated with a request ID
   959  */
   960 - (NSDictionary *)dictionaryForRequestID:(NSString *)requestID
   961 {
   962 	return (NSDictionary *)[[pendingRequests objectForKey:requestID] objectForKey:@"Info"];
   963 }
   964 
   965 /*!
   966  * @brief Remove a request ID's saved information.
   967  */
   968 - (void)clearRequestTypeForRequestID:(NSString *)requestID
   969 {
   970 	[pendingRequests removeObjectForKey:requestID];
   971 }
   972 
   973 #pragma mark Preference updating
   974 - (void)preferencesChangedForGroup:(NSString *)group key:(NSString *)key object:(AIListObject *)object
   975 					preferenceDict:(NSDictionary *)prefDict firstTime:(BOOL)firstTime
   976 {
   977 	[super preferencesChangedForGroup:group key:key object:object preferenceDict:prefDict firstTime:firstTime];
   978 	
   979 	// We only care about our changes.
   980 	if (object != self) {
   981 		return;
   982 	}
   983 	
   984 	if([group isEqualToString:GROUP_ACCOUNT_STATUS]) {
   985 		if([key isEqualToString:KEY_USER_ICON]) {
   986 			// Avoid pushing an icon update which we just downloaded.
   987 			if(![self boolValueForProperty:TWITTER_PROPERTY_REQUESTED_USER_ICON]) {
   988 				NSString *requestID = [twitterEngine updateProfileImage:[prefDict objectForKey:KEY_USER_ICON]];
   989 			
   990 				if(requestID) {
   991 					AILogWithSignature(@"%@ Pushing self icon update", self);
   992 					
   993 					[self setRequestType:AITwitterProfileSelf
   994 							forRequestID:requestID
   995 						  withDictionary:nil];
   996 				}
   997 			}
   998 			
   999 			[self setValue:nil forProperty:TWITTER_PROPERTY_REQUESTED_USER_ICON notify:NotifyNever];
  1000 		}
  1001 	}
  1002 	
  1003 	if([group isEqualToString:TWITTER_PREFERENCE_GROUP_UPDATES]) {
  1004 		if(!firstTime && [key isEqualToString:TWITTER_PREFERENCE_UPDATE_INTERVAL]) {
  1005 			NSTimeInterval timeInterval = [updateTimer timeInterval];
  1006 			NSTimeInterval newTimeInterval = [[prefDict objectForKey:TWITTER_PREFERENCE_UPDATE_INTERVAL] intValue] * 60;
  1007 			
  1008 			if (timeInterval != newTimeInterval && self.online) {
  1009 				[updateTimer invalidate]; updateTimer = nil;
  1010 				
  1011 				if(newTimeInterval > 0) {
  1012 					updateTimer = [NSTimer scheduledTimerWithTimeInterval:newTimeInterval
  1013 																   target:self
  1014 																 selector:@selector(periodicUpdate)
  1015 																 userInfo:nil
  1016 																  repeats:YES];
  1017 				}
  1018 			}
  1019 		}
  1020 		
  1021 		updateAfterSend = [[prefDict objectForKey:TWITTER_PREFERENCE_UPDATE_AFTER_SEND] boolValue];
  1022 		retweetLink = [[prefDict objectForKey:TWITTER_PREFERENCE_RETWEET_SPAM] boolValue];
  1023 		
  1024 		if ([key isEqualToString:TWITTER_PREFERENCE_LOAD_CONTACTS] && self.online) {
  1025 			if ([[prefDict objectForKey:TWITTER_PREFERENCE_LOAD_CONTACTS] boolValue]) {
  1026 				// Delay updates when loading our contacts list.
  1027 				[self silenceAllContactUpdatesForInterval:18.0];
  1028 				// Grab our user list.
  1029 				NSString	*requestID = [twitterEngine getRecentlyUpdatedFriendsFor:self.UID startingAtPage:1];
  1030 				
  1031 				if (requestID) {
  1032 					[self setRequestType:AITwitterInitialUserInfo
  1033 							forRequestID:requestID
  1034 						  withDictionary:[NSDictionary dictionaryWithObject:[NSNumber numberWithInt:1] forKey:@"Page"]];
  1035 				}
  1036 			} else {
  1037 				[self removeAllContacts];
  1038 			}
  1039 		}
  1040 	}	
  1041 }
  1042 
  1043 #pragma mark Periodic update scheduler
  1044 /*!
  1045  * @brief Trigger our periodic updates
  1046  */
  1047 - (void)periodicUpdate
  1048 {
  1049 	if (pendingUpdateCount) {
  1050 		AILogWithSignature(@"%@ Update already in progress. Count = %d", self, pendingUpdateCount);
  1051 		return;
  1052 	}
  1053 	
  1054 	NSString	*requestID;
  1055 	NSString	*lastID;
  1056 	
  1057 	// We haven't completed the timeline nor replies. This lets us know if we should display statuses.
  1058 	followedTimelineCompleted = repliesCompleted = NO;
  1059 	futureTimelineLastID = futureRepliesLastID = nil;
  1060 	
  1061 	// Prevent triggering this update routine multiple times.
  1062 	pendingUpdateCount = 3;
  1063 	
  1064 	// We haven't printed error messages for this set.
  1065 	timelineErrorMessagePrinted = NO;
  1066 	
  1067 	[queuedUpdates removeAllObjects];
  1068 	[queuedDM removeAllObjects];
  1069 	
  1070 	AILogWithSignature(@"%@ Periodic update fire", self);
  1071 	
  1072 	// Pull direct messages	
  1073 	lastID = [self preferenceForKey:TWITTER_PREFERENCE_DM_LAST_ID
  1074 							  group:TWITTER_PREFERENCE_GROUP_UPDATES];
  1075 	
  1076 	requestID = [twitterEngine getDirectMessagesSinceID:lastID startingAtPage:1];
  1077 	
  1078 	if (requestID) {
  1079 		[self setRequestType:AITwitterUpdateDirectMessage
  1080 				forRequestID:requestID
  1081 			  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithInt:1], @"Page", nil]];
  1082 	} else {
  1083 		--pendingUpdateCount;
  1084 	}
  1085 
  1086 	// Pull followed timeline
  1087 	lastID = [self preferenceForKey:TWITTER_PREFERENCE_TIMELINE_LAST_ID
  1088 							  group:TWITTER_PREFERENCE_GROUP_UPDATES];
  1089 
  1090 	requestID = [twitterEngine getFollowedTimelineFor:nil
  1091 											  sinceID:lastID
  1092 									   startingAtPage:1
  1093 												count:(lastID ? TWITTER_UPDATE_TIMELINE_COUNT : TWITTER_UPDATE_TIMELINE_COUNT_FIRST_RUN)];
  1094 	
  1095 	if (requestID) {
  1096 		[self setRequestType:AITwitterUpdateFollowedTimeline
  1097 				forRequestID:requestID
  1098 			  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithInt:1], @"Page", nil]];
  1099 	} else {
  1100 		--pendingUpdateCount;
  1101 	}
  1102 	
  1103 	// Pull the replies feed	
  1104 	lastID = [self preferenceForKey:TWITTER_PREFERENCE_REPLIES_LAST_ID
  1105 							  group:TWITTER_PREFERENCE_GROUP_UPDATES];
  1106 	
  1107 	requestID = [twitterEngine getRepliesSinceID:lastID startingAtPage:1];
  1108 	
  1109 	if (requestID) {
  1110 		[self setRequestType:AITwitterUpdateReplies
  1111 				forRequestID:requestID
  1112 			  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithInt:1], @"Page", nil]];
  1113 	} else {
  1114 		--pendingUpdateCount;
  1115 	}
  1116 }
  1117 
  1118 #pragma mark Message Display
  1119 /*!
  1120  * @brief Returns a user-readable message for an error code.
  1121  */
  1122 - (NSString *)errorMessageForError:(NSError *)error
  1123 {
  1124 	switch (error.code) {
  1125 		case 400:
  1126 			// Bad Request: your request is invalid, and we'll return an error message that tells you why.
  1127 			// This is the status code returned if you've exceeded the rate limit. 
  1128 			return AILocalizedString(@"You've exceeded the rate limit.", nil);
  1129 			break;
  1130 			
  1131 		case 401:
  1132 			// Not Authorized: either you need to provide authentication credentials, or the credentials provided aren't valid.
  1133 			return AILocalizedString(@"Your credentials do not allow you access.", nil);
  1134 			break;
  1135 			
  1136 		case 403:
  1137 			// Forbidden: we understand your request, but are refusing to fulfill it.  An accompanying error message should explain why.
  1138 			return AILocalizedString(@"Request refused by the server.", nil);
  1139 			break;
  1140 			
  1141 		case 404:
  1142 			// Not Found: either you're requesting an invalid URI or the resource in question doesn't exist (ex: no such user). 
  1143 			return AILocalizedString(@"Requested resource not found.", nil);
  1144 			break;
  1145 			
  1146 		case 500:
  1147 			// Internal Server Error: we did something wrong.  Please post to the group about it and the Twitter team will investigate.
  1148 			return AILocalizedString(@"The server reported an internal error.", nil);
  1149 			break;
  1150 			
  1151 		case 502:
  1152 			// Bad Gateway: returned if Twitter is down or being upgraded.
  1153 			return AILocalizedString(@"The server is currently down.", nil);
  1154 			break;
  1155 			
  1156 		case -1001:
  1157 			// Timeout
  1158 		case 503:
  1159 			// Service Unavailable: the Twitter servers are up, but are overloaded with requests.  Try again later.
  1160 			return AILocalizedString(@"The server is overloaded with requests.", nil);
  1161 			break;
  1162 			
  1163 	}
  1164 	
  1165 	return [NSString stringWithFormat:AILocalizedString(@"Unknown error: code %d, %@", nil), error.code, error.localizedDescription];
  1166 }
  1167 
  1168 /*!
  1169  * @brief Returns the link URL for a specific type of link
  1170  */
  1171 - (NSString *)addressForLinkType:(AITwitterLinkType)linkType
  1172 						  userID:(NSString *)userID
  1173 						statusID:(NSString *)statusID
  1174 						 context:(NSString *)context
  1175 {
  1176 	NSString *address = nil;
  1177 	
  1178 	if (linkType == AITwitterLinkStatus) {
  1179 		address = [NSString stringWithFormat:@"https://twitter.com/%@/status/%@", userID, statusID];
  1180 	} else if (linkType == AITwitterLinkFriends) {
  1181 		address = [NSString stringWithFormat:@"https://twitter.com/%@/friends", userID];
  1182 	} else if (linkType == AITwitterLinkFollowers) {
  1183 		address = [NSString stringWithFormat:@"https://twitter.com/%@/followers", userID]; 
  1184 	} else if (linkType == AITwitterLinkUserPage) {
  1185 		address = [NSString stringWithFormat:@"https://twitter.com/%@", userID]; 
  1186 	} else if (linkType == AITwitterLinkSearchHash) {
  1187 		address = [NSString stringWithFormat:@"http://search.twitter.com/search?q=%%23%@", context];
  1188 	} else if (linkType == AITwitterLinkReply) {
  1189 		address = [NSString stringWithFormat:@"twitterreply://%@@%@?action=reply&status=%@", self.internalObjectID, userID, statusID];
  1190 	} else if (linkType == AITwitterLinkRetweet) {
  1191 		address = [NSString stringWithFormat:@"twitterreply://%@@%@?action=retweet&status=%@&message=%@", self.internalObjectID, userID, statusID, context];
  1192 	} else if (linkType == AITwitterLinkFavorite) {
  1193 		address = [NSString stringWithFormat:@"twitterreply://%@@%@?action=favorite&status=%@", self.internalObjectID, userID, statusID];
  1194 	} else if (linkType == AITwitterLinkDestroyStatus) {
  1195 		address = [NSString stringWithFormat:@"twitterreply://%@@%@?action=destroy&status=%@&message=%@", self.internalObjectID, userID, statusID, context];
  1196 	} else if (linkType == AITwitterLinkDestroyDM) {
  1197 		address = [NSString stringWithFormat:@"twitterreply://%@@%@?action=destroy&dm=%@&message=%@", self.internalObjectID, userID, statusID, context];		
  1198 	}
  1199 	
  1200 	return address;
  1201 }
  1202 
  1203 /*!
  1204  * @brief Retweet the selected tweet.
  1205  *
  1206  * Attempts to retweet a tweet.
  1207  * Prints a status message in the chat on success/failure, behaves identical to sending a new tweet.
  1208  *
  1209  * @returns YES if the account could send a retweet message, NO if the account doesn't support it.
  1210  */
  1211 - (BOOL)retweetTweet:(NSString *)tweetID
  1212 {
  1213 	NSString *requestID = [twitterEngine retweetUpdate:tweetID];
  1214 	
  1215 	if (requestID) {
  1216 		[self setRequestType:AITwitterSendUpdate
  1217 				forRequestID:requestID
  1218 			  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:tweetID, @"tweetID", nil]];
  1219 	} else {
  1220 		[self.timelineChat receivedError:[NSNumber numberWithInt:AIChatMessageSendingConnectionError]];
  1221 	}
  1222 	
  1223 	return YES;
  1224 }
  1225 
  1226 /*!
  1227  * @brief Toggle the favorite status for a tweet.
  1228  *
  1229  * Attempts to favorite a tweet. If that fails, it removes favorite status.
  1230  * Prints a status message in the chat on success/failure, since it's otherwise not obvious.
  1231  */
  1232 - (void)toggleFavoriteTweet:(NSString *)tweetID
  1233 {
  1234 	NSString *requestID = [twitterEngine markUpdate:tweetID asFavorite:YES];
  1235 	
  1236 	if (requestID) {
  1237 		[self setRequestType:AITwitterFavoriteYes
  1238 				forRequestID:requestID
  1239 			  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:tweetID, @"tweetID", nil]];
  1240 	} else {
  1241 		AIChat *timelineChat = self.timelineChat;
  1242 		
  1243 		[adium.contentController displayEvent:AILocalizedString(@"Attempt to favorite tweet failed to connect.", nil)
  1244 									   ofType:@"favorite"
  1245 									   inChat:timelineChat];
  1246 	}
  1247 }
  1248 
  1249 /*!
  1250  * @brief Destroy the tweet.
  1251  *
  1252  * The user has already confirmed they want to destroy it; send the message.
  1253  */
  1254 - (void)destroyTweet:(NSString *)tweetID
  1255 {
  1256 	NSString *requestID = [twitterEngine deleteUpdate:tweetID];
  1257 	
  1258 	if(requestID) {
  1259 		[self setRequestType:AITwitterDestroyStatus
  1260 				forRequestID:requestID
  1261 			  withDictionary:nil];
  1262 	} else {
  1263 		AIChat *timelineChat = self.timelineChat;
  1264 		
  1265 		[adium.contentController displayEvent:AILocalizedString(@"Attempt to delete tweet failed to connect.", nil)
  1266 									   ofType:@"delete"
  1267 									   inChat:timelineChat];
  1268 	}
  1269 }
  1270 
  1271 /*!
  1272  * @brief Destroy the DM.
  1273  *
  1274  * The user has already confirmed they want to destroy it; send the message.
  1275  */
  1276 - (void)destroyDirectMessage:(NSString *)messageID
  1277 					 forUser:(NSString *)userID
  1278 {
  1279 	NSString *requestID = [twitterEngine deleteDirectMessage:messageID];
  1280 	AIListContact *contact = [self contactWithUID:userID];
  1281 	
  1282 	if(requestID) {
  1283 		[self setRequestType:AITwitterDestroyDM
  1284 				forRequestID:requestID
  1285 			  withDictionary:[NSDictionary dictionaryWithObject:contact forKey:@"ListContact"]];
  1286 	} else {
  1287 		AIChat *chat = [adium.chatController chatWithContact:contact];
  1288 		
  1289 		[adium.contentController displayEvent:AILocalizedString(@"Attempt to delete tweet failed to connect.", nil)
  1290 									   ofType:@"delete"
  1291 									   inChat:chat];
  1292 	}	
  1293 }
  1294 
  1295 /*!
  1296  * @brief Convert a link URL and name into an attributed link
  1297  *
  1298  * @param label The text to display for the link.
  1299  * @param destination The destination address for the link.
  1300  * @param attributeName The name of the twitter link attribute for HTML processing.
  1301  */
  1302 - (NSAttributedString *)attributedStringWithLinkLabel:(NSString *)label
  1303 									  linkDestination:(NSString *)destination
  1304 											linkClass:(NSString *)className
  1305 {
  1306 	NSURL *url = [NSURL URLWithString:destination];
  1307 	NSDictionary *attributes = [NSDictionary dictionaryWithObjectsAndKeys:
  1308 								url, NSLinkAttributeName,
  1309 								className, AIElementClassAttributeName, nil];
  1310 	
  1311 	return [[[NSAttributedString alloc] initWithString:label attributes:attributes] autorelease];
  1312 }
  1313 
  1314 /*!
  1315  * @brief Parse an attributed string into a linkified version.
  1316  */
  1317 - (NSAttributedString *)linkifiedAttributedStringFromString:(NSAttributedString *)inString
  1318 {	
  1319 	NSAttributedString *attributedString;
  1320 	
  1321 	static NSCharacterSet *usernameCharacters = nil;
  1322 	static NSCharacterSet *hashCharacters = nil;
  1323 	
  1324 	if (!usernameCharacters) {
  1325 		usernameCharacters = [[NSCharacterSet characterSetWithCharactersInString:@"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_"] retain];
  1326 	}
  1327 	
  1328 	if (!hashCharacters) {
  1329 		NSMutableCharacterSet	*disallowedCharacters = [[NSCharacterSet punctuationCharacterSet] mutableCopy];
  1330 		[disallowedCharacters formUnionWithCharacterSet:[NSCharacterSet whitespaceCharacterSet]];
  1331 		[disallowedCharacters removeCharactersInString:@"_"];
  1332 		
  1333 		hashCharacters = [[disallowedCharacters invertedSet] retain];
  1334 		
  1335 		[disallowedCharacters release];
  1336 	}
  1337 	
  1338 	attributedString = [AITwitterURLParser linkifiedStringFromAttributedString:inString
  1339 															forPrefixCharacter:@"@"
  1340 																   forLinkType:AITwitterLinkUserPage
  1341 																	forAccount:self
  1342 															 validCharacterSet:usernameCharacters];
  1343 	
  1344 	attributedString = [AITwitterURLParser linkifiedStringFromAttributedString:attributedString
  1345 															forPrefixCharacter:@"#"
  1346 																   forLinkType:AITwitterLinkSearchHash
  1347 																	forAccount:self
  1348 															 validCharacterSet:hashCharacters];
  1349 	
  1350 	return attributedString;
  1351 }
  1352 
  1353 /*!
  1354  * @brief Parses a Twitter message into an attributed string
  1355  */
  1356 - (NSAttributedString *)parseMessage:(NSString *)inMessage
  1357 							 tweetID:(NSString *)tweetID
  1358 							  userID:(NSString *)userID
  1359 					   inReplyToUser:(NSString *)replyUserID
  1360 					inReplyToTweetID:(NSString *)replyTweetID
  1361 {
  1362 	NSAttributedString *message;
  1363 	
  1364 	message = [NSAttributedString stringWithString:[inMessage stringByUnescapingFromXMLWithEntities:nil]];
  1365 	
  1366 	message = [self linkifiedAttributedStringFromString:message];
  1367 	
  1368 	BOOL replyTweet = (replyTweetID.length);
  1369 	BOOL tweetLink = (tweetID.length && userID.length);
  1370 	
  1371 	if (replyTweet || tweetLink) {
  1372 		NSMutableAttributedString *mutableMessage = [[message mutableCopy] autorelease];
  1373 		
  1374 		NSUInteger startIndex = message.length;
  1375 		
  1376 		[mutableMessage appendString:@"  (" withAttributes:nil];
  1377 	
  1378 		BOOL commaNeeded = NO;
  1379 		
  1380 		// Append a link to the tweet this is in reply to
  1381 		if (replyTweet) {
  1382 			NSString *linkAddress = [self addressForLinkType:AITwitterLinkStatus
  1383 													  userID:replyUserID
  1384 													statusID:replyTweetID
  1385 													 context:nil];
  1386 
  1387 			if([inMessage hasPrefix:@"@"] &&
  1388 			   inMessage.length >= replyUserID.length + 1 &&
  1389 			   [replyUserID isCaseInsensitivelyEqualToString:[inMessage substringWithRange:NSMakeRange(1, replyUserID.length)]]) {
  1390 				// If the message has a "@" prefix, it's a proper in_reply_to_status_id if the usernames match. Set a link appropriately.
  1391 				[mutableMessage setAttributes:[NSDictionary dictionaryWithObjectsAndKeys:linkAddress, NSLinkAttributeName, nil]
  1392 										range:NSMakeRange(0, replyUserID.length + 1)];
  1393 			} else {
  1394 				// This happens for mentions which are in_reply_to_status_id but the @target isn't the first part of the message.
  1395 				
  1396 				[mutableMessage appendAttributedString:[self attributedStringWithLinkLabel:AILocalizedString(@"IRT", "An abbreviation for 'in reply to' - placed at the beginning of the tweet tools for those which are directly in reply to another")
  1397 																		   linkDestination:linkAddress
  1398 																				 linkClass:AITwitterInReplyToClassName]];
  1399 				
  1400 				commaNeeded = YES;	
  1401 			}
  1402 		}
  1403 		
  1404 		// Append a link to reply to this tweet
  1405 		if (tweetLink) {
  1406 			NSString *linkAddress;
  1407 			
  1408 			if(![self.UID isCaseInsensitivelyEqualToString:userID]) {
  1409 				// A message from someone other than ourselves. RT and @ is permissible.
  1410 				if (retweetLink) {				
  1411 					if(commaNeeded) {
  1412 						[mutableMessage appendString:@", " withAttributes:nil];
  1413 					}
  1414 					
  1415 					linkAddress = [self addressForLinkType:AITwitterLinkRetweet
  1416 													userID:userID
  1417 												  statusID:tweetID
  1418 												   context:[inMessage stringByAddingPercentEscapesForAllCharacters]];
  1419 					
  1420 					[mutableMessage appendAttributedString:[self attributedStringWithLinkLabel:@"RT"
  1421 																			   linkDestination:linkAddress
  1422 																					 linkClass:AITwitterRetweetClassName]];
  1423 					commaNeeded = YES;
  1424 				}
  1425 				
  1426 				if (commaNeeded) {
  1427 					[mutableMessage appendString:@", " withAttributes:nil];
  1428 				}			
  1429 				
  1430 				linkAddress = [self addressForLinkType:AITwitterLinkReply
  1431 												userID:userID
  1432 											  statusID:tweetID
  1433 											   context:nil];
  1434 				
  1435 				[mutableMessage appendAttributedString:[self attributedStringWithLinkLabel:@"@"
  1436 																		   linkDestination:linkAddress
  1437 																				 linkClass:AITwitterReplyClassName]];
  1438 			} else {
  1439 				if(commaNeeded) {
  1440 					[mutableMessage appendString:@", " withAttributes:nil];
  1441 				}
  1442 				
  1443 				// Our own message. Display a destroy link.
  1444 				linkAddress = [self addressForLinkType:AITwitterLinkDestroyStatus
  1445 												userID:userID
  1446 											  statusID:tweetID
  1447 											   context:[inMessage stringByAddingPercentEscapesForAllCharacters]];
  1448 				
  1449 				[mutableMessage appendAttributedString:[self attributedStringWithLinkLabel:@"\u232B"
  1450 																		   linkDestination:linkAddress
  1451 																				 linkClass:AITwitterDeleteClassName]];
  1452 			}
  1453 			
  1454 			[mutableMessage appendString:@", " withAttributes:nil];
  1455 
  1456 			linkAddress = [self addressForLinkType:AITwitterLinkFavorite
  1457 											userID:userID
  1458 										  statusID:tweetID
  1459 										   context:nil];
  1460 
  1461 			[mutableMessage appendAttributedString:[self attributedStringWithLinkLabel:@"\u2606"
  1462 																	   linkDestination:linkAddress
  1463 																			 linkClass:AITwitterFavoriteClassName]];
  1464 
  1465 			[mutableMessage appendString:@", " withAttributes:nil];
  1466 			
  1467 			linkAddress = [self addressForLinkType:AITwitterLinkStatus
  1468 											userID:userID
  1469 										  statusID:tweetID
  1470 										   context:nil];
  1471 			
  1472 			[mutableMessage appendAttributedString:[self attributedStringWithLinkLabel:@"#"
  1473 																	   linkDestination:linkAddress
  1474 																			 linkClass:AITwitterStatusLinkClassName]];
  1475 
  1476 		}
  1477 	
  1478 		[mutableMessage appendString:@")" withAttributes:nil];
  1479 		
  1480 		[mutableMessage addAttributes:[NSDictionary dictionaryWithObjectsAndKeys:
  1481 									   [NSNumber numberWithBool:YES], AITwitterActionLinksAttributeName,
  1482 									   [NSNumber numberWithBool:YES], AIHiddenMessagePartAttributeName, nil]
  1483 								range:NSMakeRange(startIndex, mutableMessage.length - startIndex)];
  1484 	
  1485 		return mutableMessage;
  1486 	} else {
  1487 		return message;
  1488 	}
  1489 }
  1490 
  1491 /*!
  1492  * @brief Parse a direct message
  1493  */
  1494 - (NSAttributedString *)parseDirectMessage:(NSString *)inMessage
  1495 									withID:(NSString *)dmID
  1496 								  fromUser:(NSString *)sourceUID
  1497 {
  1498 	NSAttributedString *message;
  1499 	
  1500 	message = [NSAttributedString stringWithString:[inMessage stringByUnescapingFromXMLWithEntities:nil]];
  1501 	
  1502 	message = [self linkifiedAttributedStringFromString:message];
  1503 	
  1504 	NSMutableAttributedString *mutableMessage = [[message mutableCopy] autorelease];
  1505 	
  1506 	NSUInteger startIndex = message.length;
  1507 	
  1508 	[mutableMessage appendString:@"  (" withAttributes:nil];
  1509 	
  1510 	NSString *linkAddress = [self addressForLinkType:AITwitterLinkDestroyDM
  1511 											  userID:sourceUID
  1512 											statusID:dmID
  1513 											 context:[inMessage stringByAddingPercentEscapesForAllCharacters]];
  1514 	
  1515 	[mutableMessage appendAttributedString:[self attributedStringWithLinkLabel:@"\u232B"
  1516 															   linkDestination:linkAddress
  1517 																	 linkClass:AITwitterDeleteClassName]];
  1518 	
  1519 	[mutableMessage appendString:@")" withAttributes:nil];
  1520 	
  1521 	[mutableMessage addAttributes:[NSDictionary dictionaryWithObjectsAndKeys:
  1522 								   [NSNumber numberWithBool:YES], AITwitterActionLinksAttributeName,
  1523 								   [NSNumber numberWithBool:YES], AIHiddenMessagePartAttributeName, nil]
  1524 							range:NSMakeRange(startIndex, mutableMessage.length - startIndex)];
  1525 	
  1526 	return mutableMessage;
  1527 }
  1528 
  1529 
  1530 /*!
  1531  * @brief Sort status updates
  1532  */
  1533 NSInteger queuedUpdatesSort(id update1, id update2, void *context)
  1534 {
  1535 	return [[update1 objectForKey:TWITTER_STATUS_CREATED] compare:[update2 objectForKey:TWITTER_STATUS_CREATED]];
  1536 }
  1537 
  1538 /*!
  1539  * @brief Sort direct messages
  1540  */
  1541 NSInteger queuedDMSort(id dm1, id dm2, void *context)
  1542 {
  1543 	return [[dm1 objectForKey:TWITTER_DM_CREATED] compare:[dm2 objectForKey:TWITTER_DM_CREATED]];	
  1544 }
  1545 
  1546 /*!
  1547  * @brief Remove duplicate status updates.
  1548  *
  1549  * If we're following someone who replies to us, we'll receive a status update in both the
  1550  * timeline and the reply feed.
  1551  *
  1552  * @param inArray The sorted array of Tweets
  1553  */
  1554 - (NSArray *)arrayWithDuplicateTweetsRemoved:(NSArray *)inArray
  1555 {
  1556 	NSMutableArray *mutableArray = [inArray mutableCopy];
  1557 	
  1558 	NSDictionary *status = nil, *previousStatus = nil;
  1559 	
  1560 	// Starting at index 1, checking backwards. We'll never exceed bounds this way.
  1561 	for(NSUInteger index = 1; index < inArray.count; index++)
  1562 	{
  1563 		status = [inArray objectAtIndex:index];
  1564 		previousStatus = [inArray objectAtIndex:index-1];
  1565 		
  1566 		if([[status objectForKey:TWITTER_STATUS_ID] isEqualToString:[previousStatus objectForKey:TWITTER_STATUS_ID]]) {
  1567 			[mutableArray removeObject:status];
  1568 		}
  1569 	}
  1570 	
  1571 	return [mutableArray autorelease];
  1572 }
  1573 
  1574 /*!
  1575  * @brief Display queued updates or direct messages
  1576  *
  1577  * This could potentially be simplified since both DMs and updates have the same format.
  1578  */
  1579 - (void)displayQueuedUpdatesForRequestType:(AITwitterRequestType)requestType
  1580 {
  1581 	if(requestType == AITwitterUpdateReplies || requestType == AITwitterUpdateFollowedTimeline) {
  1582 		if(!queuedUpdates.count) {
  1583 			return;
  1584 		}
  1585 		
  1586 		AILogWithSignature(@"%@ Displaying %d updates", self, queuedUpdates.count);
  1587 		
  1588 		// Sort the queued updates (since we're intermingling pages of data from different souces)
  1589 		NSArray *sortedQueuedUpdates = [queuedUpdates sortedArrayUsingFunction:queuedUpdatesSort context:nil];
  1590 		
  1591 		sortedQueuedUpdates = [self arrayWithDuplicateTweetsRemoved:sortedQueuedUpdates];
  1592 		
  1593 		BOOL trackContent = [[self preferenceForKey:TWITTER_PREFERENCE_EVER_LOADED_TIMELINE group:TWITTER_PREFERENCE_GROUP_UPDATES] boolValue];
  1594 		
  1595 		AIChat *timelineChat = self.timelineChat;
  1596 		
  1597 		[[AIContactObserverManager sharedManager] delayListObjectNotifications];
  1598 		
  1599 		for (NSDictionary *status in sortedQueuedUpdates) {
  1600 			NSDate			*date = [status objectForKey:TWITTER_STATUS_CREATED];
  1601 			NSString		*text = [status objectForKey:TWITTER_STATUS_TEXT];
  1602 			
  1603 			NSString *contactUID = [[status objectForKey:TWITTER_STATUS_USER] objectForKey:TWITTER_STATUS_UID];
  1604 			
  1605 			id fromObject = nil;
  1606 			
  1607 			if(![self.UID isCaseInsensitivelyEqualToString:contactUID]) {
  1608 				AIListContact *listContact = [self contactWithUID:contactUID];
  1609 				
  1610 				// Update the user's status message
  1611 				[listContact setStatusMessage:[NSAttributedString stringWithString:[text stringByUnescapingFromXMLWithEntities:nil]]
  1612 									   notify:NotifyNow];
  1613 				
  1614 				[self updateUserIcon:[[status objectForKey:TWITTER_STATUS_USER] objectForKey:TWITTER_INFO_ICON] forContact:listContact];
  1615 				
  1616 				[timelineChat addParticipatingListObject:listContact notify:NotifyNow];
  1617 				
  1618 				fromObject = (id)listContact;
  1619 			} else {
  1620 				fromObject = (id)self;
  1621 			}
  1622 
  1623 			NSAttributedString *message = [self parseMessage:text
  1624 													 tweetID:[status objectForKey:TWITTER_STATUS_ID]
  1625 													  userID:contactUID
  1626 											   inReplyToUser:[status objectForKey:TWITTER_STATUS_REPLY_UID]
  1627 											inReplyToTweetID:[status objectForKey:TWITTER_STATUS_REPLY_ID]];
  1628 			
  1629 			AIContentMessage *contentMessage = [AIContentMessage messageInChat:timelineChat
  1630 																	withSource:fromObject
  1631 																   destination:self
  1632 																		  date:date
  1633 																	   message:message
  1634 																	 autoreply:NO];
  1635 			
  1636 			contentMessage.trackContent = trackContent;
  1637 			
  1638 			[adium.contentController receiveContentObject:contentMessage];
  1639 		}
  1640 		
  1641 		[[AIContactObserverManager sharedManager] endListObjectNotificationsDelay];
  1642 		
  1643 		[queuedUpdates removeAllObjects];
  1644 	} else if (requestType == AITwitterUpdateDirectMessage || requestType == AITwitterDirectMessageSend) {
  1645 		NSMutableArray **unsortedArray = (requestType == AITwitterUpdateDirectMessage) ? &queuedDM : &queuedOutgoingDM;
  1646 		
  1647 		if (!(*unsortedArray).count) {
  1648 			return;
  1649 		}
  1650 		
  1651 		AILogWithSignature(@"%@ Displaying %d DMs", self, queuedDM.count);
  1652 		
  1653 		NSArray *sortedQueuedDM = [*unsortedArray sortedArrayUsingFunction:queuedDMSort context:nil];
  1654 		
  1655 		for (NSDictionary *message in sortedQueuedDM) {
  1656 			NSDate			*date = [message objectForKey:TWITTER_DM_CREATED];
  1657 			NSString		*text = [message objectForKey:TWITTER_DM_TEXT];
  1658 			NSString		*fromUID = [message objectForKey:TWITTER_DM_SENDER_UID];
  1659 			NSString		*toUID = [message objectForKey:TWITTER_DM_RECIPIENT_UID];
  1660 			
  1661 			AIListObject *source = nil, *destination = nil;
  1662 			AIChat *chat = nil;
  1663 			
  1664 			if([self.UID isCaseInsensitivelyEqualToString:fromUID]) {
  1665 				// This is a message we sent; display as coming from us.
  1666 				source = self;
  1667 				destination = [self contactWithUID:toUID];
  1668 				chat = [adium.chatController chatWithContact:(AIListContact *)destination];
  1669 			} else {
  1670 				source = [self contactWithUID:fromUID];
  1671 				destination = self;
  1672 				chat = [adium.chatController chatWithContact:(AIListContact *)source];
  1673 			}
  1674 			
  1675 			if(chat && source && destination) {
  1676 				AIContentMessage *contentMessage = [AIContentMessage messageInChat:chat
  1677 																		withSource:source
  1678 																	   destination:destination
  1679 																			  date:date
  1680 																		   message:[self parseDirectMessage:text
  1681 																									 withID:[message objectForKey:TWITTER_DM_ID]
  1682 																								   fromUser:chat.listObject.UID]
  1683 																		 autoreply:NO];
  1684 				
  1685 				[adium.contentController receiveContentObject:contentMessage];
  1686 			}
  1687 		}
  1688 		
  1689 		[*unsortedArray removeAllObjects];
  1690 	}
  1691 }
  1692 
  1693 #pragma mark MGTwitterEngine Delegate Methods
  1694 /*!
  1695  * @brief A request was successful
  1696  *
  1697  * We only care about requests succeeding if they aren't specifically handled in another location.
  1698  */
  1699 - (void)requestSucceeded:(NSString *)identifier
  1700 {
  1701 	// If a request succeeds and we think we're offline, call ourselves online.
  1702 	if ([self requestTypeForRequestID:identifier] == AITwitterDisconnect) {
  1703 		[self didDisconnect];
  1704 	} else if ([self requestTypeForRequestID:identifier] == AITwitterRemoveFollow) {
  1705 		AIListContact *listContact = [[self dictionaryForRequestID:identifier] objectForKey:@"ListContact"];
  1706 		
  1707 		for (NSString *groupName in listContact.remoteGroupNames) {
  1708 			[listContact removeRemoteGroupName:groupName];
  1709 		}
  1710 	} else if ([self requestTypeForRequestID:identifier] == AITwitterDestroyStatus) {
  1711 		AIChat *timelineChat = self.timelineChat;
  1712 		
  1713 		[adium.contentController displayEvent:AILocalizedString(@"Your tweet has been successfully deleted.", nil)
  1714 									  ofType:@"delete"
  1715 									  inChat:timelineChat];
  1716 	} else if ([self requestTypeForRequestID:identifier] == AITwitterDestroyDM) {
  1717 		AIListContact *contact = [[self dictionaryForRequestID:identifier] objectForKey:@"ListContact"];
  1718 		AIChat *chat = [adium.chatController chatWithContact:contact];
  1719 		
  1720 		[adium.contentController displayEvent:AILocalizedString(@"The direct message has been successfully deleted.", nil)
  1721 									   ofType:@"delete"
  1722 									   inChat:chat];		
  1723 	}
  1724 }
  1725 
  1726 /*!
  1727  * @brief A request failed
  1728  *
  1729  * If it's a fatal error, we need to kill the session and retry. Otherwise, twitter's reliability is
  1730  * pretty terrible, so let's ignore errors for the most part.
  1731  */
  1732 - (void)requestFailed:(NSString *)identifier withError:(NSError *)error
  1733 {	
  1734 	switch ([self requestTypeForRequestID:identifier]) {
  1735 		case AITwitterDirectMessageSend:
  1736 		case AITwitterSendUpdate:
  1737 		{
  1738 			AIChat	*chat = [[self dictionaryForRequestID:identifier] objectForKey:@"Chat"];
  1739 			
  1740 			if (chat) {
  1741 				[chat receivedError:[NSNumber numberWithInt:AIChatMessageSendingConnectionError]];
  1742 				
  1743 				AILogWithSignature(@"%@ Chat send error on %@", self, chat);
  1744 			}
  1745 			break;
  1746 		}
  1747 			
  1748 		case AITwitterDisconnect:
  1749 			[self didDisconnect];
  1750 			break;
  1751 			
  1752 		case AITwitterInitialUserInfo:
  1753 			[self setLastDisconnectionError:AILocalizedString(@"Unable to retrieve user list [fail]", "Message when a (vital) twitter request to retrieve the follow list fails")];
  1754 			[self didDisconnect];
  1755 			break;
  1756 			
  1757 		case AITwitterUserIconPull:
  1758 		{
  1759 			AIListContact *listContact = [[self dictionaryForRequestID:identifier] objectForKey:@"ListContact"];
  1760 			
  1761 			// Image pull failed, flag ourselves as needing to try again.
  1762 			[listContact setValue:nil forProperty:TWITTER_PROPERTY_REQUESTED_USER_ICON notify:NotifyNever];
  1763 			break;
  1764 		}
  1765 			
  1766 		case AITwitterUpdateFollowedTimeline:
  1767 		case AITwitterUpdateReplies:
  1768 		{
  1769 			AIChat *timelineChat = [adium.chatController existingChatWithName:self.timelineChatName
  1770 																	onAccount:self];
  1771 			
  1772 			// Only print an error if the user already has the timeline open. Beyond annoying if we pop it open just to say "lol error"
  1773 			if (timelineChat && !timelineErrorMessagePrinted) {
  1774 				AIContentEvent *content = [AIContentEvent eventInChat:timelineChat
  1775 														   withSource:nil
  1776 														  destination:self
  1777 																 date:[NSDate date]
  1778 															  message:[NSAttributedString stringWithString:[NSString stringWithFormat:AILocalizedString(@"Unable to update timeline: %@", nil),
  1779 																											[self errorMessageForError:error]]]
  1780 															 withType:@"error"];
  1781 				
  1782 				content.postProcessContent = NO;
  1783 				content.coalescingKey = @"error";
  1784 				
  1785 				[adium.contentController receiveContentObject:content];
  1786 				
  1787 				// This gets reset to NO the next a periodic update fires.
  1788 				timelineErrorMessagePrinted = YES;
  1789 			}
  1790 			
  1791 			--pendingUpdateCount;
  1792 			break;
  1793 		}
  1794 			
  1795 		case AITwitterUpdateDirectMessage:
  1796 			--pendingUpdateCount;
  1797 			break;
  1798 			
  1799 		case AITwitterAddFollow:
  1800 			if(error.code == 404) {
  1801 				[adium.interfaceController handleErrorMessage:AILocalizedString(@"Unable to Add Contact", nil)
  1802 											  withDescription:[NSString stringWithFormat:AILocalizedString(@"Unable to add %@ to account %@, the user does not exist.", nil),
  1803 															   [[self dictionaryForRequestID:identifier] objectForKey:@"UID"],
  1804 															   self.explicitFormattedUID]];
  1805 			} else {
  1806 				[adium.interfaceController handleErrorMessage:AILocalizedString(@"Unable to Add Contact", nil)
  1807 											  withDescription:[NSString stringWithFormat:AILocalizedString(@"Unable to add %@ to account %@. %@",nil),
  1808 															   [[self dictionaryForRequestID:identifier] objectForKey:@"UID"],
  1809 															   self.explicitFormattedUID,
  1810 															   [self errorMessageForError:error]]];
  1811 			}
  1812 			break;
  1813 			
  1814 		case AITwitterRemoveFollow:
  1815 			[adium.interfaceController handleErrorMessage:AILocalizedString(@"Unable to Remove Contact", nil)
  1816 										  withDescription:[NSString stringWithFormat:AILocalizedString(@"Unable to remove %@ on account %@. %@", nil),
  1817 														   ((AIListContact *)[[self dictionaryForRequestID:identifier] objectForKey:@"ListContact"]).UID,
  1818 														   self.explicitFormattedUID,
  1819 														   [self errorMessageForError:error]]];
  1820 			break;
  1821 			
  1822 		case AITwitterValidateCredentials:
  1823 			if(error.code == 401) {	
  1824 				if(self.useOAuth) {
  1825 					[self setPasswordTemporarily:nil];
  1826 					[self setLastDisconnectionError:TWITTER_OAUTH_NOT_AUTHORIZED];
  1827 					
  1828 					[[NSNotificationCenter defaultCenter] postNotificationName:@"AIEditAccount"
  1829 																		object:self];
  1830 					
  1831 				} else {
  1832 					[self setLastDisconnectionError:TWITTER_INCORRECT_PASSWORD_MESSAGE];
  1833 					[self serverReportedInvalidPassword];
  1834 				}
  1835 				
  1836 				[self didDisconnect];
  1837 			} else {
  1838 				[self setLastDisconnectionError:AILocalizedString(@"Unable to validate credentials", nil)];
  1839 				[self didDisconnect];
  1840 			}
  1841 			break;
  1842 			
  1843 		case AITwitterFavoriteYes:
  1844 		case AITwitterFavoriteNo:
  1845 		{
  1846 			AIChat *timelineChat = self.timelineChat;
  1847 
  1848 			if (error.code == 403) {
  1849 				// We've attempted to add or remove when we already have it marked as such. Try the opposite.
  1850 				BOOL addAsFavorite = ([self requestTypeForRequestID:identifier] == AITwitterFavoriteNo);
  1851 				NSString *tweetID = [[self dictionaryForRequestID:identifier] objectForKey:@"tweetID"];
  1852 				
  1853 				NSString *requestID = [twitterEngine markUpdate:tweetID
  1854 													 asFavorite:addAsFavorite];
  1855 				
  1856 				if (requestID) {
  1857 					[self setRequestType:(addAsFavorite ? AITwitterFavoriteYes : AITwitterFavoriteNo)
  1858 							forRequestID:requestID
  1859 						  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:tweetID, @"tweetID", nil]];
  1860 				} else {
  1861 					[adium.contentController displayEvent:AILocalizedString(@"Attempt to favorite tweet failed to connect.", nil)
  1862 												   ofType:@"favorite"
  1863 												   inChat:timelineChat];
  1864 				}
  1865 			} else {
  1866 				[adium.contentController displayEvent:[NSString stringWithFormat:AILocalizedString(@"Attempt to favorite tweet failed. %@", nil), [self errorMessageForError:error]]
  1867 											   ofType:@"favorite"
  1868 											   inChat:timelineChat];				
  1869 			}
  1870 			
  1871 			break;
  1872 		}
  1873 			
  1874 		case AITwitterNotificationEnable:
  1875 		case AITwitterNotificationDisable:
  1876 		{
  1877 			BOOL			enableNotification = ([self requestTypeForRequestID:identifier] == AITwitterNotificationEnable);
  1878 			AIListContact	*listContact = [[self dictionaryForRequestID:identifier] objectForKey:@"ListContact"];
  1879 			
  1880 			[adium.interfaceController handleErrorMessage:(enableNotification ?
  1881 														   AILocalizedString(@"Unable to Enable Notifications", nil) :
  1882 														   AILocalizedString(@"Unable to Disable Notifications", nil))
  1883 										  withDescription:[NSString stringWithFormat:AILocalizedString(@"Cannot change notification setting for %@. %@", nil), listContact.UID, [self errorMessageForError:error]]];
  1884 			break;
  1885 		}
  1886 			
  1887 		case AITwitterDestroyStatus:
  1888 		{
  1889 			AIChat *timelineChat = self.timelineChat;
  1890 			
  1891 			[adium.contentController displayEvent:[NSString stringWithFormat:AILocalizedString(@"Your tweet failed to delete. %@", nil), [self errorMessageForError:error]]
  1892 										   ofType:@"delete"
  1893 										   inChat:timelineChat];
  1894 			break;
  1895 		}
  1896 			
  1897 		case AITwitterDestroyDM:
  1898 		{
  1899 				AIListContact *contact = [[self dictionaryForRequestID:identifier] objectForKey:@"ListContact"];
  1900 				AIChat *chat = [adium.chatController chatWithContact:contact];
  1901 				
  1902 				[adium.contentController displayEvent:[NSString stringWithFormat:AILocalizedString(@"The direct message failed to delete. %@", nil), [self errorMessageForError:error]]
  1903 											   ofType:@"delete"
  1904 											   inChat:chat];	
  1905 			break;
  1906 		}
  1907 			
  1908 		case AITwitterUnknownType:
  1909 		case AITwitterRateLimitStatus:
  1910 		case AITwitterProfileSelf:
  1911 		case AITwitterSelfUserIconPull:
  1912 		case AITwitterProfileUserInfo:
  1913 		case AITwitterProfileStatusUpdates:
  1914 			// While we don't handle the errors, it's a good idea to not have a "default" just to prevent accidentally letting something
  1915 			// we should really handle slip through.
  1916 			break;
  1917 
  1918 	}
  1919 	
  1920 	AILogWithSignature(@"%@ Request failed (%@ - %u) - %@", self, identifier, [self requestTypeForRequestID:identifier], error);
  1921 	
  1922 	[self clearRequestTypeForRequestID:identifier];
  1923 }
  1924 
  1925 /*!
  1926  * @brief Status updates received
  1927  */
  1928 - (void)statusesReceived:(NSArray *)statuses forRequest:(NSString *)identifier
  1929 {
  1930 	if([self requestTypeForRequestID:identifier] == AITwitterUpdateFollowedTimeline ||
  1931 	   [self requestTypeForRequestID:identifier] == AITwitterUpdateReplies) {
  1932 		NSString *lastID;
  1933 		
  1934 		BOOL nextPageNecessary = NO;
  1935 		
  1936 		if([self requestTypeForRequestID:identifier] == AITwitterUpdateFollowedTimeline) {
  1937 			lastID = [self preferenceForKey:TWITTER_PREFERENCE_TIMELINE_LAST_ID
  1938 									  group:TWITTER_PREFERENCE_GROUP_UPDATES];
  1939 			
  1940 			nextPageNecessary = (lastID && statuses.count >= TWITTER_UPDATE_TIMELINE_COUNT - 5);
  1941 		} else {
  1942 			lastID = [self preferenceForKey:TWITTER_PREFERENCE_REPLIES_LAST_ID
  1943 									  group:TWITTER_PREFERENCE_GROUP_UPDATES];
  1944 			
  1945 			nextPageNecessary = (lastID && statuses.count >= TWITTER_UPDATE_REPLIES_COUNT - 5);
  1946 		}
  1947 		
  1948 		// Store the largest tweet ID we find; this will be our "last ID" the next time we run.
  1949 		NSString *largestTweet = [[self dictionaryForRequestID:identifier] objectForKey:@"LargestTweet"];
  1950 		
  1951 		// The largest ID is first, compare.
  1952 		if (statuses.count) {
  1953 			NSString *tweetID = [[statuses objectAtIndex:0] objectForKey:TWITTER_STATUS_ID];
  1954 			if (!largestTweet || [largestTweet compare:tweetID options:NSNumericSearch] == NSOrderedAscending) {
  1955 				largestTweet = tweetID;
  1956 			}
  1957 		}
  1958 		
  1959 		[queuedUpdates addObjectsFromArray:statuses];
  1960 		
  1961 		AILogWithSignature(@"%@ Last ID: %@ Largest Tweet: %@ Next Page Necessary: %d", self, lastID, largestTweet, nextPageNecessary);
  1962 		
  1963 		// See if we need to pull more updates.
  1964 		if (nextPageNecessary) {
  1965 			NSInteger	nextPage = [[[self dictionaryForRequestID:identifier] objectForKey:@"Page"] intValue] + 1;
  1966 			NSString	*requestID;
  1967 			
  1968 			if ([self requestTypeForRequestID:identifier] == AITwitterUpdateFollowedTimeline) {
  1969 				requestID = [twitterEngine getFollowedTimelineFor:nil
  1970 														  sinceID:lastID
  1971 												   startingAtPage:nextPage
  1972 															count:TWITTER_UPDATE_TIMELINE_COUNT];
  1973 				
  1974 				AILogWithSignature(@"%@ Pulling additional timeline page %d", self, nextPage);
  1975 				
  1976 				if (requestID) {
  1977 					[self setRequestType:AITwitterUpdateFollowedTimeline
  1978 							forRequestID:requestID
  1979 						  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithInt:nextPage], @"Page", 
  1980 										  largestTweet, @"LargestTweet", nil]];
  1981 				} else {
  1982 					// Gracefully fail: remove all stored objects.
  1983 					AILogWithSignature(@"%@ Immediate timeline fail", self);
  1984 					--pendingUpdateCount;
  1985 					[queuedUpdates removeAllObjects];
  1986 				}
  1987 				
  1988 			} else if ([self requestTypeForRequestID:identifier] == AITwitterUpdateReplies) {
  1989 				requestID = [twitterEngine getRepliesSinceID:lastID startingAtPage:nextPage];
  1990 				
  1991 				AILogWithSignature(@"%@ Pulling additional replies page %d", self, nextPage);
  1992 				
  1993 				if (requestID) {
  1994 					[self setRequestType:AITwitterUpdateReplies
  1995 							forRequestID:requestID
  1996 						  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithInt:nextPage], @"Page",
  1997 										  largestTweet, @"LargestTweet", nil]];
  1998 				} else {
  1999 					// Gracefully fail: remove all stored objects.
  2000 					AILogWithSignature(@"%@ Immediate reply fail", self);
  2001 					--pendingUpdateCount;
  2002 					[queuedUpdates removeAllObjects];
  2003 				}
  2004 			}
  2005 		} else {
  2006 			if([self requestTypeForRequestID:identifier] == AITwitterUpdateFollowedTimeline) {
  2007 				followedTimelineCompleted = YES;
  2008 				futureTimelineLastID = [largestTweet retain];
  2009 			} else if ([self requestTypeForRequestID:identifier] == AITwitterUpdateReplies) {
  2010 				repliesCompleted = YES;
  2011 				futureRepliesLastID = [largestTweet retain];
  2012 			}
  2013 			
  2014 			--pendingUpdateCount;
  2015 			
  2016 			AILogWithSignature(@"%@ Followed completed: %d Replies completed: %d", self, followedTimelineCompleted, repliesCompleted);
  2017 			
  2018 			if (followedTimelineCompleted && repliesCompleted) {
  2019 				if (queuedUpdates.count) {
  2020 					// Set the "last pulled" for the timeline and replies, since we've completed both.
  2021 					if(futureRepliesLastID) {
  2022 						AILogWithSignature(@"%@ futureRepliesLastID = %@", self, futureRepliesLastID);
  2023 						
  2024 						[self setPreference:futureRepliesLastID
  2025 									 forKey:TWITTER_PREFERENCE_REPLIES_LAST_ID
  2026 									  group:TWITTER_PREFERENCE_GROUP_UPDATES];
  2027 						
  2028 						[futureRepliesLastID release]; futureRepliesLastID = nil;
  2029 					}
  2030 					
  2031 					if(futureTimelineLastID) {
  2032 						AILogWithSignature(@"%@ futureTimelineLastID = %@", self, futureTimelineLastID);
  2033 						
  2034 						[self setPreference:futureTimelineLastID
  2035 									 forKey:TWITTER_PREFERENCE_TIMELINE_LAST_ID
  2036 									  group:TWITTER_PREFERENCE_GROUP_UPDATES];
  2037 						
  2038 						[futureTimelineLastID release]; futureTimelineLastID = nil;
  2039 					}
  2040 					
  2041 					[self displayQueuedUpdatesForRequestType:[self requestTypeForRequestID:identifier]];
  2042 				}
  2043 
  2044 				if (![self preferenceForKey:TWITTER_PREFERENCE_EVER_LOADED_TIMELINE group:TWITTER_PREFERENCE_GROUP_UPDATES]) {
  2045 					[self setPreference:[NSNumber numberWithBool:YES]
  2046 								 forKey:TWITTER_PREFERENCE_EVER_LOADED_TIMELINE
  2047 								  group:TWITTER_PREFERENCE_GROUP_UPDATES];
  2048 				}
  2049 			}
  2050 		}
  2051 	} else if ([self requestTypeForRequestID:identifier] == AITwitterProfileStatusUpdates) {
  2052 		AIListContact *listContact = [[self dictionaryForRequestID:identifier] objectForKey:@"ListContact"];
  2053 
  2054 		NSMutableArray *profileArray = [[listContact profileArray] mutableCopy];
  2055 		
  2056 		AILogWithSignature(@"%@ Updating statuses for profile, user %@", self, listContact);
  2057 		
  2058 		for (NSDictionary *update in statuses) {
  2059 			NSAttributedString *message = [self parseMessage:[update objectForKey:TWITTER_STATUS_TEXT]
  2060 													 tweetID:[update objectForKey:TWITTER_STATUS_ID]
  2061 													  userID:listContact.UID
  2062 											   inReplyToUser:[update objectForKey:TWITTER_STATUS_REPLY_UID]
  2063 											inReplyToTweetID:[update objectForKey:TWITTER_STATUS_REPLY_ID]];
  2064 			
  2065 			[profileArray addObject:[NSDictionary dictionaryWithObjectsAndKeys:message, KEY_VALUE, nil]];
  2066 		}
  2067 		
  2068 		[listContact setProfileArray:profileArray notify:NotifyNow];
  2069 	} else if ([self requestTypeForRequestID:identifier] == AITwitterSendUpdate) {
  2070 		if (updateAfterSend) {
  2071 			[self periodicUpdate];
  2072 		}
  2073 		
  2074 		if (statuses.count) {
  2075 			[adium.contentController displayEvent:AILocalizedString(@"Tweet successfully sent.", nil)
  2076 										   ofType:@"tweet"
  2077 										  inChat:self.timelineChat];
  2078 		}
  2079 				
  2080 		for(NSDictionary *update in statuses) {
  2081 			[[NSNotificationCenter defaultCenter] postNotificationName:AITwitterNotificationPostedStatus
  2082 																object:update
  2083 															  userInfo:[NSDictionary dictionaryWithObjectsAndKeys:self.timelineChat, @"AIChat", nil]];
  2084 			
  2085 			NSString *text = [[update objectForKey:TWITTER_STATUS_TEXT] stringByUnescapingFromXMLWithEntities:nil];
  2086 			
  2087 			if([[self preferenceForKey:TWITTER_PREFERENCE_UPDATE_GLOBAL group:TWITTER_PREFERENCE_GROUP_UPDATES] boolValue] &&
  2088 			   (![text hasPrefix:@"@"] || [[self preferenceForKey:TWITTER_PREFERENCE_UPDATE_GLOBAL_REPLIES group:TWITTER_PREFERENCE_GROUP_UPDATES] boolValue])) {
  2089 				AIStatus *availableStatus = [AIStatus statusOfType:AIAvailableStatusType];
  2090 				
  2091 				availableStatus.statusMessage = [NSAttributedString stringWithString:text];
  2092 				[adium.statusController setActiveStatusState:availableStatus];
  2093 			}
  2094 		}
  2095 	} else if ([self requestTypeForRequestID:identifier] == AITwitterFavoriteYes ||
  2096 			   [self requestTypeForRequestID:identifier] == AITwitterFavoriteNo) {
  2097 		AIChat *timelineChat = self.timelineChat;
  2098 
  2099 		for (NSDictionary *status in statuses) {
  2100 			NSString *message;
  2101 			
  2102 			// Use HTML for the status message since it's just easier to localize that way.
  2103 			
  2104 			if ([self requestTypeForRequestID:identifier] == AITwitterFavoriteYes) {
  2105 				message = AILocalizedString(@"The <a href=\"%@\">requested tweet</a> by <a href=\"%@\">%@</a> is now a favorite.", nil);
  2106 			} else {
  2107 				message = AILocalizedString(@"The <a href=\"%@\">requested tweet</a> by <a href=\"%@\">%@</a> is no longer a favorite.", nil);
  2108 			}
  2109 
  2110 			NSString *userID = [[status objectForKey:TWITTER_STATUS_USER] objectForKey:TWITTER_STATUS_UID];
  2111 			
  2112 			
  2113 			message = [NSString stringWithFormat:message,
  2114 					   [self addressForLinkType:AITwitterLinkStatus
  2115 										 userID:userID
  2116 									   statusID:[status objectForKey:TWITTER_STATUS_ID]
  2117 										context:nil],
  2118 					   [self addressForLinkType:AITwitterLinkUserPage
  2119 										 userID:userID
  2120 									   statusID:nil
  2121 										context:nil],
  2122 					   userID];
  2123 			
  2124 			NSAttributedString *attributedMessage = [[AIHTMLDecoder decoder] decodeHTML:message withDefaultAttributes:nil];
  2125 			
  2126 			AIContentEvent *content = [AIContentEvent eventInChat:timelineChat
  2127 													   withSource:nil
  2128 													  destination:self
  2129 															 date:[NSDate date]
  2130 														  message:attributedMessage
  2131 														 withType:@"favorite"];
  2132 			
  2133 			content.postProcessContent = NO;
  2134 			content.coalescingKey = @"favorite";
  2135 
  2136 			[adium.contentController receiveContentObject:content];
  2137 		}
  2138 	}
  2139 	
  2140 	[self clearRequestTypeForRequestID:identifier];
  2141 }
  2142 
  2143 /*!
  2144  * @brief Direct messages received
  2145  */
  2146 - (void)directMessagesReceived:(NSArray *)messages forRequest:(NSString *)identifier
  2147 {	
  2148 	if ([self requestTypeForRequestID:identifier] == AITwitterUpdateDirectMessage) {		
  2149 		NSString *lastID = [self preferenceForKey:TWITTER_PREFERENCE_DM_LAST_ID
  2150 											group:TWITTER_PREFERENCE_GROUP_UPDATES];
  2151 		
  2152 		BOOL nextPageNecessary = (lastID && messages.count >= TWITTER_UPDATE_DM_COUNT);
  2153 		
  2154 		// Store the largest tweet ID we find; this will be our "last ID" the next time we run.
  2155 		NSString *largestTweet = [[self dictionaryForRequestID:identifier] objectForKey:@"LargestTweet"];
  2156 		
  2157 		// The largest ID is first, compare.
  2158 		if (messages.count) {
  2159 			NSString *tweetID = [[messages objectAtIndex:0] objectForKey:TWITTER_DM_ID];
  2160 			if (!largestTweet || [largestTweet compare:tweetID] == NSOrderedAscending) {
  2161 				largestTweet = tweetID;
  2162 			}
  2163 		}
  2164 		
  2165 		[queuedDM addObjectsFromArray:messages];
  2166 		
  2167 		AILogWithSignature(@"%@ Last ID: %@ Largest Tweet: %@ Next Page Necessary: %d", self, lastID, largestTweet, nextPageNecessary);
  2168 		
  2169 		if(nextPageNecessary) {
  2170 			NSInteger	nextPage = [[[self dictionaryForRequestID:identifier] objectForKey:@"Page"] intValue] + 1;
  2171 			
  2172 			NSString	*requestID = [twitterEngine getDirectMessagesSinceID:lastID
  2173 														      startingAtPage:nextPage];
  2174 			
  2175 			AILogWithSignature(@"%@ Pulling additional DM page %d", self, nextPage);
  2176 			
  2177 			if(requestID) {
  2178 				[self setRequestType:AITwitterUpdateDirectMessage
  2179 						forRequestID:requestID
  2180 					  withDictionary:[NSDictionary dictionaryWithObjectsAndKeys:[NSNumber numberWithInt:nextPage], @"Page",
  2181 									  largestTweet, @"LargestTweet", nil]];
  2182 			} else {
  2183 				// Gracefully fail: remove all stored objects.
  2184 				AILogWithSignature(@"%@ Immediate DM pull fail", self);
  2185 				--pendingUpdateCount;
  2186 				[queuedDM removeAllObjects];
  2187 			}
  2188 		} else {		
  2189 			--pendingUpdateCount;
  2190 			
  2191 			if (largestTweet) {
  2192 				AILogWithSignature(@"%@ Largest DM pulled = %@", self, largestTweet);
  2193 				
  2194 				[self setPreference:largestTweet
  2195 							 forKey:TWITTER_PREFERENCE_DM_LAST_ID
  2196 							  group:TWITTER_PREFERENCE_GROUP_UPDATES];
  2197 			}
  2198 		
  2199 			// On first load, don't display any direct messages. Just ge the largest ID.
  2200 			if (queuedDM.count && lastID) {
  2201 				[self displayQueuedUpdatesForRequestType:[self requestTypeForRequestID:identifier]];
  2202 			} else {
  2203 				[queuedDM removeAllObjects];		
  2204 			}
  2205 		}
  2206 	} else if ([self requestTypeForRequestID:identifier] == AITwitterDirectMessageSend) {
  2207 		[queuedOutgoingDM addObjectsFromArray:messages];
  2208 		[self displayQueuedUpdatesForRequestType:AITwitterDirectMessageSend];
  2209 	}
  2210 	
  2211 	[self clearRequestTypeForRequestID:identifier];
  2212 }
  2213 
  2214 /*!
  2215  * @brief User information received
  2216  */
  2217 - (void)userInfoReceived:(NSArray *)userInfo forRequest:(NSString *)identifier
  2218 {	
  2219 	if (([self requestTypeForRequestID:identifier] == AITwitterInitialUserInfo ||
  2220 		 [self requestTypeForRequestID:identifier] == AITwitterAddFollow) &&
  2221 		[[self preferenceForKey:TWITTER_PREFERENCE_LOAD_CONTACTS group:TWITTER_PREFERENCE_GROUP_UPDATES] boolValue]) {
  2222 		[[AIContactObserverManager sharedManager] delayListObjectNotifications];
  2223 		
  2224 		// The current amount of friends per page is 100. Use >= just in case this changes.
  2225 		BOOL nextPageNecessary = (userInfo.count >= 100);
  2226 		
  2227 		AILogWithSignature(@"%@ User info pull, Next page necessary: %d Count: %d", self, nextPageNecessary, userInfo.count);
  2228 		
  2229 		for (NSDictionary *info in userInfo) {
  2230 			AIListContact *listContact = [self contactWithUID:[info objectForKey:TWITTER_INFO_UID]];
  2231 			
  2232 			// If the user isn't in a group, set them in the Twitter group.
  2233 			if(listContact.countOfRemoteGroupNames == 0) {
  2234 				[listContact addRemoteGroupName:TWITTER_REMOTE_GROUP_NAME];
  2235 			}
  2236 		
  2237 			// Grab the Twitter display name and set it as the remote alias.
  2238 			if (![[listContact valueForProperty:@"Server Display Name"] isEqualToString:[info objectForKey:TWITTER_INFO_DISPLAY_NAME]]) {
  2239 				[listContact setServersideAlias:[info objectForKey:TWITTER_INFO_DISPLAY_NAME]
  2240 									   silently:silentAndDelayed];
  2241 			}
  2242 			
  2243 			// Grab the user icon and set it as their serverside icon.
  2244 			[self updateUserIcon:[info objectForKey:TWITTER_INFO_ICON] forContact:listContact];
  2245 			
  2246 			// Set the user as available.
  2247 			[listContact setStatusWithName:nil
  2248 								statusType:AIAvailableStatusType
  2249 									notify:NotifyLater];
  2250 			
  2251 			// Set the user's status message to their current twitter status text
  2252 			NSString *statusText = [[info objectForKey:TWITTER_INFO_STATUS] objectForKey:TWITTER_INFO_STATUS_TEXT];
  2253 			if (!statusText) //nil if they've never tweeted
  2254 				statusText = @"";
  2255 			[listContact setStatusMessage:[NSAttributedString stringWithString:[statusText stringByUnescapingFromXMLWithEntities:nil]] notify:NotifyLater];
  2256 			
  2257 			// Set the user as online.
  2258 			[listContact setOnline:YES notify:NotifyLater silently:silentAndDelayed];
  2259 			
  2260 			[listContact notifyOfChangedPropertiesSilently:silentAndDelayed];
  2261 		}
  2262 		
  2263 		[[AIContactObserverManager sharedManager] endListObjectNotificationsDelay];
  2264 		
  2265 		if (nextPageNecessary) {
  2266 			NSInteger	nextPage = [[[self dictionaryForRequestID:identifier] objectForKey:@"Page"] intValue] + 1;
  2267 			NSString	*requestID = [twitterEngine getRecentlyUpdatedFriendsFor:self.UID startingAtPage:nextPage];
  2268 			
  2269 			AILogWithSignature(@"%@ Pulling additional user info page %d", self, nextPage);
  2270 			
  2271 			if(requestID) {
  2272 				[self setRequestType:AITwitterInitialUserInfo
  2273 						forRequestID:requestID
  2274 					  withDictionary:[NSDictionary dictionaryWithObject:[NSNumber numberWithInt:nextPage]
  2275 																 forKey:@"Page"]];
  2276 			} else { 
  2277 				[self setLastDisconnectionError:AILocalizedString(@"Unable to retrieve user list [additional fail]", "Message when a (vital) twitter request to retrieve the follow list fails")];
  2278 				[self didDisconnect];
  2279 			}
  2280 			
  2281 		} else if ([self valueForProperty:@"Connecting"]) {			
  2282 			// Trigger our normal update routine.
  2283 			[self didConnect];
  2284 		}
  2285 	} else if ([self requestTypeForRequestID:identifier] == AITwitterProfileUserInfo) {
  2286 		NSDictionary *thisUserInfo = [userInfo objectAtIndex:0];
  2287 		
  2288 		if (thisUserInfo) {	
  2289 			AIListContact	*listContact = [[self dictionaryForRequestID:identifier] objectForKey:@"ListContact"];
  2290 			
  2291 			NSArray *keyNames = [NSArray arrayWithObjects:@"name", @"location", @"description", @"url", @"friends_count", @"followers_count", @"statuses_count", nil];
  2292 			NSArray *readableNames = [NSArray arrayWithObjects:AILocalizedString(@"Name", nil), AILocalizedString(@"Location", nil),
  2293 									  AILocalizedString(@"Biography", nil), AILocalizedString(@"Website", nil), AILocalizedString(@"Following", nil),
  2294 									  AILocalizedString(@"Followers", nil), AILocalizedString(@"Updates", nil), nil];
  2295 			
  2296 			NSMutableArray *profileArray = [NSMutableArray array];
  2297 			
  2298 			for (NSUInteger index = 0; index < keyNames.count; index++) {
  2299 				NSString			*keyName = [keyNames objectAtIndex:index];
  2300 				NSString			*unattributedValue = [thisUserInfo objectForKey:keyName];
  2301 				
  2302 				if(![unattributedValue isEqualToString:@""]) {
  2303 					NSString			*readableName = [readableNames objectAtIndex:index];
  2304 					NSAttributedString	*value;
  2305 					
  2306 					if([keyName isEqualToString:@"friends_count"]) {
  2307 						value = [NSAttributedString attributedStringWithLinkLabel:unattributedValue
  2308 																  linkDestination:[self addressForLinkType:AITwitterLinkFriends userID:listContact.UID statusID:nil context:nil]];
  2309 					} else if ([keyName isEqualToString:@"followers_count"]) {
  2310 						value = [NSAttributedString attributedStringWithLinkLabel:unattributedValue
  2311 																  linkDestination:[self addressForLinkType:AITwitterLinkFollowers userID:listContact.UID statusID:nil context:nil]];
  2312 					} else if ([keyName isEqualToString:@"statuses_count"]) {
  2313 						value = [NSAttributedString attributedStringWithLinkLabel:unattributedValue
  2314 																  linkDestination:[self addressForLinkType:AITwitterLinkUserPage userID:listContact.UID statusID:nil context:nil]];
  2315 					} else {
  2316 						value = [NSAttributedString stringWithString:unattributedValue];
  2317 					}
  2318 						
  2319 					[profileArray addObject:[NSDictionary dictionaryWithObjectsAndKeys:readableName, KEY_KEY, value, KEY_VALUE, nil]];
  2320 				}
  2321 			}
  2322 			
  2323 			AILogWithSignature(@"%@ Updating profileArray for user %@", self, listContact);
  2324 			
  2325 			[listContact setProfileArray:profileArray notify:NotifyNow];
  2326 			
  2327 			// Grab their statuses.
  2328 			NSString *requestID = [twitterEngine getUserTimelineFor:listContact.UID since:nil startingAtPage:0 count:TWITTER_UPDATE_USER_INFO_COUNT];
  2329 			
  2330 			if (requestID) {
  2331 				[self setRequestType:AITwitterProfileStatusUpdates
  2332 						forRequestID:requestID
  2333 					  withDictionary:[NSDictionary dictionaryWithObject:listContact forKey:@"ListContact"]];
  2334 			}
  2335 		}
  2336 	} else if ([self requestTypeForRequestID:identifier] == AITwitterValidateCredentials ||
  2337 			   [self requestTypeForRequestID:identifier] == AITwitterProfileSelf) {
  2338 		for (NSDictionary *info in userInfo) {
  2339 			NSString *requestID = [twitterEngine getImageAtURL:[info objectForKey:TWITTER_INFO_ICON]];
  2340 			
  2341 			if (requestID) {
  2342 				[self setRequestType:AITwitterSelfUserIconPull
  2343 						forRequestID:requestID
  2344 					  withDictionary:nil];
  2345 			}
  2346 
  2347 			[self filterAndSetUID:[info objectForKey:TWITTER_INFO_UID]];
  2348 			
  2349 			if ([info objectForKey:@"name"]) {
  2350 				[self setPreference:[[NSAttributedString stringWithString:[info objectForKey:@"name"]] dataRepresentation]
  2351 								forKey:KEY_ACCOUNT_DISPLAY_NAME
  2352 								 group:GROUP_ACCOUNT_STATUS];		
  2353 			}
  2354 			
  2355 			[self setValue:[info objectForKey:@"name"] forProperty:@"Profile Name" notify:NotifyLater];
  2356 			[self setValue:[info objectForKey:@"url"] forProperty:@"Profile URL" notify:NotifyLater];
  2357 			[self setValue:[info objectForKey:@"location"] forProperty:@"Profile Location" notify:NotifyLater];
  2358 			[self setValue:[info objectForKey:@"description"] forProperty:@"Profile Description" notify:NotifyLater];
  2359 			[self notifyOfChangedPropertiesSilently:NO];
  2360 		}
  2361 		
  2362 		
  2363 		if([self requestTypeForRequestID:identifier] == AITwitterValidateCredentials) {
  2364 			// Our UID is definitely set; grab our friends.
  2365 			
  2366 			if ([[self preferenceForKey:TWITTER_PREFERENCE_LOAD_CONTACTS group:TWITTER_PREFERENCE_GROUP_UPDATES] boolValue]) {
  2367 				// If we load our follows as contacts, do so now.
  2368 				
  2369 				// Delay updates on initial login.
  2370 				[self silenceAllContactUpdatesForInterval:18.0];
  2371 				// Grab our user list.
  2372 				NSString	*requestID = [twitterEngine getRecentlyUpdatedFriendsFor:self.UID startingAtPage:1];
  2373 				
  2374 				if (requestID) {
  2375 					[self setRequestType:AITwitterInitialUserInfo
  2376 							forRequestID:requestID
  2377 						  withDictionary:[NSDictionary dictionaryWithObject:[NSNumber numberWithInt:1] forKey:@"Page"]];
  2378 				} else {
  2379 					[self setLastDisconnectionError:AILocalizedString(@"Unable to retrieve user list", nil)];
  2380 					[self didDisconnect];
  2381 				}
  2382 			} else {
  2383 				// If we don't load follows as contacts, we've finished connecting (fast, wasn't it?)
  2384 				[self didConnect];
  2385 			}
  2386 		}
  2387 	} else if ([self requestTypeForRequestID:identifier] == AITwitterNotificationEnable ||
  2388 			   [self requestTypeForRequestID:identifier] == AITwitterNotificationDisable) {
  2389 		BOOL			enableNotification = ([self requestTypeForRequestID:identifier] == AITwitterNotificationEnable);
  2390 		AIListContact	*listContact = [[self dictionaryForRequestID:identifier] objectForKey:@"ListContact"];
  2391 		
  2392 		for (NSDictionary *info in userInfo) {		
  2393 			[adium.interfaceController handleMessage:(enableNotification ?
  2394 													  AILocalizedString(@"Notifications Enabled", nil) :
  2395 													  AILocalizedString(@"Notifications Disabled", nil))
  2396 									 withDescription:[NSString stringWithFormat:(enableNotification ?
  2397 																				 AILocalizedString(@"You will now receive device notifications for %@.", nil) :
  2398 																				 AILocalizedString(@"You will no longer receive device notifications for %@.", nil)),
  2399 													  listContact.UID]
  2400 									 withWindowTitle:(enableNotification ?
  2401 													  AILocalizedString(@"Notifications Enabled", nil) :
  2402 													  AILocalizedString(@"Notifications Disabled", nil))];
  2403 		}
  2404 	}
  2405 	
  2406 	[self clearRequestTypeForRequestID:identifier];
  2407 }
  2408 
  2409 /*!
  2410  * @brief Miscellaneous information received
  2411  */
  2412 - (void)miscInfoReceived:(NSArray *)miscInfo forRequest:(NSString *)identifier
  2413 {
  2414 	if([self requestTypeForRequestID:identifier] == AITwitterRateLimitStatus) {
  2415 		NSDictionary *rateLimit = [miscInfo objectAtIndex:0];
  2416 		NSDate *resetDate = [NSDate dateWithTimeIntervalSince1970:[[rateLimit objectForKey:TWITTER_RATE_LIMIT_RESET_SECONDS] intValue]];
  2417 		
  2418 		[adium.interfaceController handleMessage:AILocalizedString(@"Current Twitter rate limit", "Message in the rate limit status window")
  2419 								 withDescription:[NSString stringWithFormat:AILocalizedString(@"You have %d/%d more requests for %@.", "The first %d is the number of requests, the second is the total number of requests per hour. The %@ is the duration of time until the count resets."),
  2420 													[[rateLimit objectForKey:TWITTER_RATE_LIMIT_REMAINING] intValue],
  2421 													[[rateLimit objectForKey:TWITTER_RATE_LIMIT_HOURLY_LIMIT] intValue],
  2422 													[NSDateFormatter stringForTimeInterval:[resetDate timeIntervalSinceNow]
  2423 																			showingSeconds:YES
  2424 																			   abbreviated:YES
  2425 																			  approximated:NO]]
  2426 								 withWindowTitle:AILocalizedString(@"Rate Limit Status", nil)];
  2427 	}
  2428 	
  2429 	[self clearRequestTypeForRequestID:identifier];
  2430 }
  2431 
  2432 /*!
  2433  * @brief Requested image received
  2434  */
  2435 - (void)imageReceived:(NSImage *)image forRequest:(NSString *)identifier
  2436 {
  2437 	if([self requestTypeForRequestID:identifier] == AITwitterUserIconPull) {
  2438 		AIListContact		*listContact = [[self dictionaryForRequestID:identifier] objectForKey:@"ListContact"];
  2439 		
  2440 		AILogWithSignature(@"%@ Updated user icon for %@", self, listContact);
  2441 		
  2442 		[listContact setServersideIconData:[image TIFFRepresentation]
  2443 									notify:NotifyLater];
  2444 		
  2445 		[listContact setValue:nil forProperty:TWITTER_PROPERTY_REQUESTED_USER_ICON notify:NotifyNever];
  2446 	} else if([self requestTypeForRequestID:identifier] == AITwitterSelfUserIconPull) {
  2447 		AILogWithSignature(@"Updated self icon for %@", self);
  2448 
  2449 		// Set a property so we don't re-send thie image we're just now downloading.
  2450 		[self setValue:[NSNumber numberWithBool:YES] forProperty:TWITTER_PROPERTY_REQUESTED_USER_ICON notify:NotifyNever];
  2451 		
  2452 		[self setPreference:[NSNumber numberWithBool:YES]
  2453 					 forKey:KEY_USE_USER_ICON
  2454 					  group:GROUP_ACCOUNT_STATUS];
  2455 		
  2456 		
  2457 		[self setPreference:[image TIFFRepresentation]
  2458 					 forKey:KEY_USER_ICON
  2459 					  group:GROUP_ACCOUNT_STATUS];
  2460 	}
  2461 	
  2462 	[self clearRequestTypeForRequestID:identifier];
  2463 }
  2464 
  2465 @end
adium-1.4