tq.java

Java实现QQ登录并发送消息

package org.formalin14.tq;

import java.io.*;
import java.net.*;
import java.text.*;
import java.util.*;

import edu.tsinghua.lumaqq.qq.*;
import edu.tsinghua.lumaqq.qq.beans.*;
import edu.tsinghua.lumaqq.qq.events.*;
import edu.tsinghua.lumaqq.qq.packets.in.*;

/**
 * @author Achilles Xu
 *
 */
public class TQ implements IQQListener {
	private QQClient client;
	private QQUser user;

	// config
	private String server;
	private boolean udp;
	private int qqno;
	private String qqpass;
	private boolean initHide;
	private boolean useProxy;
	private String proxyServer;
	private int proxyPort; 
	private String proxyUser;
	private String proxyPass;
	private String proxyType;
	
	private int state;
	private int stepCount = 5;
	private Hashtable<Integer, String> friends;
	private Hashtable<Integer, String> clusters;
	private Hashtable<Integer, Integer> clustersInternal;
	private Hashtable<Integer, String> members;
	private Hashtable<Integer, String> onlines;
	private ArrayList<String> messages;
	private int distNo;
	private int distType;	// 0 - normal user, 1 - cluster
	private String distName;
	private boolean onlineFinished = false;
	private BufferedWriter out;
	private boolean go;

	public TQ() {
		try {
			out = new BufferedWriter(new FileWriter("msg.log", true));
		} catch (Exception ex) {
			System.out.println("can not open log file, exit.");
			System.exit(-2);
		}
		if (!loadConfig()) {
			return;
		}

		try {
			state = 0;
			friends = new Hashtable<Integer, String>();
			clusters = new Hashtable<Integer, String>();
			clustersInternal = new Hashtable<Integer, Integer>();
			members = new Hashtable<Integer, String>();
			messages = new ArrayList<String>();
			onlines = new Hashtable<Integer, String>();
			distNo = 0;
			distName = "";
			distType = 0;
			go = false;
			
			user = new QQUser(qqno, qqpass);
			if (initHide) {
				user.setStatus(QQ.QQ_LOGIN_MODE_HIDDEN);
			}
			client = new QQClient();
			client.addQQListener(this);
			user.setUdp(udp);
			client.setUser(user);
			client.setLoginServer(server);
			if (useProxy) {
				client.setProxy(new InetSocketAddress(proxyServer, proxyPort));
				client.setProxyType(proxyType);
				if (!proxyUser.equals("")) {
					client.setProxyUsername(proxyUser);
					client.setProxyPassword(proxyPass);
				}
			}
			client.login();
		} catch (Exception e) {
			log(e);
			log("Init QQClient error, exit.");
		}
		
		log("Welcome to use TQ.\nAuthor: Achilles Xu\nSupport: [e-mail]");

		while (true) {
			if (state >= stepCount) {
				try {
						System.out.print(distName + ">");
					BufferedReader in = new BufferedReader(
							new InputStreamReader(System.in));
					String cmd = in.readLine().trim();
					processInput(cmd);
				} catch (Exception e) {
					log(e);
				}
			}
			try {
				Thread.sleep(500);
			} catch (Exception e) {
			}
		}
	}

	private void processInput(String cmd) {
		try {
			out.write(distName + ">" + cmd + "\n");
			out.flush();
		} catch (Exception ex) {}
		if (cmd.equals("")) {

		} else if (cmd.startsWith("/")) {
			processCommand(cmd.substring(1).toLowerCase());
		} else if (distNo != 0) {
			switch (distType) {
			case 0:
				client.sendIM(distNo, cmd);
				break;
			case 1:
				client.sendClusterIM(distNo, cmd);
				break;
			}
		}
		for(String msg : messages) {
			System.out.print(msg);
		}
		messages.clear();
	}

