mvchelper.java

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

	public int getFirstClusterGroup() {
		int[] cluster = listClusterGroup();
		if(cluster != null && cluster.length > 0)
			return cluster[0];
		else
			return -1;
	}
	
	/**
	 * @return
	 * 		所有群组的索引
	 */
	public int[] listClusterGroup() {
	    return main.getModel().findTabIndex(clusterMatcher);
	}
	
	/**
	 * 在指定的群组中查找群
	 * 
	 * @param clusterGroupIndex
	 * 		群组索引
	 * @param clusterId
	 * 		群ID
	 * @return
	 * 		群ID索引数组
	 */
	public int[] listCluster(int clusterGroupIndex, int clusterId) {
	    clusterIdMatcher.setClusterId(clusterId);
	    return main.getModel().findItemIndex(clusterGroupIndex, clusterIdMatcher);
	}	
	
	/**
	 * 根据群的内部ID查找一个群
	 * 
	 * @param clusterId
	 * 		内部ID
	 * @return
	 * 		存在则返回群的model，否则返回null
	 */
	public ClusterModel getClusterModel(int clusterId) {
		int[] cluster = listClusterGroup();
		if(cluster != null && cluster.length > 0)
			return getClusterModel(cluster[0], clusterId);
		else
			return null;
	}
	
	/**
	 * 根据索引得到一个群model
	 * 
	 * @param tabIndex
	 * 		群组索引
	 * @param clusterId
	 * 		群内部ID
	 * @return
	 * 		存在则返回群的model，否则返回null
	 */
	public ClusterModel getClusterModel(int tabIndex, int clusterId) {
		if(tabIndex < 0 || tabIndex >= main.getModel().getTabCount()) return null;
		int[] item = listCluster(tabIndex, clusterId);
		if(item != null && item.length > 0)
			return (ClusterModel)main.getModel().getItem(tabIndex, item[0]);
		else
			return null;
	}
	
	/**
	 * @return
	 * 		所有好友组的索引数组
	 */
	public int[] listFriendlyGroup() {
	    return main.getModel().findTabIndex(friendlyMatcher);
	}	
	
	/**
	 * 得到第一个好友组model
	 * 
	 * @return
	 * 		好友组model
	 */
	public GroupModel getFirstFriendlyGroupModel() {
		List list = main.getModel().find(friendlyMatcher);
		if(list != null && list.size() > 0)
		    return (GroupModel)list.get(0);
		else
		    return null;
	}
	
	/**
	 * 判断一个FriendModel代表的用户是否是我的好友
	 * 
	 * @param f
	 * 		FriendModel
	 * @return
	 * 		true表示是我的好友
	 */
	public boolean isFriend(FriendModel f) {
	    return isFriend(f.getQQ());
	}
	
	/**
	 * 判断一个FriendModel代表的用户是否是我的好友
	 * 
	 * @param qq
	 * 		用户QQ号
	 * @return
	 * 		true表示是我的好友
	 */
	public boolean isFriend(int qq) {
		int[] friendly = listFriendlyGroup();
		if(friendly != null && friendly.length > 0) {
			qqNumMatcher.setQQ(qq, true);
			for(int i = 0; i < friendly.length; i++) {
				int[] temp = main.getModel().findItemIndex(friendly[i], qqNumMatcher);
				if(temp != null && temp.length > 0)
					return true;
			}
			return false;
		} else
			return false;
	}
	
	/**
	 * 给定一个QQ号，返回其在model中的位置，也就是tabIndex加上itemIndex
	 * 所以返回的是一个int[2]，第一个是组索引，第二个是组内索引
	 * <pre>
	 * 得到的结果只返回一个好友的索引，不考虑搜索到多个好友的情况，因为这在QQ中
	 * 是不可能的，但是程序留了余地
	 * </pre>
	 * 
	 * @param qqNum
	 * 		QQ号
	 * @return
	 * 		好友的model在shutter中的组索引和组内索引，如果不存在，返回null
	 */
	public int[] getFriendCoordinate(int qqNum) {
	    ShutterModel model = main.getModel();
	    
		qqNumMatcher.setQQ(qqNum, true);
		int tabSize = model.getTabCount();
		for(int i = 0; i < tabSize; i++) {
		    GroupModel g = (GroupModel)model.getTab(i);
		    if(g.isCluster()) continue;
			int[] temp = model.findItemIndex(i, qqNumMatcher);
			if(temp != null && temp.length > 0) {
				int[] ret = new int[2];
				ret[0] = i;
				ret[1] = temp[0];
				return ret;
			}
		}
		return null;
	}
	
	/**
	 * 查找一个好友的model，返回第一个搜索到的结果，一般也只可能搜到一个，多个在目前的情况
	 * 下是不正常的，所以不考虑，但是程序上留了余地
	 * 
	 * @param qq
	 * 		好友的QQ号
	 * @return
	 * 		好友的model，null表示不存在这个好友
	 */
	public FriendModel getFriendModel(int qq) {
	    return getFriendModel(new Integer(qq));
	}
	
	/**
	 * 查找一个好友的model，返回第一个搜索到的结果，一般也只可能搜到一个，多个在目前的情况
	 * 下是不正常的，所以不考虑，但是程序上留了余地
	 * 
	 * @param qq
	 * 		好友的QQ号
	 * @return
	 * 		好友的model，null表示不存在这个好友
	 */
	public FriendModel getFriendModel(Integer qq) {
	    qqNumMatcher.setQQ(qq, true);
	    List items = main.getModel().findItem(qqNumMatcher);
	    if(items != null && items.size() > 0) 
	        return (FriendModel)items.get(0);
	    else
	        return null;
	}
	
	/**
	 * 根据好友的model，得到好友在最近联系人组中的model，如果没有，返回null，
	 * 如果最近联系人功能没有打开，也返回null
	 * 
	 * @param f
	 * 		好友model
	 * @return CoolButton对象，如果不存在，返回null
	 */
	public CoolButton getLatestViewPart(FriendModel f) {	    
	    if(!OptionUtil.getInstance().isEnableLatest()) return null;
	    ShutterModel model = main.getModel();
	    // 找到最近联系人组，如果没有这个组，返回
        int[] li = model.findTabIndex(latestMatcher);
        if(li == null || li.length == 0) return null;
	    GroupModel g = (GroupModel)model.getTab(li[0]);
	    if(!LumaQQ.getString("group.default.latest").equals(g.getProperty(INode.NAME)))
	        return null;
	    // 在联系人组中查找是否有这个model
	    qqNumMatcher.setQQ(f.getQQ(), false);
	    int[] i = model.findItemIndex(li[0], qqNumMatcher);
	    if(i == null || i.length == 0) return null;
	    return main.getShutter().getItemControl(li[0], i[0]);
	}
	
	/**
	 * @return
	 * 		最近联系人组的索引数组
	 */
	public int[] listLatestGroup() {
	    return main.getModel().findTabIndex(latestMatcher);
	}
	
	/**
	 * 在指定组中查找好友索引，
	 * 
	 * @param groupIndex
	 * 		组索引
	 * @param qq
	 * 		好友QQ号
	 * @return
	 * 		好友索引数组
	 */
	public int[] listFriend(int groupIndex, int qq, boolean original) {
	    qqNumMatcher.setQQ(qq, original);
	    return main.getModel().findItemIndex(groupIndex, qqNumMatcher);
	}	
    
    /**
     * 检查一个好友是否是陌生人
     * 
     * @param qq
     * 		用户QQ号
     * @return
     * 		true表示是陌生人
     */
    public boolean isStranger(int qq) {
		// 在陌生人组中搜索发送者，如果没有找到，就当作陌生人处理
		int[] gTemp = listStrangerGroup();
		int[] i = listFriend(gTemp[0], qq, true);
		return (i != null && i.length > 0); 
    }
    
    /**
     * 检查一个人是否处于黑名单中
     * 
     * @param qq
     * 		QQ号
     * @return
     * 		true表示其在黑名单中
     */
    public boolean isBlacklist(int qq) {
        // 在黑名单组中搜索
		int[] gTemp = listBlacklistGroup();
		int[] i = listFriend(gTemp[0], qq, true);
		return (i != null && i.length > 0); 
    }
    
    /**
     * @return
     * 		黑名单组索引数组
     */
    public int[] listBlacklistGroup() {
        return main.getModel().findTabIndex(blacklistMatcher);
    }
    
    /**
     * @return
     * 		陌生人组索引数组
     */
    public int[] listStrangerGroup() {
        return main.getModel().findTabIndex(strangerMatcher);
    }    
	
	/**
	 * 找到指定QQ号在最近联系人组中的位置
	 * 
     * @param qqNum
     * 		QQ号
     * @return
     * 		组索引和组内索引，如果没有，返回null
     */
    public int[] getLatestCoordinate(int qqNum) {
        int[] ret = new int[2];
        int[] li = listLatestGroup();
        if(li == null || li.length == 0) return null;
        ret[0] = li[0];
        int[] ii = listFriend(li[0], qqNum, false);
        if(ii == null || ii.length == 0) return null;
        ret[1] = ii[0];
        return ret;
    }    
	
    /**
     * 在陌生人组中查找qq指定的用户，如果没有找到，则把这个用户添加到陌生人组
     * 
     * @param qq	
     * 		用户QQ号
     * @return
     * 		陌生人的组索引和组内索引
     */
    public int[] getStrangerIndex(int qq) {
		int[] gTemp = listStrangerGroup();
		int[] i = listFriend(gTemp[0], qq, true);
		if(i == null || i.length == 0) {
			/* 陌生人组中没有这个人，添加之 */
			FriendModel f = new FriendModel(String.valueOf(qq), icons.getHead(0));
			f.addProperty(IQQNode.QQ_NUMBER, new Integer(qq));
			f.addProperty(IQQNode.STATUS, IQQNode.VALUE_ONLINE);
			f.addProperty(IQQNode.MEMBER, "false");
			f.addProperty(IQQNode.HEAD, new Integer(0));
			main.getModel().addItem(gTemp[0], f);
			i = new int[] { gTemp[0], main.getModel().getItemCount(gTemp[0]) - 1 };
			// 得到这个陌生人的资料
			main.getClient().getUserInfo(qq);
		} 
		return i;
    }    
	
	/**
	 * 根据qq号，返回好友的view part
	 * 
	 * @param qqNum
	 * 		好友QQ号
	 * @return
	 * 		CoolButton对象
	 */
    public CoolButton getFriendViewPart(int qqNum) {
		int[] indices = getFriendCoordinate(qqNum);
		if(indices == null) 
		    return null;
		else
			return main.getShutter().getItemControl(indices[0], indices[1]);
	}
	
	/**
	 * 根据好友的model，得到好友的viewpart
	 * 
	 * @param f
	 * 		好友的model
	 * @return
	 * 	CoolButton对象
	 */
	public CoolButton getFriendViewPart(FriendModel f) {
		return getFriendViewPart(f.getQQ());
	}
	
	/**
	 * 根据手机号码，查找这个手机好友的索引
	 * 
	 * @param number
	 * 		手机号码
	 * @return
	 * 		索引数组
	 */
	public int[] getMobileFriend(String number) {
	    mobileNumberMatcher.setNumber(number);
	    return main.getMobileModel().findItemIndex(0, mobileNumberMatcher);
	}

	/**