Зависает отправка SMS

import java.io.IOException;
import java.util.Random;
import org.jsmpp.InvalidResponseException;
import org.jsmpp.PDUException;
import org.jsmpp.bean.Alphabet;
import org.jsmpp.bean.BindType;
import org.jsmpp.bean.ESMClass;
import org.jsmpp.bean.GSMSpecificFeature;
import org.jsmpp.bean.GeneralDataCoding;
import org.jsmpp.bean.MessageClass;
import org.jsmpp.bean.MessageMode;
import org.jsmpp.bean.MessageType;
import org.jsmpp.bean.NumberingPlanIndicator;
import org.jsmpp.bean.RegisteredDelivery;
import org.jsmpp.bean.SMSCDeliveryReceipt;
import org.jsmpp.bean.TypeOfNumber;
import org.jsmpp.extra.NegativeResponseException;
import org.jsmpp.extra.ResponseTimeoutException;
import org.jsmpp.session.BindParameter;
import org.jsmpp.session.SMPPSession;
import org.jsmpp.session.Session;
 
 
public class SendSMS {
 
    private static final String SMCS_USER = "USER";
    private static final String SMCS_PASSWORD = "password";
    private static final String SMCS_HOST = "XX.XXX.XXX.XXX";
    private static final int    SMCS_PORT = 3102;
    private static final String SMCS_SOURCE = "7921XXXXXXX";
 
    private static final int MAX_MULTIPART_MSG_SEGMENT_SIZE_UCS2 = 134;
    private static final int MAX_SINGLE_MSG_SEGMENT_SIZE_UCS2 = 70;
 
 
    private static byte[][] splitUnicodeMessage(byte[] aMessage, Integer maximumMultipartMessageSegmentSize) {
 
        final byte UDHIE_HEADER_LENGTH = 0x05;
        final byte UDHIE_IDENTIFIER_SAR = 0x00;
        final byte UDHIE_SAR_LENGTH = 0x03;
 
        //determine how many messages have to be sent
        int numberOfSegments = aMessage.length / maximumMultipartMessageSegmentSize;
        int messageLength = aMessage.length;
        if (numberOfSegments > 255) {
            numberOfSegments = 255;
            messageLength = numberOfSegments * maximumMultipartMessageSegmentSize;
        }
        if ((messageLength % maximumMultipartMessageSegmentSize) > 0) {
            numberOfSegments++;
        }
 
        // prepare array for all of the msg segments
        byte[][] segments = new byte[numberOfSegments][];
 
        int lengthOfData;
 
        //generate new reference number
        byte[] referenceNumber = new byte[1];
        new Random().nextBytes(referenceNumber);
 
        // split the message adding required headers
        for (int i = 0; i < numberOfSegments; i++) {
            if (numberOfSegments - i == 1) {
                lengthOfData = messageLength - i * maximumMultipartMessageSegmentSize;
            } else {
                lengthOfData = maximumMultipartMessageSegmentSize;
            }
 
            //new array to store the header
            segments[i] = new byte[6 + lengthOfData];
 
            //UDH header
            //doesnt include itself, its header length
            segments[i][0] = UDHIE_HEADER_LENGTH;
            //SAR identifier
            segments[i][1] = UDHIE_IDENTIFIER_SAR;
            // SAR length
            segments[i][2] = UDHIE_SAR_LENGTH;
            // reference number (same for all messages)
            segments[i][3] = referenceNumber[0];
            // total number of segments
            segments[i][4] = (byte) numberOfSegments;
            // segment number
            segments[i][5] = (byte) (i + 1);
 
            // copy the data into the array
            System.arraycopy(aMessage, (i * maximumMultipartMessageSegmentSize), segments[i], 6, lengthOfData);
 
        }
        return segments;
    }
 
 
    public static String sendTextMessage(String destinationMsisdn, String messageBody, String MY_SMCS_SOURCE) throws IOException, InterruptedException {
 
        String sourceMsisdn = MY_SMCS_SOURCE; // SMCS_SOURCE;
        MessageClass messageClass = MessageClass.CLASS1;
 
        SMPPSession session = new SMPPSession();
 
        try {
            session.connectAndBind(SMCS_HOST, SMCS_PORT, new BindParameter(BindType.BIND_TX, SMCS_USER, SMCS_PASSWORD,
                    "cp", TypeOfNumber.UNKNOWN, NumberingPlanIndicator.UNKNOWN, null));
        } catch (IOException e) {
            System.err.println("Failed connect and bind to host");
            e.printStackTrace();
        }
 
        // configure variables acording to if message contains national
        // characters
        Alphabet alphabet = null;
        int maximumSingleMessageSize = 0;
        int maximumMultipartMessageSegmentSize = 0;
        byte[] byteSingleMessage = null;
        byteSingleMessage = messageBody.getBytes("UTF-16BE");
        alphabet = Alphabet.ALPHA_UCS2;
        maximumSingleMessageSize = MAX_SINGLE_MSG_SEGMENT_SIZE_UCS2;
        maximumMultipartMessageSegmentSize = MAX_MULTIPART_MSG_SEGMENT_SIZE_UCS2;
 
        // check if message needs splitting and set required sending parameters
        byte[][] byteMessagesArray = null;
        ESMClass esmClass = null;
        if (messageBody.length() > maximumSingleMessageSize) {
            // split message according to the maximum length of a segment
            byteMessagesArray = splitUnicodeMessage(byteSingleMessage, maximumMultipartMessageSegmentSize);
            // set UDHI so PDU will decode the header
            esmClass = new ESMClass(MessageMode.DEFAULT, MessageType.DEFAULT, GSMSpecificFeature.UDHI);
        } else {
            byteMessagesArray = new byte[][] { byteSingleMessage };
            esmClass = new ESMClass();
        }
 
        System.out.println("Sending message " + messageBody);
        System.out.printf("Message is %d characters long and will be sent as %d messages with params: %s %s ",
                messageBody.length(), byteMessagesArray.length, alphabet, messageClass);
        System.out.println();
 
        // submit all messages
        String messageId = null;
        for (int i = 0; i < byteMessagesArray.length; i++) {
            messageId = submitMessage(session, byteMessagesArray[i], sourceMsisdn, destinationMsisdn,
                    messageClass, alphabet, esmClass);
            System.out.println("Message submitted, message_id is " + messageId);
        }
 
 
        session.unbindAndClose();
        return messageId;
    }
 
