locprefixconnection.java

中国移动定位引擎的客户端

package ffcs.lbp.le;

import java.io.IOException;

import net.gleamynode.netty2.EventDispatcher;
import net.gleamynode.netty2.IoProcessor;
import net.gleamynode.netty2.Message;
import net.gleamynode.netty2.MessageRecognizer;
import net.gleamynode.netty2.Session;
import ffcs.lbp.LbpMessage;
import ffcs.lbp.common.ConnConfigMBean;
import ffcs.lbp.common.Connection;
import ffcs.lbp.common.InteIOProcess;
import ffcs.lbp.common.LbpMessageAdapter;
import ffcs.lbp.common.Result;
import ffcs.lbp.common.LbpUtil;
import ffcs.lbp.le.message.*;
import ffcs.lbp.le.message.Link;
import ffcs.lbp.le.message.LinkRsp;
import ffcs.lbp.le.message.Login;
import ffcs.logging.Log;
import ffcs.logging.LogFactory;

/**
* <p>Title: 小区推送LBP项目</p>
* <p>Description:
*   与MSPGW的连接类，该类实现与MSPGW的发送与接收包,
* 
* </p>
* <p>Copyright: 2008 福建福富软件技术股份有限公司 </p>
* <p>Company: 福建福富软件技术股份有限公司</p>
* @author chenxin
* @version $Rev:1.0 $Date: 2008-02-17
*/

public class LocPrefixConnection extends Connection {
    private Log log = LogFactory.getLog(LocPrefixConnection.class);
	// 登录包
	private Login LoginPDU = null;
	// 链路测试包
	private Link link = new Link();
	// 链路测试应答包
	private LinkRsp linkRsp = new LinkRsp();

	private InteIOProcess inteIoProcess = null;
	


    /**
     * 构造函数
     * @param config 配置信息
     * @param msgEncoder　封包，实现字节转成消息对象
     * @param inteIoProcess　接口IO管理类
     */
	public LocPrefixConnection(ConnConfigMBean config, MessageRecognizer msgEncoder,
			InteIOProcess inteIoProcess) throws IOException {
		super.setConfig(config);
		super.setMsgRecognizer(msgEncoder);
		setBindMode(config.getLoginMode());
		this.inteIoProcess = inteIoProcess;
		
	}

    /**
     * 构造函数
     * @param config 配置信息
	 * @param ioPro IO处理实例，负责连接的读入和写出处理
	 * @param eventDis 负责连接事件的触发和调度
     * @param msgEncoder　封包，实现字节转成消息对象
     * @param inteIoProcess　接口IO管理类
     */
	public LocPrefixConnection(ConnConfigMBean config, IoProcessor ioPro,
			EventDispatcher eventDis, MessageRecognizer msgEncoder,
			InteIOProcess inteIoProcess)  {
		super.setConfig(config);
		super.setIoProcessor(ioPro);
		super.setEventDispatcher(eventDis);
		super.setMsgRecognizer(msgEncoder);
		setBindMode(config.getLoginMode());
		this.inteIoProcess = inteIoProcess;
		
	}
	/**
	 * 登录操作,参考{@link #login(long timeOut)}
	 * @return Result　返回结果,
	 */
	public Result login() {
		return login(getConfig().getConnTimeOut());
	}

	/**
	 * 登录方法，当连接作为客户端时，子类必须实现， 如果是服务端子类可以实现一个空方法, 通常连接建立后，必须立即登录以防止服务端超时 Usage:
	 * @param timeOut  登录超时时间（接收登录应答包的时间）
	 * @return Result 返回结果
	 */
	public Result login(long timeOut) {
/*		try {
			LoginPDU = createBind(getBindMode());
			LoginPDU.setSequence(SmUtil.getNextSmscSeqNum());
			LoginPDU.setSystemId(getConfig().getLoginId());
			LoginPDU.setPassword(getConfig().getLoginPassword());
		} catch (InvalidParameterValueException e) {
			throw new IllegalStateException("create Bind package error: " + e.getMessage());
		}
		Result result = new Result();
		
		LbpMessage m = sendRequestForRep(LoginPDU.getSequence(), LoginPDU, timeOut);

		// 如果为空，则接收登录应答包超时
		if (m == null) {
			result.setStatus(Result.ERR_TIMEOUT);
			result.setDesc("登录到实体"  + this +")不成功，登录包："+LoginPDU+ " 原因:应答包超时");
			return result;
		}

		BindResp bindResp = (BindResp) (m);
		
		// 如果状态码不为0代表登录失败
		if (bindResp.getCommandStatus() != 0) {
			super.setConnStatus(DISCONNECT);
			result.setStatus(bindResp.getCommandStatus());
			result.setDesc("登录到MSPGW失败，错误代码为：" + bindResp.getCommandStatus());
		} else {
			result.setDesc("登录成功"+ bindPDU + this);
			super.setConnStatus(LOGGIN_ON);
		}
		return result;*/
		Result result = new Result();
		return result;
	}


