mvchelper.java

java写的qq代码实现qq的部分功能

	 * 保存用户的好友列表和分组信息到缺省xml文件中
	 */
	public void saveModel() {
	    ShutterModel model = main.getModel();
	    
		Groups groups = new GroupsImpl();
		int tabSize = model.getTabCount();
		for(int i = 0; i < tabSize; i++) {
			Group group = ModelUtils.createGroupElement(model.getTab(i));
			groups.addGroup(group);
			// 判断这个组是群组还是普通组，保存的方式有些不一样，因为model不一样
			if("true".equals(group.getIsCluster())) {
				int itemSize = model.getItemCount(i);
				for(int j = 0; j < itemSize; j++) {
					// 得到群的model
					Object modelObj = model.getItem(i, j);
					// 判断model的类型
					if(modelObj instanceof ClusterModel) {
						ClusterModel c = (ClusterModel)modelObj;
						// 把群model添加到group中
						Cluster cluster = ModelUtils.createClusterElement(c);
						group.addCluster(cluster);
						// 添加这个群的成员
						Map members = c.getMembers();
						Iterator iter = members.values().iterator();
						while(iter.hasNext()) {
							FriendModel f = (FriendModel)iter.next();
							Friend friend = ModelUtils.createFriendElement(f);
							cluster.addFriend(friend);
						}
					} 
				}	
			} else {
				int itemSize = model.getItemCount(i);
				for(int j = 0; j < itemSize; j++) {
					Friend friend = ModelUtils.createFriendElement((FriendModel)model.getItem(i, j));
					group.addFriend(friend);
				}				
			}
		}
		// 写入到文件
		try {
			groups.marshal(new File(LumaQQ.GROUPS));
		} catch (IOException e) {
			log.error("好友分组信息保存失败");
		}
	}
	
	/**
	 * 初始化手机好友model
	 */
	public void initMobileModel() {
	    // 添加组，唯一的一个组
	    ShutterModel mobileModel = new DefaultShutterModel();
	    GroupModel g = new GroupModel(LumaQQ.getString("group.default.mobile"));
	    mobileModel.addTab(g);
	    
	    // 遍历所有好友，创建MobileModel对象，添加到组中
	    MobileUtil mobiles = MobileUtil.getInstance();
	    List list = mobiles.getMobileList();
	    Iterator i = list.iterator();
	    while(i.hasNext()) {
	        Mobile m = (Mobile)i.next();
	        MobileModel mm = ModelUtils.createMobileModel(m);
	        mobileModel.addItem(0, mm);
	    }
	    
	    main.setMobileModel(mobileModel);
	}
    
    /**
	 * 初始化model，从groups.xml中读取组信息和好友信息，如果不存在这个文件
	 * 则创建一个
	 */
	public void initModel() {
		// 检查分组信息文件，如果没有则创建一个，如果创建失败则退出
		File groupFile = new File(LumaQQ.GROUPS);
		if(!main.getConfigHelper().checkGroupFile(groupFile)) 
			main.close();
		// 读入分组信息文件，失败则退出
		groups = main.getConfigHelper().loadGroupFile(groupFile);
		if(groups == null)
			main.close();
		// 创建model对象
		DefaultShutterModel newModel = new DefaultShutterModel();
		main.setModel(newModel);
		// 初始化model
		Iterator groupIter = groups.getGroupList().iterator();
		int i = 0;
		while(groupIter.hasNext()) {
			Group group = (Group)groupIter.next();
			GroupModel g = ModelUtils.createGroupModel(group);
			newModel.addTab(g);
			// 根据改组是否是群组，调用不同的model创建方法
			if(g.isCluster()) {
				/* 当前组为群组 */
				Iterator clusterIter = group.getClusterList().iterator();
				while(clusterIter.hasNext()) {
					Map members = new HashMap();
					Cluster cluster = (Cluster)clusterIter.next();
					ClusterModel c = ModelUtils.createClusterModel(cluster);
					newModel.addItem(i, c);
					// 加入群中的成员
					List list = cluster.getFriendList();
					Iterator memberIter = list.iterator();
					while(memberIter.hasNext()) {
						Friend friend = (Friend)memberIter.next();
						FriendModel f = getFriendModel(Util.getInt(friend.getQqNum(), 0));
						if(f == null)
						    f = ModelUtils.createFriendModel(friend);
						f.addProperty(IQQNode.PARENT, c);
						members.put(f.getProperty(IQQNode.QQ_NUMBER), f);
					}
					c.addProperty(IQQNode.MEMBERS, members);
				}
			} else {
				/* 当前组为普通组 */
				Iterator friendIter = group.getFriendList().iterator();
				boolean isLatest = LumaQQ.getString("group.default.latest").equals(g.getProperty(INode.NAME));
				while(friendIter.hasNext()) {
					Friend friend = (Friend)friendIter.next();
					FriendModel f = ModelUtils.createFriendModel(friend);
					if(isLatest)
					    f.addProperty(IQQNode.ORIGINAL, "false");
					newModel.addItem(i, f);					
				}				
			}
			i++;
		}
		// 检查是否需要从服务器获得好友列表，如果xml文件中有好友，则认为
		// 好友已经保存在本地了，不再从服务器获取，这个判断方法比较简单
		// 以后可以修改，或者添加一个强制刷新好友列表的菜单项
		main.setFriendListFinished(newModel.getAllItemCount() > 0);
		// 设置model
		setModel(newModel);
		// 查找黑名单组，如果可视属性为false，隐藏它
		int[] blacklist = listBlacklistGroup();
		if (blacklist != null) {
			GroupModel blacklistGroup = (GroupModel)main.getModel().getTab(blacklist[0]);
			if (!blacklistGroup.isVisible()) {
				main.getShutter().hideTab(blacklist[0], true);
				main.setBlacklistVisible(false);
			} else
				main.setBlacklistVisible(true);
		}
	}
	
	/**
	 * 添加一个临时群
	 * 
	 * @param tempType
	 * @param clusterId
	 * @param parentClusterId
	 * @return
	 */
	public ClusterModel addTempCluster(byte tempType, int clusterId, int parentClusterId) {
		// 找到群组的索引
		int[] cluster = listClusterGroup();
		// 检查是否已经存在这个群，是则不做任何操作
		if(cluster != null && cluster.length > 0) {
			ClusterModel c = getClusterModel(cluster[0], clusterId);
			if(c == null) {
				// 新建一个群Model
				c = new ClusterModel(clusterId);
				c.addProperty(INode.IMAGE, icons.getClusterHead(4));
				c.addProperty(IQQNode.HEAD, new Integer(4));
				ClusterInfo info = new ClusterInfo();
				info.externalId = parentClusterId;
				c.addProperty(IQQNode.INFO, info);
				c.addProperty(IQQNode.TYPE, new Integer(tempType));
				// 添加这个model
				main.getModel().addItem(cluster[0], c);
				// 请求得到这个群的信息和成员列表
				main.getClient().getTempClusterInfo(tempType, clusterId, parentClusterId);
			}			
			// 返回model
			return c;
		}
		return null;
	}
	
	/**
	 * 添加一个Cluster
	 * 
	 * @param clusterId
	 * 		群的内部id
	 * @param create
	 * 		true表示我是这个群的创建者
	 * @return
	 * 		添加的或者早就存在的群model
	 */
	public ClusterModel addCluster(int clusterId, boolean create) {
		// 找到群组的索引
		int[] cluster = listClusterGroup();
		// 检查是否已经存在这个群，是则不做任何操作
		if(cluster != null && cluster.length > 0) {
			ClusterModel c = getClusterModel(cluster[0], clusterId);
			if(c == null) {
				// 新建一个群Model
				c = new ClusterModel(clusterId);
				c.addProperty(INode.IMAGE, icons.getClusterHead(4));
				c.addProperty(IQQNode.HEAD, new Integer(4));
				c.addProperty(IQQNode.INFO, new ClusterInfo());
				// 设置creator
				if(create) c.setCreator(main.getMyModel().getQQ());
				// 添加这个model
				main.getModel().addItem(cluster[0], c);
				// 如果我是创建者，则激活群
				if(create)
				    main.getClient().activateCluster(clusterId);
				// 请求得到这个群的信息和成员列表
				main.getClient().getClusterInfo(clusterId);
			}			
			// 返回model
			return c;
		}
		return null;
	}
	
	/**
	 * 删除一个群的model，如果存在这个群的相关窗口，也将关闭他们
	 * 
	 * @param clusterId
	 * 		群的内部ID
	 * @return
	 * 		成功则返回true
	 */
	public boolean removeCluster(int clusterId) {
	    ShutterModel model = main.getModel();
	    ShellRegistry shellRegistry = main.getShellRegistry();
	    UIHelper uiHelper = main.getUIHelper();
	    
		// 找到群组
		int[] cluster = listClusterGroup();
		if(cluster != null && cluster.length > 0) {
			// 找到群
			int[] item = listCluster(cluster[0], clusterId);
			if(item != null && item.length > 0) {
				// 得到群model
				ClusterModel c = (ClusterModel)model.getItem(cluster[0], item[0]);
				// 删除群
				model.removeItem(cluster[0], item[0]);
				// 关闭群相关窗口
				boolean anyShellOpened = false;
				if(shellRegistry.hasClusterInfoWindow(c)) {
					shellRegistry.removeClusterInfoWindow(c).close();
				}
				if(shellRegistry.hasSendClusterIMWindow(c)) {
					shellRegistry.removeSendClusterIMWindow(c).close();
				}
				// 把这个群的消息从队列中删除
				main.getMessageQueue().removeMessage(clusterId);
				// 调整动画状态
				uiHelper.resetGroupImageEffect(cluster[0]);
				uiHelper.resetTrayImageEffect();
				// 返回true表示成功
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 删除最近联系人组
	 */
	public void removeLatestGroup() {
	    int[] li = listLatestGroup();
	    if(li != null && li.length > 0)
	        main.getModel().removeTab(li[0]);
	}
	
	/**
	 * 更新服务器端的分组信息，目前这个函数没有使用，因为自动更新分组的前提是
	 * 登录是自动同步，不然可能会有潜在的问题
	 */
	public void updateGroupInServer() {
		// 组装上传分组名称包，注意i从1开始，因为我的好友组是缺省的，不需要上传
		// 同时组装上传分组好友列表包
		List groups = new ArrayList();
		ShutterModel model = main.getModel();
		int tabSize = model.getTabCount();
		for(int i = 0, g = 0; i < tabSize; i++) {
			GroupModel gModel = (GroupModel)model.getTab(i);
			if(gModel.needUpload()) {
				// 等于0表示是“我的好友”，这个是不需要上传名字的
				if(i != 0)
					groups.add(model.getTabName(i));
			}
		}
		// 发送
		main.getClient().uploadGroup(groups);
	}
		
	/**
	 * 设置组上的好友数和上线数
	 */
	public void setAllGroupStatistics() {
	    ShutterModel model = main.getModel();
	    int tabCount = model.getTabCount();
	    for(int i = 0; i < tabCount; i++) {
	        GroupModel g = (GroupModel)model.getTab(i);
	        g.setOnlineUser(0);
	        g.setUsers(model.getItemCount(i));
	    }
	}
	
	/**
	 * 添加一个手机好友
	 * 
	 * @param name
	 * 		名称
	 * @param number
	 * 		手机号
	 */
	public void addMobile(String name, String number) {
	    // 创建model
	    Mobile m = new MobileImpl();
	    m.setName(name);
	    m.setNumber(number);
	    MobileModel mm = ModelUtils.createMobileModel(m);
	    
	    // 添加
	    MobileUtil.getInstance().addMobileFriend(m);
	    main.getMobileModel().addItem(0, mm);
	}
	
	/**
	 * 删除手机好友，只删搜索到的第一个
	 * 
	 * @param number
	 * 		手机号码
	 */
	public void removeMobile(String number) {
	    MobileUtil.getInstance().removeMobileFriend(number);
	    
	    int[] indices = getMobileFriend(number);
	    if(indices != null && indices.length > 0) 
	        main.getMobileModel().removeItem(0, indices[0]);
	}
	
	/**
	 * 得到好友的鼠标跟踪事件监听器
	 * 
	 * @return
	 * 		ItemMouseTrackListener
	 */
	public ItemMouseTrackListener getItemMouseTrackListener() {
		return itemMouseTrackListener;
	}

    /**
     * 删除一个好友
     * 
     * @param f
     * 		FriendModel
     */
    public void removeFriend(FriendModel f) {
        int[] indices = getFriendCoordinate(f.getQQ());
        if(indices != null && indices.length > 0) {
	        main.getModel().removeItem(indices[0], indices[1]);
	        main.setGroupDirty(true);
        }
    }
}