cmpp_yx.java

短信cmpp2.0源码

                byte[] send = new byte[9];
                System.arraycopy(Tools.long2byte(resp.nMsgId),0,send,0,8);
                send[8]=(byte)resp.nResult;
                try {
                    sendPacket(resp,send);
                }
                catch (IOException ex) {
                    throw ex;
                }
                back.stat=stat;
                backMsg=back;
                break;
            case COMMAND_CMPP_SUBMIT_RESP:
                CMPPSubmitMessageResp sResp = new CMPPSubmitMessageResp();
                if(msg==null) stat=SUBMIT_MSG_NULL_ERROR;
                else{
                    try {
                        byte id[]= new byte[8];
                        System.arraycopy(msg,0,id,0,8);
                        sResp.setMsgID(id);
                        sResp.nResult= msg[8];
                        stat=msg[8];
                    }
                    catch (Exception ex) {
                        stat=SUBMIT_MSG_FORMAT_ERROR;
                    }
                }
                sResp.stat=stat;
                backMsg=sResp;
                break;
            case COMMAND_CMPP_ACTIVE_TEST:
                CMPPActiveTestMessageResp respMsg=new CMPPActiveTestMessageResp();
                respMsg.nSequenceID=head.nSequenceID;
                try {
                    sendHead(respMsg);
                }
                catch (IOException ex) {
                    throw ex;
                }
                break;
            case COMMAND_CMPP_ACTIVE_TEST_REP:
                break;
            case COMMAND_CMPP_TERMINATE:
                CMPPHead out= new CMPPHead();
                out.nMsgSize=12;
                out.nCommandID=COMMAND_CMPP_TERMINATE_RESP;
                out.nSequenceID=head.nSequenceID;
                try {
                    sendHead(out);
                }
                catch (IOException ex) {
                    throw ex;
                }
                break;
            case COMMAND_CMPP_TERMINATE_RESP:
                break;
            default:
                stat=CMPP_UNKNOWN_PACKAGE_ERROR;
        }
        backMsg.nCommandID=head.nCommandID;
        backMsg.nMsgSize=head.nMsgSize;
        backMsg.nSequenceID=head.nSequenceID;
        backMsg.stat=stat;
        return backMsg;
    }

    public void deliver()throws IOException{
        try {
            if(!activeTest("auto"))
                throw new IOException();
            CMPPHead back = Deliver();
            if(back.nCommandID==this.COMMAND_CMPP_DELIVER){
                deliverMsgList.addElement(((CMPPDeliverMessage)back).getDeliverMsg());
                return;
            }
            if(back.nCommandID==this.COMMAND_CMPP_TERMINATE){
                close();
                throw new IOException();
            }
        }
        catch (IOException ex) {
            close();
            throw ex;
        }
    }


    //收取网关下发信息
    private CMPPHead Deliver()throws IOException{
        CMPPHead head = new CMPPHead();
        byte[] bMsg=null;
        int i=0;
        while(true){
            try {
                bMsg=read(head);
            }
            catch (InterruptedIOException ex) {
                if(i==3){
                    head.stat=DELIVER_MSG_TIME_OUT;//由于没有消息而退出－－stat=1
                    break;
                }else{
                    i++;
                     continue;
                }
            }
            catch (IOException ex) {
                throw ex;
            }
            try {
                head = dealMsg(head,bMsg);
            }
            catch(IOException ex){
                throw ex;
            }
            catch (Exception ex) {
                Log.printBytes(bMsg,logFile);
                Log.printError(ex,"",logFile);
            }
            if(head.nCommandID==this.COMMAND_CMPP_ACTIVE_TEST){
                continue;
            }
            break;
        }
        return head;
    }

    //向网关查询信息流量
    public CMPPQueryMessageResp Query(){
        CMPPQueryMessage queryMessage = new CMPPQueryMessage();
        CMPPQueryMessageResp queryResp = new CMPPQueryMessageResp();

        return queryResp;
    }

    //发送测试信息
    private boolean activeTest(String flag)throws IOException{
        boolean testFlag=false;
        if(flag==null||(int)(System.currentTimeMillis()/1000)-checkTime>10)
            testFlag=true;
        if(testFlag){
            CMPPActiveTestMessage test = new CMPPActiveTestMessage();
            sendOut=test.setSequenceID(sendOut);
            test.nMsgSize=12;
            try {
                sendHead(test);
            }
            catch(IOException e){
                sendOut--;
                return false;
            }
            try {
                while(true){
                    CMPPHead back = Deliver();
                    if(back.nCommandID==this.COMMAND_CMPP_DELIVER){
                        deliverMsgList.addElement(((CMPPDeliverMessage)back).getDeliverMsg());
                        continue;
                    }
                    if(back.stat==this.DELIVER_MSG_TIME_OUT){
                        throw new IOException();
                    }
                    if(back.nCommandID==this.COMMAND_CMPP_ACTIVE_TEST_REP){
                        checkTime=(int)(System.currentTimeMillis()/1000);
                        break;
                    }
                }
            }
            catch (IOException ex) {
                return false;
            }
            return true;
        }
        return true;
    }
    public boolean activeTest()throws IOException{
        return activeTest(null);
    }

    private int getDeliverMessage(CMPPDeliverMessage msg,byte[] content)throws Exception{
        if(msg==null)
            return DELIVER_MSG_NULL_ERROR;
        int stat=CMPP_SUCCESS;
        //把content解析成所需信息
        byte msgID[] = new byte[8];
        byte sDestTermID[] = new byte[21];
        byte sServiceID[] = new byte[10];
        byte cTpPid=0;
        byte cTpUdhi=0;
        byte nMsgFormat=0;
        byte sSrcTermID[] = new byte[21];
        byte nIsReply=0;
        byte nMsgLen=0;
        byte sMsgContent[]=null;
        try {
            System.arraycopy(content,0,msgID,0,8);
            System.arraycopy(content,8,sDestTermID,0,21);
            System.arraycopy(content,29,sServiceID,0,10);
            cTpPid = content[39];
            cTpUdhi = content[40];
            nMsgFormat = content[41];
            System.arraycopy(content,42,sSrcTermID,0,21);
            nIsReply = content[63];
            nMsgLen = content[64];
            if(nMsgLen< 0)
                nMsgLen += 256;
            sMsgContent= new byte[nMsgLen];
            System.arraycopy(content,65,sMsgContent,0,nMsgLen);
        }
        catch (Exception ex) {
            return DELIVER_MSG_FORMAT_ERROR;
        }
        /////////////////////////////////////////封装正常消息
        msg.setMsgID(msgID);
        msg.msgID=Tools.byte2long(msgID);
        msg.nIsDelivery=nIsReply;
        msg.nMsgFormat=nMsgFormat;
        msg.nMsgLength=nMsgLen;
        msg.nTPpid=cTpPid;
        msg.nTPudhi=cTpUdhi;
        msg.sDestId=new String(sDestTermID).trim();
        msg.sServiceId=new String(sServiceID).trim();
        msg.sSrcTerminalId=new String(sSrcTermID).trim();
        try {
            if(nIsReply==0){
                if(nMsgFormat == 8){//ucs2编码格式
                    msg.sMsgContent = new String(sMsgContent,"iso-10646-ucs-2");

                }else{
                    msg.sMsgContent=new String(sMsgContent,"gb2312");
                }
            }
        }
        catch (Exception ex) {
            return DELIVER_MSG_FORMAT_DECODE_ERROR;
        }
        /////////////////////////////状态报告中所需字段
        if(nIsReply==1){
            try {
                byte msgReportID[]=new byte[8];
                System.arraycopy(sMsgContent,0,msgReportID,0,8);
                msg.setReportMsgId(msgReportID);
                //msg.nReportMsgId=Tools.byte2long(sMsgContent,0);
                msg.sStat=new String(sMsgContent,8,7).trim();
                msg.sSubmitTime=new String(sMsgContent,15,10).trim();
                msg.sDoneTime=new String(sMsgContent,25,10).trim();
                msg.sDestTerminalId=new String(sMsgContent,35,21).trim();
                msg.nSMSCSequence=Tools.byte2int(sMsgContent,56);
            }
            catch (Exception ex) {
                stat=DELIVER_MSG_FORMAT_REPORT_ERROR;
            }
        }
        return stat;
    }

    private void sendHead(CMPPHead head)throws IOException{
        byte[] send = new byte[12];
        System.arraycopy(Tools.int2byte(head.nMsgSize),0,send,0,4);
        System.arraycopy(Tools.int2byte(head.nCommandID),0,send,4,4);
        System.arraycopy(Tools.int2byte(head.nSequenceID),0,send,8,4);
        send(send);
    }
    private void sendPacket(CMPPHead head,byte[] msg)throws IOException{
        byte[] send = new byte[12+msg.length];
        head.nMsgSize=12+msg.length;
        System.arraycopy(Tools.int2byte(head.nMsgSize),0,send,0,4);
        System.arraycopy(Tools.int2byte(head.nCommandID),0,send,4,4);
        System.arraycopy(Tools.int2byte(head.nSequenceID),0,send,8,4);
        System.arraycopy(msg,0,send,12,msg.length);
        send(send);
    }
    private void send(byte[] msg)throws IOException{
        DataOutputStream out = creatOutputStream();
        out.write(msg);
        out.flush();
    }

    private byte[] read(CMPPHead head)throws InterruptedIOException,IOException{
        DataInputStream in =creatInputStream();
        head.nMsgSize=in.readInt();
        head.nCommandID=in.readInt();
        head.nSequenceID=in.readInt();
        byte[] resp = null;
        if(head.nMsgSize<=12){
            return null;
        }else{
            resp=new byte[head.nMsgSize-12];
            in.read(resp,0,head.nMsgSize-12);
        }
        return resp;
    }
    private DataInputStream creatInputStream()throws IOException{
        return new DataInputStream(s.getInputStream());
    }
    private DataOutputStream creatOutputStream()throws IOException{
        return new DataOutputStream(s.getOutputStream());
    }
    private void close(){
        socketManger.freeSocket();
        s=null;
    }

    private static final int CMPP_SUCCESS=0;
    private static final int CMPP_UNKNOWN_PACKAGE_ERROR=-9;
    private static final int CMPP_LOGOUT_HAPPEND=-2;

    private static final int SUBMIT_MSG_NULL_ERROR=-4;
    private static final int SUBMIT_MSG_FORMAT_ERROR=-5;
    private static final int SUBMIT_MSG_TIME_OUT=-6;

    private static final int DELIVER_MSG_FORMAT_REPORT_ERROR=-7;
    private static final int DELIVER_MSG_NULL_ERROR=-8;
    private static final int DELIVER_MSG_TIME_OUT=-9;
    private static final int DELIVER_MSG_FORMAT_ERROR=-10;
    private static final int DELIVER_MSG_FORMAT_DECODE_ERROR=-11;

    private static final int CONNECT_MSG_NULL_ERROR=-12;
    private static final int CONNECT_MSG_RESP_NOT_FOUNT_ERROR=-13;
    private static final int CONNECT_MSG_FORMAT_ERROR=-14;
    private static final int CONNECT_INIT_ERROR=-15;

    private static final int CONNECT_HEAD_LEN = 12;
    private static final int CONNECT_PACKET_LEN = 27;
    private static final int QUERY_PACKET_LEN = 27;
    private static final int COMMAND_CMPP_SUBMIT = 4;
    private static final int COMMAND_CMPP_QUERY = 6;
    private static final int COMMAND_CMPP_TERMINATE = 2;
    private static final int COMMAND_CMPP_TERMINATE_RESP = 0x80000002;
    private static final int COMMAND_CMPP_QUERY_RESP = 0x80000006;
    private static final int COMMAND_CMPP_SUBMIT_RESP = 0x80000004;
    private static final int COMMAND_CMPP_CONNECT = 1;
    private static final int COMMAND_CMPP_CONNECT_RESP = 0x80000001;
    private static final int COMMAND_CMPP_ACTIVE_TEST = 8;
    private static final int COMMAND_CMPP_ACTIVE_TEST_REP = 0x80000008;
    private static final int COMMAND_CMPP_DELIVER = 5;
    private static final int COMMAND_CMPP_NACK_RESP = 0x80000000;
    private static final int COMMAND_CMPP_DELIVER_RESP = 0x80000005;
    private static final int COMMAND_CMPP_SET_KEY = 4098;
    private static final int COMMAND_CMPP_SET_KEY_RESP = 0x80001002;

}