    private static String submitMessage(SMPPSession session, byte[] message, String sourceMsisdn, String destinationMsisdn,
            MessageClass messageClass, Alphabet alphabet, ESMClass esmClass) {
        String messageId = null;
        //GeneralDataCoding dataCoding = new GeneralDataCoding(false, true, MessageClass.CLASS1, Alphabet.ALPHA_UCS2);
        GeneralDataCoding dataCoding = new GeneralDataCoding(false, true, messageClass, alphabet);
        try {
            messageId = session.submitShortMessage("CMT", TypeOfNumber.UNKNOWN, NumberingPlanIndicator.UNKNOWN,
                    sourceMsisdn, TypeOfNumber.UNKNOWN, NumberingPlanIndicator.UNKNOWN, destinationMsisdn, esmClass,
                    (byte) 0, (byte) 1, null, null, new RegisteredDelivery(SMSCDeliveryReceipt.SUCCESS),
                    (byte) 0,new GeneralDataCoding((byte) 8) , (byte) 0, message);
        
        } catch (PDUException e) {
            // Invalid PDU parameter
            System.err.println("Invalid PDU parameter");
            e.printStackTrace();
        } catch (ResponseTimeoutException e) {
            // Response timeout
            System.err.println("Response timeout");
            e.printStackTrace();
        } catch (InvalidResponseException e) {
            // Invalid response
            System.err.println("Receive invalid respose");
            e.printStackTrace();
        } catch (NegativeResponseException e) {
            // Receiving negative response (non-zero command_status)
            System.err.println("Receive negative response");
            e.printStackTrace();
        } catch (IOException e) {
            System.err.println("IO error occur");
            e.printStackTrace();
        }
       return messageId;
    }
 
}