network.java

J2ME手机游戏50例

package demo;
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.io.StreamConnectionNotifier;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.GameCanvas;
import javax.microedition.lcdui.game.Sprite;


public class NetWork implements DiscoveryListener {
	public static final int NETWORK_BUTTON			= 0;	//选择按钮
	//客户端状态
	public static final int NETWORK_FINDDEVICE		= 1;	//查找设备
	public static final int NETWORK_DEVICEFINDING		= 2;	//正在查找设备
	public static final int NETWORK_FINDSERVICE		= 3;	//查找服务
	public static final int NETWORK_SERVICEFINDING	= 4;	//正在查找服务
	public static final int NETWORK_NETSEL			= 5;	//选择网络
	//服务器端状态
	public static final int NETWORK_BUILDSERVER		= 6;	//建立服务
	public static final int NETWORK_LISTENCLIENT		= 7;	//监听客户
	//公共状态
	public static final int NETWORK_WRONG				= 8;	//没有网络
	public static final int NETWORK_GAME				= 9;	//游戏状态
	public static final int NETWORK_STATE_NUM			= 10;	//状态总数
	private int m_nState = NETWORK_BUTTON;
	
	private Sprite		m_NetButtonSp;							//联网按钮
	private int		m_nBnSel;								//当前选择的按钮
	private int		m_nCurNet;								//当前选择的网络
	public 	boolean	m_bServer;								//是否是服务器
	private DataInputStream m_InputDs;
	private DataOutputStream m_OutputDs;
	
	private StreamConnectionNotifier m_Notifier;
	private StreamConnection m_Conn;
	
	//响应服务的UUID 
	private static final UUID BTFIVE_UUID = new UUID( 
            "F0E0D0C0B0A000908476605040302015", false); 
	private DiscoveryAgent m_Agent; 
	
	private Vector m_Devices = new Vector(); 			//设备集合
	private Vector m_Records = new Vector();			//服务集合  
	     
	int[] m_TransIDs;									//服务搜索的事务id集合 
	