	private void processCommand(String cmd) {
		if (cmd.equals("exit") || cmd.equals("q") || cmd.equals("quit")) {
			System.exit(0);
		} else if (cmd.equals("friends")) {
			for (Map.Entry<Integer, String> entry : friends.entrySet()) {
				log(entry.getKey().toString() + "\t" + entry.getValue());
			}
		} else if (cmd.equals("clusters")) {
			for (Map.Entry<Integer, String> entry : clusters.entrySet()) {
				log(entry.getKey().toString() + "\t" + entry.getValue());
			}
		} else if (cmd.equals("clustersinternal")) {
			for (Map.Entry<Integer, Integer> entry : clustersInternal.entrySet()) {
				log(entry.getKey().toString() + "\t" + entry.getValue().toString());
			}
		} else if (cmd.equals("who")) {
			for (Map.Entry<Integer, String> entry : onlines.entrySet()) {
				log(entry.getKey().toString() + "\t" + entry.getValue());
			}
		} else if (cmd.startsWith("cd ")) {
			try {
				int nTemp = Integer.parseInt(cmd.substring(3));
				String sTemp = null;
				if ((sTemp = friends.get(nTemp)) != null) {
					distNo = nTemp;
					distName = String.valueOf(distNo + " " + sTemp);
					distType = 0;
				} else if (clusters.get(nTemp) != null && clustersInternal.get(nTemp) != null) {
					distNo = clustersInternal.get(nTemp);
					distName = String.valueOf(nTemp) + " " + clusters.get(nTemp);
					distType = 1;
				} else {
					log("invalid qq number!");
				}
			} catch (Exception ex) {
				log("wrong format! shoule be: /cd <qq number or cluster number>");
			}
		} else if (cmd.startsWith("m ")) {
			try {
				String[] sa = cmd.split("\\s+", 3);
				if (sa.length == 3) {
					int nTemp = Integer.parseInt(sa[1]);
					if (friends.get(nTemp) != null) {
						client.sendIM(nTemp, sa[2]);
					} else if (clusters.get(nTemp) != null && clustersInternal.get(nTemp) != null) {
						client.sendClusterIM(clustersInternal.get(nTemp), sa[2]);
					} else {
						log("invalid qq number!");
					}
				} else {
					throw new Exception("");
				}
			} catch (Exception ex) {
				log("wrong format! shoule be: /cd <qq number or cluster number>");
			}
		} else if (cmd.equals("go")) {
			go = true;
		} else if (cmd.equals("stop")) {
			go = false;
		} else {
			log("Command not found!");
		}
	}

	/**
	 * read config
	 */
	private boolean loadConfig() {
		try {
			Properties config = new Properties();
			config.load(new FileInputStream("config.ini"));
			server = config.getProperty("server");
			if (server == null || server.trim().equals("")) {
				throw new Exception("cannot find server in config file.");
			}
			if (config.getProperty("udp", "0").equals("1")) {
				udp = true;
			} else {
				udp = false;
			}

			qqno = Integer.parseInt(config.getProperty("qqno"));
			qqpass = config.getProperty("qqpass", "");
			if (config.getProperty("hide", "0").equals("1")) {
				initHide = true;
			} else {
				initHide = false;
			}
			if (config.getProperty("proxy", "0").equals("1")) {
				useProxy = true;
				proxyServer = config.getProperty("proxyserver", "");
				proxyPort = Integer.parseInt(config.getProperty("proxyport", ""));
				proxyUser = config.getProperty("proxyuser", "");
				proxyPass = config.getProperty("proxypass", "");
				proxyType = config.getProperty("proxytype", "None");
			} else {
				useProxy = false;
			}
			return true;
		} catch (Exception e) {
			log(e);
			log("Load config file error, program will exit.");
		}
		return false;
	}

	private void log(String msg) {
		lognw(msg + "\n");
	}

	private void lognw(String msg) {
		try {
	        out.write(msg);
	        out.flush();
	    } catch (Exception ex) {
	    }
		if (state >= stepCount && !go) {
			messages.add(msg);
		} else {
			System.out.print(msg);
		}
	}

	private void log(Exception e) {
		e.printStackTrace();
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		TQ tq = new TQ();
	}

	public void qqEvent(QQEvent e) {
		switch (e.type) {
		case QQEvent.QQ_LOGIN_SUCCESS:
			log("login succeeded, waiting for status change ......");
			state = 1;
			break;
		case QQEvent.QQ_LOGIN_PASSWORD_ERROR:
		case QQEvent.QQ_LOGIN_REDIRECT_NULL:
		case QQEvent.QQ_LOGIN_UNKNOWN_ERROR:
			log("login failed");
			System.exit(-1);
			break;
		case QQEvent.QQ_CHANGE_STATUS_SUCCESS:
			log("changed status ok.");
			if (state == 1) {
				state = 2;
				client.getFriendList();
				client.downloadFriend(0);
			}
			break;
		case QQEvent.QQ_CHANGE_STATUS_FAIL:
			log("changed status failed.");
			break;
		case QQEvent.QQ_GET_FRIEND_LIST_SUCCESS:
			processFriendList(e);
			break;
		case QQEvent.QQ_DOWNLOAD_GROUP_FRIEND_SUCCESS:
			processGroupFriend(e);
			break;
		case QQEvent.QQ_DOWNLOAD_GROUP_FRIEND_FAIL:
			log("download group friend failed");
			break;

		case QQEvent.QQ_GET_CLUSTER_INFO_SUCCESS:
			processClusterInfo(e);
			break;
		case QQEvent.QQ_GET_CLUSTER_INFO_FAIL:
			log("get cluster info error");
			break;
		case QQEvent.QQ_GET_MEMBER_INFO_SUCCESS:
			processMemberInfo(e);
			break;
		case QQEvent.QQ_GET_MEMBER_INFO_FAIL:
			log("get member info failed.");
			break;
		case QQEvent.QQ_RECEIVE_CLUSTER_IM:
			processClusterIM(e);
			break;
		case QQEvent.QQ_RECEIVE_NORMAL_IM:
			processNormalIM(e);
			break;
		case QQEvent.QQ_CONNECTION_BROKEN:
			log("connection lost, reconnecting...");
			try {client.login();} catch (Exception ex) {log(ex);}
			break;
		case QQEvent.QQ_CONNECTION_LOST:
			log("connection lost, reconnecting...");
			try {client.login();} catch (Exception ex) {log(ex);}
			break;
		case QQEvent.QQ_OPERATION_TIMEOUT:
			log("send message error, please try again.");
			break;
		case QQEvent.QQ_GET_FRIEND_ONLINE_SUCCESS:
			processFriendOnline(e);
			break;
		}
	}

