user.java

简单的基于java的音频聊天系统 p2p模式 喜欢大家喜欢

package org.phyeas.server;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 每一个连接表示一个用户
 * 
 * @author _phyeas
 * 
 */
public class User implements Runnable {
	private Socket socket;
	private Server server;
	private int bufferSize;

	private int id;
	private String name;
	private Group currentGroup;

	/**
	 * 现在所在的group
	 * 
	 * @return
	 */
	public Group getCurrentGroup() {
		return currentGroup;
	}

	public void setCurrentGroup(Group currentGroup) {
		this.currentGroup = currentGroup;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	private InputStream in;
	private OutputStream out;

	private boolean stop;

	public boolean isStop() {
		return stop;
	}

	public void setStop(boolean stop) {
		this.stop = stop;
	}

	// ************** server ********
	public Server getServer() {
		return server;
	}

	public void setServer(Server server) {
		this.server = server;
	}

	// ************** server ********
	/**
	 * 无参数 构造USER
	 */
	public User() {
	}

	/**
	 * 构造一个已连接的USER
	 * 
	 * @param socket
	 */
	public User(Socket socket) {
		setSocket(socket);
	}

	/**
	 * 构造一个已连接的USER
	 * 
	 * @param socket
	 *            套接字
	 * @param server
	 *            服务器
	 */
	public User(Socket socket, Server server) {
		this(socket);
		setServer(server);
	}

	/**
	 * 构造一个已连接的USER
	 * 
	 * @param socket
	 *            套接字
	 * @param server
	 *            服务器
	 * @param bufferSize
	 *            缓冲大小。默认是1024
	 */
	public User(Socket socket, Server server, int bufferSize) {
		this(socket, server);
		this.bufferSize = bufferSize;
	}

	/**
	 * 获取连接套接字
	 * 
	 * @return 套接字
	 */
	public Socket getSocket() {
		return socket;
	}

	/**
	 * 设置套接字
	 * 
	 * @param socket
	 */
	public void setSocket(Socket socket) {
		this.socket = socket;
	}

	/**
	 * 开始接收客户数据
	 */
	public void start() {
		Thread thread = new Thread(this);
		thread.start();
	}

	/**
	 * 停止接收
	 */
	public void stop() {
		setStop(true);
	}

	/**
	 * 向客户端发送数据
	 * 
	 * @param data
	 *            数据
	 * @param off
	 *            偏移量
	 * @param len
	 *            长度
	 */
	public void send(byte[] data, int off, int len) {

		if (socket != null) {
			try {
				if (out == null) {
					out = socket.getOutputStream();
				}
				out.write(data, off, len);
			} catch (Exception ex) {
				// ex.printStackTrace();
			}
		} else {
			System.out.println("socket为空...");
		}
	}

	/**
	 * 向客户端发送数据
	 * 
	 * @param data
	 *            数据
	 */
	public void send(byte[] data) {
		send(data, 0, data.length);
	}

	public void run() {
		try {
			if (socket != null) {
				in = socket.getInputStream();
				if (bufferSize <= 0)
					bufferSize = 1024;
				byte[] buffer = new byte[bufferSize];
				while (!isStop()) {
					int size = in.read(buffer);
					ByteArrayOutputStream bo = new ByteArrayOutputStream();
					bo.write(buffer, 0, size);
					byte[] data = bo.toByteArray();
					if (data.length > 2
							&& (data[0] == Byte.MIN_VALUE && data[1] == Byte.MAX_VALUE)) {
						for (int i = 0; i < data.length; i++) {
							if (data[i] == Byte.MIN_VALUE
									&& data[i + 1] == Byte.MAX_VALUE) {
								int j = i;
								List<Byte> lstData = new ArrayList<Byte>();
								for (; i < data.length; i++) {
									if (data[i] == Byte.MIN_VALUE
											&& data[i + 1] == Byte.MAX_VALUE
											&& i != j) {
										i--;
										break;
									}
									lstData.add(data[i]);
								}
								byte[] b = new byte[lstData.size()];
								for (int k = 0; k < b.length; k++) {
									b[k] = lstData.get(k);
								}
								server.revice(b, this);
							}
						}
					} else {
						server.revice(data, this);
					}
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}