	public NetWork(){
		try{
			Image img = Image.createImage("/demo/conbutton.png");
			m_NetButtonSp = new Sprite(img, 53, 21);
		}
		catch (Exception ex){}
	}
	public void setState( int state ){
		if( state < 0 || state >= NETWORK_STATE_NUM )
			return;
		m_nState = state;
	}
	public int getState(){
		return m_nState;
	}
	/*****
	 * 联网界面中，处理按键的输入
	 * @参数 keyStates.....当前的按键状态
	 * @返回所选联网按钮的类型
	 */
	public int Input( int keyStates, Grids grid ){
		switch( m_nState ){
		case NETWORK_BUTTON:						//选择按钮
			{
				if( ( keyStates & GameCanvas.UP_PRESSED ) != 0 )
					m_nBnSel --;
				if( ( keyStates & GameCanvas.DOWN_PRESSED ) != 0 )
					m_nBnSel ++;
				if( m_nBnSel < 0 )
					m_nBnSel = 0;
				if( m_nBnSel >= m_NetButtonSp.getFrameSequenceLength() )
					m_nBnSel = m_NetButtonSp.getFrameSequenceLength() - 1;
				if( ( keyStates & GameCanvas.FIRE_PRESSED ) != 0 ){
					if( m_nBnSel == 0 ){
						m_bServer = true;
						setState(NETWORK_BUILDSERVER);
					}
					else{
						m_bServer = false;
						setState(NETWORK_FINDDEVICE);
					}
				}
			}
			break;
		case NETWORK_NETSEL:						//选择服务
			{
				if( ( keyStates & GameCanvas.UP_PRESSED ) != 0 )
					m_nCurNet --;
				if( ( keyStates & GameCanvas.UP_PRESSED ) != 0 )
					m_nCurNet ++;
				if( m_nCurNet < 0 )
					m_nCurNet = 0;
				if( m_nCurNet >= m_Records.size() )
					m_nCurNet = m_Records.size() - 1;
				if( ( keyStates & GameCanvas.FIRE_PRESSED ) != 0 ){
					ServiceRecord sr=(ServiceRecord)m_Records.elementAt(m_nCurNet);
					if( accessService(sr) ){
						setState(NETWORK_GAME);
						grid.m_nNetState = Grids.NET_WAIT;
					}
					else
						setState(NETWORK_WRONG);
				}
			}
			break;
		case NETWORK_GAME:							//进行游戏
			return grid.NetInput(keyStates, this);
		}
		return 0;
	}
	public void Logic(){
		switch( m_nState ){
		case NETWORK_FINDDEVICE:					//查找设备
			{
				try { 
		            LocalDevice localDevice = LocalDevice.getLocalDevice(); 
		            m_Agent = localDevice.getDiscoveryAgent(); 
		        } 
		        catch( BluetoothStateException e ){
		        	e.printStackTrace();
		        	setState(NETWORK_WRONG);
		        	return;
		        }
		        try { 
		        	m_Agent.startInquiry(DiscoveryAgent.GIAC, this); 
		        } 
		        catch (BluetoothStateException e) {
		        	e.printStackTrace();
		        	setState(NETWORK_WRONG);
		        	return;
		        }
		        setState(NETWORK_DEVICEFINDING);
			}
			break;
		case NETWORK_FINDSERVICE:					//查找服务
			{
				UUID[] uuidSet = new UUID[1];  
		        uuidSet[0] = BTFIVE_UUID; 
				m_TransIDs = new int[m_Devices.size()]; 
		        for (int i = 0; i < m_Devices.size(); i++) { 
		            RemoteDevice rd = (RemoteDevice) m_Devices.elementAt(i); 
		            try { 
		                //记录每一次服务搜索的事务id 
		            	m_TransIDs[i] = m_Agent.searchServices(null, uuidSet, 
		                        rd, this); 
		            } 
		            catch (BluetoothStateException e) { 
		                continue; 
		            } 
		        } 
		        setState(NETWORK_SERVICEFINDING);
			}
			break;
		case NETWORK_BUILDSERVER:					//建立服务
			{
				try { 
					LocalDevice localDevice = LocalDevice.getLocalDevice(); 

					if (!localDevice.setDiscoverable(DiscoveryAgent.GIAC)) { 
						setState(NETWORK_WRONG);
						return;
					} 
					StringBuffer url = new StringBuffer("btspp://"); 
					url.append("localhost").append(':'); 
					url.append(BTFIVE_UUID.toString()); 
					url.append(";name=BTFIVE Server"); 
					url.append(";authorize=false"); 
					m_Notifier = (StreamConnectionNotifier) Connector 
				           .open(url.toString());  
				} 
				catch (Exception e) { 
					e.printStackTrace(); 
					setState(NETWORK_WRONG);
					return;
				}
				setState(NETWORK_LISTENCLIENT);
			}
			break;
		case NETWORK_LISTENCLIENT:					//监听客户
			{
				try{ 
					m_Conn = m_Notifier.acceptAndOpen(); 
				} 
				catch (IOException e) {
					return;
				} 
				setState(NETWORK_GAME);
			}
			break;
		}
	}
	public void Paint(Graphics g, int scrWidth, int scrHeight){
		switch( m_nState ){
		case NETWORK_BUTTON:
			{
				int x = scrWidth/2 - m_NetButtonSp.getWidth()/2;
				int y = scrHeight/2 - m_NetButtonSp.getHeight();
				for( int n = 0; n < 2; n ++ ){
					if( n == m_nBnSel )
						m_NetButtonSp.setFrame(n);
					else
						m_NetButtonSp.setFrame(n+2);
					m_NetButtonSp.setPosition(x, y);
					m_NetButtonSp.paint(g);
					y = y + m_NetButtonSp.getHeight();						
				}
			}
			break;
		case NETWORK_FINDDEVICE:
		case NETWORK_DEVICEFINDING:
			g.drawString("正在查找设备...", scrWidth/2 - 20, scrHeight/2, 0);
			break;
		case NETWORK_FINDSERVICE:
		case NETWORK_SERVICEFINDING:
			g.drawString("正在查找服务...", scrWidth/2 - 20, scrHeight/2, 0);
			break;
		case NETWORK_NETSEL:
			int x = scrWidth/2 - 40;
			int y = 20;
			g.drawString("请选择网络...", scrWidth/2 - 20, scrHeight/2, 0);
			y = y + 30;
			for( int n = 0; n < m_Records.size() && n < 5; n ++ ){
				ServiceRecord sr = (ServiceRecord)m_Records.elementAt(n);
				g.drawString(sr.toString(), x, y, 0);
				if( n == m_nCurNet ){
					g.drawRect(x-1, y-1, scrWidth - (x * 2), g.getFont().getHeight() );
				}
				y = y + 20;
			}
			break;
		case NETWORK_BUILDSERVER:
			g.drawString("正在建立服务...", scrWidth/2 - 30, scrHeight/2-20, 0);
			break;
		case NETWORK_LISTENCLIENT:
			g.drawString("等待客户连接...", scrWidth/2 - 30, scrHeight/2-20, 0);
			break;
		case NETWORK_WRONG:
			g.drawString("网络出错...", scrWidth/2 - 30, scrHeight/2-20, 0);
			try {
				if( m_OutputDs != null ){
					m_OutputDs.close();
					m_OutputDs = null;
				}
				if( m_InputDs != null ){
					m_InputDs.close();
					m_InputDs = null;
				}
			} catch (IOException e) {
				e.printStackTrace();
			} 
			break;
		}
	}
	