	private void processFriendOnline(QQEvent e) {
		try {
			GetOnlineOpReplyPacket p = (GetOnlineOpReplyPacket) e.getSource();
			for (FriendOnlineEntry f : p.onlineFriends) {
				String qqName = friends.get(f.status.qqNum);
				if (qqName == null) qqName = "";
				onlines.put(f.status.qqNum, qqName);
			}
			if (!p.finished) {
				if (onlineFinished) {
					onlines.clear();
					onlineFinished = false;
				}
				client.getFriendOnline(p.position);
			} else {
				//log("get online friends ok.");
				onlineFinished = true;
				state ++;
			}
		} catch (Exception ex) {
			log(ex);
		}
		
	}

	private void processNormalIM(QQEvent e) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("MM-dd HH:mm");
			ReceiveIMPacket p = (ReceiveIMPacket) e.getSource();
			NormalIM m = p.normalIM;
			String senderName = friends.get(p.normalHeader.sender);
			if (senderName == null) senderName = "";
			log(sdf.format(new Date(p.normalHeader.sendTime)) + "["
					+ p.normalHeader.sender
					+ " "
					+ senderName
					+ "]"
					+ new String(m.messageBytes));
		} catch (Exception ex) {
			log(ex);
		}
		
	}

	private void processClusterIM(QQEvent e) {
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("MM-dd HH:mm");
			ReceiveIMPacket p = (ReceiveIMPacket) e.getSource();
			ClusterIM m = p.clusterIM;
			String sDate = sdf.format(new Date(m.sendTime));
			String clusterName = clusters.get(m.externalId);
			if (clusterName == null) {
				clusterName = "";
			}
			String senderName = members.get(m.sender);
			if (senderName == null) {
				senderName = "";
			}
			String msg = sDate + "["
					+ m.externalId
					+ " "
					+ clusterName
					+ "]["
					+ m.sender
					+ " "
					+ senderName
					+ "]"
					+ new String(m.messageBytes);
			log(msg);
		} catch (Exception ex) {
			log(ex);
		}
		
	}

	private void processMemberInfo(QQEvent e) {
		try {
			ClusterCommandReplyPacket p = (ClusterCommandReplyPacket) e.getSource();
			for (Object o : p.memberInfos) {
				QQFriend m = (QQFriend) o;
				members.put(m.qqNum, m.nick);
			}
		} catch (Exception ex) {
			log(ex);
		}
	}

	private void processClusterInfo(QQEvent e) {
		try {
			ClusterCommandReplyPacket p = (ClusterCommandReplyPacket) e
					.getSource();
			ClusterInfo info = p.info;
			clusters.put(info.externalId, info.name);
			clustersInternal.put(info.externalId, info.clusterId);
			client.getClusterMemberInfo(info.clusterId, p.members);
		} catch (Exception ex) {
			log(ex);
		}
	}

	private void processGroupFriend(QQEvent e) {
		try {
			DownloadGroupFriendReplyPacket p = (DownloadGroupFriendReplyPacket) e
					.getSource();
			for (DownloadFriendEntry entry : p.friends) {
				if (entry.isCluster()) {
					client.getClusterInfo(entry.qqNum);
				}
			}
			if (p.beginFrom != 0) {
				client.downloadFriend(p.beginFrom);
			} else {
				log("download cluster finished.");
				client.getFriendOnline();
				state ++;
			}
		} catch (Exception ex) {
			log(ex);
		}
	}

	private void processFriendList(QQEvent e) {
		try {
			GetFriendListReplyPacket p = (GetFriendListReplyPacket) e
					.getSource();
			for (QQFriend f : p.friends) {
				friends.put(f.qqNum, f.nick);
			}
			if (p.position != 0xFFFF) {
				client.getFriendList(p.position);
			} else {
				log("fetch friend list finished.");
				state++;
			}
		} catch (Exception ex) {
			log(ex);
		}
	}

}