mainqqlistener.mm

lumaqq

				case kQQSubCommandUploadGroupName:
					[self handleUploadGroupNameTimeout:event];
					return YES;
			}
			return NO;
		default:
			return NO;
	}
}

- (BOOL)handleLoginOK:(QQNotification*)event {
	// growl
	[[GrowlApplicationBridge growlDelegate] loginSuccess:m_me
										   lastLoginTime:[[[m_main client] user] lastLoginTime]
												 loginIp:[[[m_main client] user] ip]];
	
	// load groups
	[m_groupManager loadGroups];
	[m_me release];
	m_me = [m_groupManager user:[m_me QQ]];
	[m_main setMe:m_me];
	
	// check friend count
	if([m_groupManager friendCount] == 0) {
		// if zero, downloading friends
		[m_main setHint:L(@"LQHintDownloadGroupName", @"MainWindow")];
		[[m_main client] downloadGroupNames];
	} else {
		// initialize friend list UI
		[m_main setHint:L(@"LQHintInitializeUI", @"MainWindow")];
		[m_main initializeMainPane];
		[[m_main loginIndicator] stopAnimation:self];
		[[m_main mainTab] selectTabViewItemAtIndex:1];
		[[m_main window] setShowsToolbarButton:YES];
		[[m_main window] display];
		
		// install jobs
		GetUserPropertyJob* pJob = [[[GetUserPropertyJob alloc] init] autorelease];
		GetSignatureJob* sJob = [[[GetSignatureJob alloc] init] autorelease];
		GetCustomHeadInfoJob* iJob = [[[GetCustomHeadInfoJob alloc] init] autorelease];
		GetCustomHeadDataJob* dJob = [[[GetCustomHeadDataJob alloc] init] autorelease];
		[pJob addLinkJob:sJob];
		[pJob addLinkJob:iJob];
		[iJob addLinkJob:dJob];
		[[m_main jobController] startJob:pJob];
		[[m_main jobController] startJob:[[[GetFriendLevelJob alloc] init] autorelease]];
		
		// get online friend
		[[m_main client] getOnlineFriend];
		
		// refresh cluster
		[m_main refreshClusters:[m_groupManager allClusters]];
	}
	
	// play sound
	PreferenceCache* cache = [PreferenceCache cache:[m_me QQ]];
	if([cache isEnableSound])
		[[SoundHelper shared] playSound:kLQSoundLogin QQ:[m_me QQ]];
	
	return YES;
}

- (BOOL)handlePasswordVerifyFailed:(QQNotification*)event {
	PasswordVerifyReplyPacket* packet = (PasswordVerifyReplyPacket*)[event object];
	
	[AlertTool showWarning:[m_main window]
					 title:L(@"LQAlertTitle2", @"MainWindow")
				   message:[packet errorMessage]
				  delegate:m_main
			didEndSelector:@selector(loginFailedAlertDidEnd:returnCode:contextInfo:)];
	
	return YES;
}

- (BOOL)handleLoginFailed:(QQNotification*)event {
	[m_main shutdownNetwork];
	[m_main restartNetwork];
	return YES;
}

- (BOOL)handleChangeStatusOK:(QQNotification*)event {	
	// refresh ui
	[m_main setChangingStatus:NO];
	[m_main refreshStatusUI];
	
	return NO;
}

- (BOOL)handleFriendStatusChanged:(QQNotification*)event {
	FriendStatusChangedPacket* packet = [event object];
	FriendStatusChangedNotification* notify = [packet friendStatus];
	User* user = [m_groupManager user:[notify QQ]];
	if(user) {
		// copy info
		[user copyWithFriendStatusChangedNotification:notify];
		
		// get preference
		PreferenceCache* cache = [PreferenceCache cache:[m_me QQ]];
		BOOL onlineTip = [cache isUserOnlineTipEnabled];
		
		// if user becomes online, flash name
		if([notify status] == kQQStatusAway || 
		   [notify status] == kQQStatusOnline ||
		   [notify status] == kQQStatusBusy ||
		   [notify status] == kQQStatusMute ||
		   [notify status] == kQQStatusQMe) {
			if(![user isVisible]) {
				[user setOnlining:YES];
				[[TimerTaskManager sharedManager] addTask:[ModelEffectTask taskWithMainWindow:m_main object:user]];
				
				// if not disable online tip, play sound
				
				if(onlineTip) {
					// play sound
					[[SoundHelper shared] playSound:kLQSoundUserOnline QQ:[m_me QQ]];
					
					// growl
					[[GrowlApplicationBridge growlDelegate] userOnline:user
															mainWindow:m_main];
				}
			}
		} else if(onlineTip) {
			// growl
			[[GrowlApplicationBridge growlDelegate] userOffline:user mainWindow:m_main];
		}
		
		// refresh ui
		if([notify QQ] == [m_me QQ])
			[m_main refreshStatusUI];
		else {
			[user setStatus:[notify status]];
			[[m_main userOutline] reloadItem:user];
		}
		
		// sort users
		Group* group = [m_groupManager group:[user groupIndex]];
		if(group) {
			[group sort];
			[[m_main userOutline] reloadItem:group reloadChildren:YES];
		}
	}
	return NO;
}

