cwspsession.java~1~

jwap 协议 udp 可以用于手机通讯

              }

              break;

            case STATE_SUSPENDED:

              if ( (p.getTransaction().getClassType() ==
                    IWTPTransaction.CLASS_TYPE_0) &&
                  (pdu.getType() == CWSPPDU.PDU_TYPE_DISCONNECT)) {
                s_disconnect_ind(ABORT_DISCONNECT);
                setState(STATE_NULL);
              }
              else if ( (p.getTransaction().getClassType() ==
                         IWTPTransaction.CLASS_TYPE_1) &&
                       (pdu.getType() == CWSPPDU.PDU_TYPE_CONFIRMEDPUSH)) {
                p.getTransaction().abort(ABORT_SUSPEND);
              }

              break;

            case STATE_RESUMING:

              if ( (p.getTransaction().getClassType() ==
                    IWTPTransaction.CLASS_TYPE_0) &&
                  (pdu.getType() == CWSPPDU.PDU_TYPE_DISCONNECT)) {
                wtp.abort(ABORT_DISCONNECT);
                abortAllMethods(ABORT_DISCONNECT);
                s_disconnect_ind(ABORT_DISCONNECT);
                setState(STATE_NULL);
              }
              else if ( (p.getTransaction().getClassType() ==
                         IWTPTransaction.CLASS_TYPE_1) &&
                       (pdu.getType() == CWSPPDU.PDU_TYPE_CONFIRMEDPUSH)) {
                p.getTransaction().abort(ABORT_PROTOERR);
              }
          }

          break;

        case 0x03: //--------------------------------------------- TR-INVOKE.CNF

          switch (state) {
            case STATE_CONNECTING:

              //ignore
              break;

            case STATE_CONNECTED:
              break;

            case STATE_SUSPENDED:

              // ignore
              break;

            case STATE_RESUMING:
              // ignore
          }

          break;

        case 0x05: //--------------------------------------------- TR-RESULT.IND

          switch (state) {
            case STATE_CONNECTING:

              if (p.getUserData().length > MRU) {
                wtp.abort(ABORT_MRUEXCEEDED);
                abortAllMethods(ABORT_CONNECTERR);
                s_disconnect_ind(ABORT_MRUEXCEEDED);
                setState(STATE_NULL);
              }
              else if (pdu.getType() == CWSPPDU.PDU_TYPE_CONNECTREPLY) {
                CWSPConnectReply pdu2 = (CWSPConnectReply) pdu;
                setState(STATE_CONNECTED);

                CWTPEvent initPacket = new CWTPEvent(new byte[0],
                    CWTPEvent.TR_RESULT_RES);
                wtp.process(initPacket);
                session_id = pdu2.getServerSessionID();
                s_connect_cnf();
              }
              else if (pdu.getType() == CWSPPDU.PDU_TYPE_REDIRECT) {
                CWTPEvent initPacket = new CWTPEvent(new byte[0],
                    CWTPEvent.TR_RESULT_RES);
                wtp.process(initPacket);
                abortAllMethods(ABORT_CONNECTERR);

                CWSPRedirect pdu2 = (CWSPRedirect) pdu;
                if (version == 2) {
                  s_disconnect_ind(pdu2.getSocketAddresses());
                }
                else {
                  s_disconnect_ind(pdu2.getInetAddresses());
                }
                setState(STATE_NULL);
              }
              else if (pdu.getType() == CWSPPDU.PDU_TYPE_REPLY) {
                CWTPEvent initPacket = new CWTPEvent(new byte[0],
                    CWTPEvent.TR_RESULT_RES);
                wtp.process(initPacket);
                abortAllMethods(ABORT_CONNECTERR);

                CWSPReply pdu2 = (CWSPReply) pdu;
                s_disconnect_ind(pdu2.getStatus());
                setState(STATE_NULL);
              }
              else {
                wtp.abort(ABORT_PROTOERR);
                abortAllMethods(ABORT_CONNECTERR);
                s_disconnect_ind(ABORT_PROTOERR);
                setState(STATE_NULL);
              }

              break;

            case STATE_CONNECTED:
              break;

            case STATE_SUSPENDED:
              break;

            case STATE_RESUMING:

              if (p.getUserData().length > MRU) {
                wtp.abort(ABORT_MRUEXCEEDED);
                abortAllMethods(ABORT_SUSPEND);
                s_suspend_ind(ABORT_MRUEXCEEDED);
                setState(STATE_SUSPENDED);
              }
              else if (pdu.getType() == CWSPPDU.PDU_TYPE_REPLY) {
                CWSPReply pdu2 = (CWSPReply) pdu;

                if (pdu2.getStatus() == CWSPReply._200_OK_Success) {
                  CWTPEvent initPacket = new CWTPEvent(new byte[0],
                      CWTPEvent.TR_RESULT_RES);
                  wtp.process(initPacket);
                  s_resume_cnf();
                  setState(STATE_CONNECTED);
                }
                else {
                  CWTPEvent initPacket = new CWTPEvent(new byte[0],
                      CWTPEvent.TR_RESULT_RES);
                  wtp.process(initPacket);
                  abortAllMethods(ABORT_DISCONNECT);

                  CWSPReply pdu3 = (CWSPReply) pdu;
                  s_disconnect_ind(pdu3.getStatus());
                  setState(STATE_NULL);
                }
              }
              else {
                wtp.abort(ABORT_PROTOERR);
                abortAllMethods(ABORT_SUSPEND);
                s_suspend_ind(ABORT_PROTOERR);
                setState(STATE_SUSPENDED);
              }
          }

          break;

        case 0x07: //--------------------------------------------- TR-RESULT.CNF

          switch (state) {
            case STATE_CONNECTING:
              break;

            case STATE_CONNECTED:
              break;

            case STATE_SUSPENDED:
              break;

            case STATE_RESUMING:
          }

          break;
      }
    }
    catch (EWSPCorruptPDUException e) {
      logger.error("Corrupt PDU", e);
    }
    catch (EWTPAbortedException e2) {
      logger.error("Aborted", e2);
    }
  }

  /**
   * TR-Abort.ind
   * @param abortReason The abort reason
   */
  public void tr_abort(short abortReason) {
    if (logger.isDebugEnabled()) {
      logger.debug("WSP Session: TR-ABORT.REQ in " + states[state]);
    }

    if (state == STATE_CONNECTING) {
      abortAllMethods(ABORT_CONNECTERR);
      s_disconnect_ind(abortReason);
      setState(STATE_NULL);
    }
    else if (state == STATE_SUSPENDED) {
      // ignore
    }
    else if (state == STATE_RESUMING) {
      if (abortReason == ABORT_DISCONNECT) {
        abortAllMethods(ABORT_DISCONNECT);
        s_disconnect_ind(ABORT_DISCONNECT);
        setState(STATE_NULL);
      }
      else {
        abortAllMethods(ABORT_SUSPEND);
        s_suspend_ind(abortReason);
        setState(STATE_SUSPENDED);
      }
    }
  }

  //////////////////////////////////////////////////////////////////////////////
  //////////////////////////////////////////////////////////// WSP pseudo events
  public void disconnect() {
    socket.close();

    if (state == STATE_CONNECTING) {
      wtp.abort(ABORT_DISCONNECT);
      abortAllMethods(ABORT_DISCONNECT);
      s_disconnect_ind(ABORT_DISCONNECT);
      setState(STATE_NULL);
    }
    else if (state == STATE_CONNECTED) {
      abortAllMethods(ABORT_DISCONNECT);
      abortAllPushes(ABORT_DISCONNECT);
      s_disconnect_ind(ABORT_DISCONNECT);
      setState(STATE_NULL);
    }
    else if (state == STATE_SUSPENDED) {
      s_disconnect_ind(ABORT_DISCONNECT);
      setState(STATE_NULL);
    }
    else if (state == STATE_RESUMING) {
      wtp.abort(ABORT_DISCONNECT);
      abortAllMethods(ABORT_DISCONNECT);
      s_disconnect_ind(ABORT_DISCONNECT);
      setState(STATE_NULL);
    }
  }

  public void suspend() {
    if (state == STATE_CONNECTING) {
      wtp.abort(ABORT_DISCONNECT);
      abortAllMethods(ABORT_DISCONNECT);
      s_disconnect_ind(ABORT_SUSPEND);
      setState(STATE_NULL);
    }
    else if (state == STATE_CONNECTED) {
      // resume facility enabled!
      abortAllMethods(ABORT_SUSPEND);
      abortAllPushes(ABORT_SUSPEND);
      s_disconnect_ind(ABORT_SUSPEND);
      setState(STATE_SUSPENDED);
    }
    else if (state == STATE_RESUMING) {
      wtp.abort(ABORT_SUSPEND);
      abortAllMethods(ABORT_SUSPEND);
      s_suspend_ind(ABORT_SUSPEND);
      setState(STATE_SUSPENDED);
    }
  }

  //////////////////////////////////////////////////////////////////////////////
  ////////////////////////////////////////////////////////////////////// HELPERS
  private void abortAllMethods(short reason) {
    while (methods.size() > 0) {
      ( (CWSPMethodManager) methods.elementAt(0)).abort(reason);
      methods.remove(0);
    }
  }

  private void abortAllPushes(short reason) {
    while (pushes.size() > 0) {
      ( (CWSPPushManager) pushes.elementAt(0)).abort(reason);
      pushes.remove(0);
    }
  }

  /**
   * sets the state of the state machine
   * @param state the state to set
   */
  private void setState(short state) {
    if (logger.isDebugEnabled()) {
      logger.debug(states[this.state] + " >>> " + states[state]);
    }

    this.state = state;
  }

  public short getState() {
    return state;
  }

  public int getMRU() {
    return MRU;
  }

  public boolean isSuspended() {
    return isSuspended;
  }

  public short getSuspendedCode() {
    return suspendCode;
  }

  public boolean isDisonnected() {
    return isDisconnected;
  }

  public short getDisconnectCode() {
    return disconnectCode;
  }

  public CWTPSocket getWTPSocket() {
    return socket;
  }
}