	public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) { 
		
		if (m_Devices.indexOf(btDevice) == -1) { 
			m_Devices.addElement(btDevice); 
		} 
	} 
	/** 
	 * 回调方法，唤醒初始化线程 
	 */ 
	public void inquiryCompleted(int discType) { 
		setState(NETWORK_FINDSERVICE);
	} 
	/** 
	 * 回调方法 
	 */ 
	public void servicesDiscovered(int transID, ServiceRecord[] servRecord) { 
	    for (int i = 0; i < servRecord.length; i++) { 
	        m_Records.addElement(servRecord[i]); 
	    } 
	} 
	/** 
	 * 回调方法，唤醒初始化线程 
	 */ 
	public void serviceSearchCompleted(int transID, int respCode) { 
	     
	    for (int i = 0; i < m_TransIDs.length; i++) { 
	        if (m_TransIDs[i] == transID) { 
	        	m_TransIDs[i] = -1; 
	            break; 
	        } 
	    } 
	     
	    //如果所有的设备都已经搜索服务完毕，则唤醒初始化线程。 
	    boolean finished = true; 
	    for (int i = 0; i < m_TransIDs.length; i++) { 
	        if (m_TransIDs[i] != -1) { 
	            finished = false; 
	            break; 
	        } 
	    } 
	    if (finished) { 
	    	if( m_Records.size() > 0 )
	    		setState(NETWORK_NETSEL);
	    	else
	    		setState(NETWORK_WRONG);
	    } 
	} 
	//连接服务
	private boolean accessService(ServiceRecord sr){  
		boolean bResult = true;
		try { 
			String url = sr.getConnectionURL( 
                    ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false); 
            m_Conn = (StreamConnection) Connector.open(url);             
        } catch (IOException e) { 
             e.printStackTrace();
             bResult = false;
        } 
        return bResult;
    } 
	//发送数据
	public void SendData( byte[] data ){
		try {
			if( m_OutputDs == null )
				m_OutputDs = m_Conn.openDataOutputStream();
			m_OutputDs.write(data);
		} catch (IOException e) {
			e.printStackTrace();
			setState(NETWORK_WRONG);
		} 
	}
	//接收数据
	public void ReadData( byte[] data ){
		try {
			if( m_InputDs == null )
				m_InputDs = m_Conn.openDataInputStream();
			m_InputDs.read(data);
		} catch (IOException e) {
			e.printStackTrace();
			setState(NETWORK_WRONG);
		} 
	}
}