- (BOOL)handleGetFriendListOK:(QQNotification*)event {
	GetFriendListReplyPacket* packet = (GetFriendListReplyPacket*)[event object];
	
	// add friends
	[m_groupManager addFriends:[packet friends]];
	
	// finished?
	if([packet finished]) {
		if(![m_main isRefreshingFriendList]) {
			// initialize friend list UI
			[m_main setHint:L(@"LQHintInitializeUI", @"MainWindow")];
			[m_main initializeMainPane];
			[[m_main loginIndicator] stopAnimation:self];
			[[m_main mainTab] selectTabViewItemAtIndex:1];
			[[m_main window] setShowsToolbarButton:YES];
			[[m_main window] display];
		} else
			[m_main setRefreshingFriendList:NO];
		
		// install jobs
		GetUserPropertyJob* pJob = [[[GetUserPropertyJob alloc] init] autorelease];
		GetSignatureJob* sJob = [[[GetSignatureJob alloc] init] autorelease];
		GetCustomHeadInfoJob* iJob = [[[GetCustomHeadInfoJob alloc] init] autorelease];
		GetCustomHeadDataJob* dJob = [[[GetCustomHeadDataJob alloc] init] autorelease];
		[pJob addLinkJob:sJob];
		[pJob addLinkJob:iJob];
		[iJob addLinkJob:dJob];
		[[m_main jobController] startJob:pJob];
		[[m_main jobController] startJob:[[[GetFriendLevelJob alloc] init] autorelease]];
		[[m_main jobController] startJob:[[[GetRemarkJob alloc] init] autorelease]];
		
		// get online friend
		[[m_main client] getOnlineFriend];
	} else {
		[[m_main client] getFriendList:[packet nextStartPosition]];
	}
	
	return YES;
}

- (BOOL)handleGetFriendGroupOK:(QQNotification*)event {
	GetFriendGroupReplyPacket* packet = (GetFriendGroupReplyPacket*)[event object];
	
	// add friend groups
	[m_groupManager addFriendGroups:[packet friendGroups]];
	
	// finished?
	if([packet finished]) {
		[m_main setHint:L(@"LQHintDownloadFriend", @"MainWindow")];
		[[m_main client] getFriendList];
		
		// refresh cluster
		[m_main refreshClusters:[m_groupManager allClusters]];
	} else {
		[[m_main client] getFriendGroup:[packet nextStartPosition]];
	}
	
	return YES;
}

- (BOOL)handleDownloadGroupNameOK:(QQNotification*)event {
	GroupDataOpReplyPacket* packet = (GroupDataOpReplyPacket*)[event object];
	
	[m_groupManager initializeGroups:[packet groupNames]];
	if([m_main isRefreshingFriendList]) {
		[m_main reloadUsers];
		[m_main reloadClusters];
		[m_main reloadRecent];
	}
	[m_main setHint:L(@"LQHintDownloadFriendGroup", @"MainWindow")];
	[[m_main client] getFriendGroup];
	
	return YES;
}

