client.java

有关手机游戏网络对战方面的源码

package unicoco;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Vector;

import javax.bluetooth.BluetoothStateException;
import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.UUID;
import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;
import javax.microedition.lcdui.Alert;
import javax.microedition.lcdui.AlertType;
import javax.microedition.lcdui.Choice;
import javax.microedition.lcdui.ChoiceGroup;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Gauge;
import javax.microedition.lcdui.StringItem;

public class Client extends Form implements CommandListener, Runnable,
		DiscoveryListener {
	Vector devices = new Vector(5);

	Vector services = new Vector(5);

	int[] transIDs;

	StreamConnection conn;

	Command connect;

	public final static UUID serviceUUID = new UUID(
			"da822f1b1b4d40c397c36286c753de77", false);

	static Client instance;

	Thread tClient;

	class ConnectThread extends Thread {
		public void run() {
			int i = cgHosts.getSelectedIndex();
			ServiceRecord sr = (ServiceRecord) services.elementAt(i);
			String url = sr.getConnectionURL(
					ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false);
			try {
				conn = (StreamConnection) Connector.open(url);
				dis = conn.openDataInputStream();
				dos = conn.openDataOutputStream();
				boolean authorized = dis.readBoolean();

				if (authorized) {
					SelectList.instance=null;
					OptionsForm.instance=null;
					System.gc();
					ConnectionControler.iniConnCtrl(dis, dos, conn);
					MIDGame.display.setCurrent(GameMainCanvas.getInstance(false));
				} else {
					// 释放资源和清理垃圾动作
					dos.close();
					dis.close();
					conn.close();
					deleteAll();
					removeCommand(connect);
					devices.removeAllElements();
					services.removeAllElements();
					for (int j = 0; j < transIDs.length; j++) {
						transIDs[i] = 0;
					}
					tClient = null;
					Alert refuseInfo = new Alert("Info", "You can't access host",
							null, AlertType.INFO);
					MIDGame.display.setCurrent(refuseInfo, SelectList.getInstance());
				}
			} catch (Exception e) {
//				e.printStackTrace();
				MIDGame.game.notifyDestroyed();
			}
		}
	}

	public void commandAction(Command c, Displayable d) {
		if (c.getLabel().equalsIgnoreCase("back")) {
			deleteAll();
			// 这里的interrupt()没有取消tClient中pending的IO操作
			if (tClient != null) {
				tClient.interrupt();
			}
			if (connect != null) {
				removeCommand(connect);
			}
			da.cancelInquiry(this);
			devices.removeAllElements();
			services.removeAllElements();
			if (transIDs != null) {
				for (int i = 0; i < transIDs.length; i++) {
					transIDs[i] = 0;
				}
			}
			tClient = null;
			if (dis != null) {
				try {
					dis.close();
					dos.close();
					conn.close();
				} catch (IOException e) {
//					e.printStackTrace();
					return;
				}
			}
			MIDGame.display.setCurrent(SelectList.getInstance());
		} else if (c.getLabel().equalsIgnoreCase("connect")) {
			deleteAll();
			append(new StringItem(" Info : ", "wait for Server respond..."));
			removeCommand(connect);
			new ConnectThread().start();
		}

	}

	DataOutputStream dos;

	DataInputStream dis;

	DiscoveryAgent da;

	ChoiceGroup cgHosts;

	public void run() {
		Gauge gauge = new Gauge("Searching...", false, Gauge.INDEFINITE,
				Gauge.CONTINUOUS_RUNNING);
		append(gauge);
		UUID[] uuidSet = new UUID[2];
		try {
			LocalDevice locald = LocalDevice.getLocalDevice();
			da = locald.getDiscoveryAgent();
			uuidSet[0] = new UUID(0x1101);
			uuidSet[1] = serviceUUID;
			synchronized (this) {
				da.startInquiry(DiscoveryAgent.GIAC, this);
				try {
					wait();
				} catch (InterruptedException e) {
					// 被用户中断直接返回
					// System.out.println("after startInquiry");
					// e.printStackTrace();
					return;
				}
			}
		} catch (BluetoothStateException e) {
//			e.printStackTrace();
			MIDGame.game.notifyDestroyed();
		}
		transIDs = new int[devices.size()];
		for (int i = 0; i < devices.size(); i++) {
			RemoteDevice rd = (RemoteDevice) devices.elementAt(i);
			try {
				transIDs[i] = da.searchServices(null, uuidSet, rd, this);
			} catch (BluetoothStateException e) {
//				e.printStackTrace();
				MIDGame.game.notifyDestroyed();
			}
		}
		synchronized (this) {
			try {
				wait();
			} catch (InterruptedException e) {
//				e.printStackTrace();
				return;
			}
		}
		String[] hosts = new String[services.size()];
		for (int i = 0; i < services.size(); i++) {
			try {
				hosts[i] = ((RemoteDevice) devices.elementAt(i))
						.getFriendlyName(false);
			} catch (IOException e) {
//				System.out.println("after two wait()");
//				e.printStackTrace();
				return;
			}
		}
		deleteAll();
		cgHosts = new ChoiceGroup("Host", Choice.EXCLUSIVE, hosts, null);
		append(cgHosts);
		connect = new Command("connect", Command.OK, 1);
		addCommand(connect);
	}

	public Client() {
		super("Client");
		setCommandListener(this);
		addCommand(new Command("back", Command.BACK, 1));
	}

	public void deviceDiscovered(RemoteDevice rd, DeviceClass dc) {
		if (devices.indexOf(rd) == -1) {
			devices.addElement(rd);
		}
	}

	public void inquiryCompleted(int arg0) {
		synchronized (this) {
			notify();
		}

	}

	public void servicesDiscovered(int arg0, ServiceRecord[] arg1) {
		for (int i = 0; i < arg1.length; i++) {
			services.addElement(arg1[i]);
		}
	}

	public void serviceSearchCompleted(int transID, int arg1) {
		for (int i = 0; i < transIDs.length; i++) {
			if (transIDs[i] == transID) {
				transIDs[i] = -1;
				break;
			}
		}
		for (int i = 0; i < transIDs.length; i++) {
			if (transIDs[i] != -1) {
				return;
			}
		}
		synchronized (this) {
			notify();
		}
	}

	public final static Client getInstance() {
		if (instance == null) {
			instance = new Client();
		}
		instance.tClient = new Thread(instance);
		instance.tClient.start();
		return instance;
	}
}