	/**
	 * 发送链路测试功能,
	 * @return boolean <code>true</code> 链路测试成功 <code>false</code> 链路测试失败
	 */
	public boolean Link() {
		link.setSequenceId(LbpUtil.getNextSeqNum());
        //设置最后的链路测试时间，无论发送任何数据包，都把当时的时间设置为最后的链路测试时间
		this.setLastLinkTime(System.currentTimeMillis());
		return super.sendMessage(link);
	}

	/**
	 * 发送链路测试功能
	 * @param timeOut 链路测试超时时间，如果超时return false
	 * @return <code>true</code> 链路测试成功 <code>false</code> 链路测试失败
	 */
	public boolean Link(long timeOut)  {
		link.setSequenceId(LbpUtil.getNextSeqNum());
		LbpMessage m = sendRequestForRep(link.getPackFlag(), link, timeOut);
	    //设置最后的链路测试时间，无论发送任何数据包，都把当时的时间设置为最后的链路测试时间
		this.setLastLinkTime(System.currentTimeMillis());
		// 如果为空，则接收登录应答包超时
		if (m == null) {
			return false;
		} else {
			return true;
		}
	}

	/**
	 * 当接收到对方发过来的链路测试请求包时，回链路测试应答包
	 * @param seqnum 对链路测试包对应的seqnum
	 * @return boolean <code>true</code> 应答成功 <code>false</code> 应答失败
	 */
	public boolean enquireLinkResp(int seqnum) {
		// 防止多线程时，修改了linkResp包中的sequence_number字段
		boolean b = true;
		synchronized (linkRsp) {
			linkRsp.setSequenceId(seqnum);
			b = super.sendMessage(linkRsp);
		}
		return b;
	}

	/** 
	 * 接收消息事件的方法，
	 * @param session　接收消息的会话
	 * @param message 具体的消息
	 */
	public void messageReceived(Session session, Message message) {
		if (message == null) {
			return;
		}
       LbpMessageAdapter lmMsg = (LbpMessageAdapter)message;
		
		//这时的SMPP消息还没解析到具体的子类，只解析到包HEAD部份,要进一步解析才行
       LbpMessage lbpmsg = lmMsg.getLbpMessage();
		
		if(log.isDebugEnabled()){
			log.debug("消息来自" + this  + lbpmsg);
		}
		if (log.isInfoEnabled()) {
			log.info("消息来自[" + getConnName() + "]:"  + lbpmsg.getSimpleInfo());
		}
		if (log.isTraceEnabled()) {
			log.info("消息来自[" + getConnName() + "]:"  + lbpmsg.getSimpleInfo());
		}
		setLastReceiveTime(System.currentTimeMillis());
		clearLinkFail();//链路测试清零
		switch (lbpmsg.getCommandId()) {
	/*	case LeMessage.AddLocUser:
			addReceiveFlux();
			inteIoProcess.receivedFromLocInfoMgr(this,lbpmsg);
			break;
		case LeMessage.CycLoc:
			
			inteIoProcess.receivedFromLocInfoMgr(this,lbpmsg);
			break;
		case LeMessage.CycLocStop:
			addReceiveFlux();
			inteIoProcess.receivedFromLocInfoMgr(this,lbpmsg);
			break;
		case LeMessage.DelLocUser:
			addReceiveFlux();
			inteIoProcess.receivedFromLocInfoMgr(this,lbpmsg);
			break;
		case LeMessage.Dstan:
			addReceiveFlux();
			inteIoProcess.receivedFromLocInfoMgr(this,lbpmsg);
			break;
		case LeMessage.GetUserLoc:
			addReceiveFlux();
			inteIoProcess.receivedFromLocInfoMgr(this,lbpmsg);
			break;*/
		case LeMessage.Link:
			setLastLinkTime(System.currentTimeMillis());
			enquireLinkResp(lbpmsg.getSequenceId());
			break;
		case LeMessage.LinkRsp:
			checkWaitPacket(lbpmsg.getSequenceId(), lbpmsg);
			break;
		case LeMessage.Login:
			break;
			/*case LeMessage.StdLoc:
			addReceiveFlux();
			inteIoProcess.receivedFromLocInfoMgr(this,lbpmsg);
			break;
		case LeMessage.TriArea:
			addReceiveFlux();
			inteIoProcess.receivedFromLocInfoMgr(this,lbpmsg);
			break;
		case LeMessage.TriAreaStop:
			addReceiveFlux();
			inteIoProcess.receivedFromLocInfoMgr(this,lbpmsg);
			break;
		default:
			log.warn("unknow message command_id"+lbpmsg.getCommandId());
			break;*/
		default:
			inteIoProcess.receivedFromLocInfoMgr(this,lbpmsg);
			break;
		}
	}

	/** 
　　　*　取得接口IO管理类
	 * @return InteIOProcess 接口IO管理类
	 */
	public InteIOProcess getInteIoProcess() {
		return inteIoProcess;
	}
	/**
	 * 设备得接口IO管理类
	 * @param inteIOProcess  接口IO管理类
	 */
	public void setInteIOProcess(InteIOProcess inteIOProcess) {
		this.inteIoProcess = inteIOProcess;
	}

	public String toString() {
		StringBuffer sb = new StringBuffer(100);
		sb.append('[');
		sb.append(super.toString());
		sb.append(']');

		return sb.toString();
	}

}