- (BOOL)handleGetOnlineFriendOK:(QQNotification*)event {
	GetOnlineOpReplyPacket* packet = (GetOnlineOpReplyPacket*)[event object];
	
	// get preference
	PreferenceCache* cache = [PreferenceCache cache:[m_me QQ]];
	
	// refresh cache
	[m_onlineCache addObjectsFromArray:[packet friends]];
	
	// check new online friend, if has, play sound. If user forbid online hint, don't play sound
	if(!m_firstOnlineCheckAfterLogin) {
		NSEnumerator* e = [[packet friends] objectEnumerator];
		while(FriendStatus* fs = [e nextObject]) {
			if(![m_onlines objectForKey:fs]) {
				// sound
				if([cache isUserOnlineTipEnabled])
					[[SoundHelper shared] playSound:kLQSoundUserOnline QQ:[m_me QQ]];
				
				// growl
				User* user = [m_groupManager user:[fs QQ]];
				if(user)
					[[GrowlApplicationBridge growlDelegate] userOnline:user
															mainWindow:m_main];
			}
		}
	} else
		m_firstOnlineCheckAfterLogin = NO;
	
	// construct a new hash
	NSMutableDictionary* newOnlines = [NSMutableDictionary dictionary];
	NSEnumerator* e = [m_onlineCache objectEnumerator];
	FriendStatus* fs = nil;
	while(fs = [e nextObject]) {
		[newOnlines setObject:fs forKey:fs];
		
		// set status
		User* u = [m_groupManager user:[fs QQ]];
		if(u)
			[u copyWithFriendStatus:fs];
	}
	
	// then remove the users which is not in new onlines
	e = [m_onlines keyEnumerator];
	while(fs = [e nextObject]) {
		if(![newOnlines objectForKey:fs]) {
			User* u = [m_groupManager user:[fs QQ]];
			if(u) {
				[u setStatus:kQQStatusOffline];
				
				// growl
				[[GrowlApplicationBridge growlDelegate] userOffline:u mainWindow:m_main];
			}
		}
	}
	
	// swap online array
	[newOnlines retain];
	[m_onlines release];
	m_onlines = newOnlines;
	
	// refresh outline
	[m_groupManager sortAll];
	[[m_main userOutline] reloadData];
	
	return YES;
}

- (BOOL)handleKeepAliveOK:(QQNotification*)event {
	KeepAliveReplyPacket* packet = (KeepAliveReplyPacket*)[event object];
	
	// save online count
	m_onlineUserCount = [packet online];
	
	// clear online cache, because keep alive will trigger a get online friend request
	[m_onlineCache removeAllObjects];
	
	return YES;
}

- (BOOL)handleGetUserPropertyOK:(QQNotification*)event {
	PropertyOpReplyPacket* packet = (PropertyOpReplyPacket*)[event object];
	
	// set properties
	[m_groupManager setUserProperty:[packet properties]];

	return NO;
}

- (BOOL)handleGetFriendLevelOK:(QQNotification*)event {
	LevelOpReplyPacket* packet = (LevelOpReplyPacket*)[event object];
	
	// set levels
	[m_groupManager setFriendLevel:[packet levels]];
	
	return NO;
}

- (BOOL)handleGetSignatureOK:(QQNotification*)event {
	SignatureOpReplyPacket* packet = (SignatureOpReplyPacket*)[event object];
	
	// for update, so don't check sequence here
	[m_groupManager setSignature:[packet signatures]];
	
	return NO;
}

- (BOOL)handleModifySignatureOK:(QQNotification*)event {
	SignatureOpPacket* packet = (SignatureOpPacket*)[event outPacket];
	if([[packet user] QQ] == [[m_main me] QQ])
		[[m_main me] setSignature:[packet signature]];
	return NO;
}

- (BOOL)handleBatchGetFriendRemarkOK:(QQNotification*)event {
	FriendDataOpReplyPacket* packet = (FriendDataOpReplyPacket*)[event object];
	
	// set remark
	[m_groupManager setRemarks:[packet remarks]];
	
	return NO;
}

- (BOOL)handleGetClusterMessageSettingOK:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = [event object];
	NSEnumerator* e = [[packet messageSettings] objectEnumerator];
	while(ClusterMessageSetting* setting = [e nextObject]) {
		if([setting messageSetting] != kQQClusterMessageClearServerSetting) {
			Cluster* cluster = [m_groupManager cluster:[setting internalId]];
			if(cluster)
				[m_main changeClusterMessageSetting:cluster newMessageSetting:[setting messageSetting]];
		}
	}
	return NO;
}

- (BOOL)handleGetTempClusterInfoOK:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = [event object];
	
	// save cluster info
	[m_groupManager setClusterInfo:[packet info]];
	
	// set member
	Cluster* tempCluster = [m_groupManager cluster:[packet internalId]];
	if(tempCluster) {
		// set member
		[tempCluster clearMembers];
		[m_groupManager setMembers:[packet internalId] members:[packet members]];
		
		// refresh ui
		[[m_main clusterOutline] reloadItem:tempCluster];
	}
	return NO;
}

- (BOOL)handleGetClusterInfoOK:(QQNotification*)event {
	ClusterCommandReplyPacket* packet = (ClusterCommandReplyPacket*)[event object];
	
	// save cluster info
	[m_groupManager setClusterInfo:[packet info]];
	
	// set member
	Cluster* c = [m_groupManager cluster:[packet internalId]];
	if(c) {
		[c clearMembers];
		[m_groupManager setMembers:[packet internalId] members:[packet members]];
		
		// get member info, divide into small packet because we only can get 30 members once