Problemas no envio de Sms

Alo galera estou estou querendo fazer uma aplicação para envio de sms
e estou a usar um exemplo que peguei aqui no forum no link asseguir http://www.guj.com.br/java/131103-smpp
e aquando executo da-me o seguinte erro:

log4j:WARN No appenders could be found for logger (org.jsmpp.session.SMPPSession).
log4j:WARN Please initialize the log4j system properly.
Failed connect and bind to host
java.io.IOException: Receive negative bind response: Negative response 0000000d found
	at org.jsmpp.session.SMPPSession.connectAndBind(SMPPSession.java:246)
	at org.jsmpp.session.SMPPSession.connectAndBind(SMPPSession.java:200)
	at smsito.SimpleSubmitExample.main(SimpleSubmitExample.java:34)
IO error occur
java.net.SocketException: Socket closed
	at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:99)
	at java.net.SocketOutputStream.write(SocketOutputStream.java:124)
	at org.jsmpp.DefaultPDUSender.writeAndFlush(DefaultPDUSender.java:419)
	at org.jsmpp.DefaultPDUSender.sendSubmitSm(DefaultPDUSender.java:203)
	at org.jsmpp.SynchronizedPDUSender.sendSubmitSm(SynchronizedPDUSender.java:192)
	at org.jsmpp.session.SubmitSmCommandTask.executeTask(SubmitSmCommandTask.java:86)
	at org.jsmpp.session.AbstractSession.executeSendCommand(AbstractSession.java:248)
	at org.jsmpp.session.SMPPSession.submitShortMessage(SMPPSession.java:320)
	at smsito.SimpleSubmitExample.main(SimpleSubmitExample.java:41)

o codigo que estou a testar eh o seguinte:

package smsito;
import java.io.IOException;  
 

import java.util.Date;   
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.GeneralDataCoding;   
import org.jsmpp.bean.MessageClass;   
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.util.AbsoluteTimeFormatter;   
import org.jsmpp.util.TimeFormatter;   
    
/**  
  * @author uudashr  
  *  
  */   
public class SimpleSubmitExample {   
     private static TimeFormatter timeFormatter = new AbsoluteTimeFormatter();;   
        
     public static void main(String[] args) {   
         SMPPSession session = new SMPPSession();   
         try {   
             session.connectAndBind("192.168.10.248", 1817, new BindParameter(BindType.BIND_TX, "teste", "teste", "cp", TypeOfNumber.UNKNOWN, NumberingPlanIndicator.UNKNOWN, null));   
         } catch (IOException e) {   
             System.err.println("Failed connect and bind to host");   
             e.printStackTrace();   
         }   
                                                                                                                                                                                                   //o numero 284709018 eh o  Nr de celular p teste  
         try {   
             String messageId = session.submitShortMessage("CMT", TypeOfNumber.INTERNATIONAL, NumberingPlanIndicator.UNKNOWN, "1616", TypeOfNumber.INTERNATIONAL, NumberingPlanIndicator.UNKNOWN, "284709018", new ESMClass(), (byte)0, (byte)1,  timeFormatter.format(new Date()), null, new RegisteredDelivery(SMSCDeliveryReceipt.DEFAULT), (byte)0, new GeneralDataCoding(false, false, MessageClass.CLASS1, Alphabet.ALPHA_DEFAULT), (byte)0, "jSMPP simplify SMPP on Java platform".getBytes());   
             System.out.println("Message submitted, message_id is " + messageId);   
         } 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();   
         }   
            
         session.unbindAndClose();   
     }   
        
        
}  

Execute primeiramente um simulador SMPP

import java.io.IOException;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;

import org.apache.log4j.BasicConfigurator;
import org.jsmpp.PDUStringException;
import org.jsmpp.SMPPConstant;
import org.jsmpp.bean.CancelSm;
import org.jsmpp.bean.DataCoding;
import org.jsmpp.bean.DataSm;
import org.jsmpp.bean.DeliveryReceipt;
import org.jsmpp.bean.ESMClass;
import org.jsmpp.bean.GSMSpecificFeature;
import org.jsmpp.bean.MessageMode;
import org.jsmpp.bean.MessageType;
import org.jsmpp.bean.NumberingPlanIndicator;
import org.jsmpp.bean.QuerySm;
import org.jsmpp.bean.RegisteredDelivery;
import org.jsmpp.bean.ReplaceSm;
import org.jsmpp.bean.SMSCDeliveryReceipt;
import org.jsmpp.bean.SubmitMulti;
import org.jsmpp.bean.SubmitMultiResult;
import org.jsmpp.bean.SubmitSm;
import org.jsmpp.bean.TypeOfNumber;
import org.jsmpp.extra.ProcessRequestException;
import org.jsmpp.session.BindRequest;
import org.jsmpp.session.DataSmResult;
import org.jsmpp.session.QuerySmResult;
import org.jsmpp.session.SMPPServerSession;
import org.jsmpp.session.SMPPServerSessionListener;
import org.jsmpp.session.ServerMessageReceiverListener;
import org.jsmpp.session.ServerResponseDeliveryAdapter;
import org.jsmpp.session.Session;
import org.jsmpp.util.DeliveryReceiptState;
import org.jsmpp.util.MessageIDGenerator;
import org.jsmpp.util.MessageId;
import org.jsmpp.util.RandomMessageIDGenerator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author uudashr
 *
 */
public class SMPPServerSimulator extends ServerResponseDeliveryAdapter implements Runnable, ServerMessageReceiverListener {
    private static final Integer DEFAULT_PORT = 1817;
    private static final Logger logger = LoggerFactory.getLogger(SMPPServerSimulator.class);
    private final ExecutorService execService = Executors.newFixedThreadPool(5);
    private final ExecutorService execServiceDelReciept = Executors.newFixedThreadPool(100);
    private final MessageIDGenerator messageIDGenerator = new RandomMessageIDGenerator();
    private int port;
    
    public SMPPServerSimulator(int port) {
        this.port = port;
    }
    
    public void run() {
        try {
            SMPPServerSessionListener sessionListener = new SMPPServerSessionListener(port);
            
            logger.info("Listening on port {}", port);
            while (true) {
                SMPPServerSession serverSession = sessionListener.accept();
                logger.info("Accepting connection for session {}", serverSession.getSessionId());
                serverSession.setMessageReceiverListener(this);
                serverSession.setResponseDeliveryListener(this);
                execService.execute(new WaitBindTask(serverSession));
            }
        } catch (IOException e) {
            logger.error("IO error occured", e);
        }
    }
    
    public QuerySmResult onAcceptQuerySm(QuerySm querySm,
            SMPPServerSession source) throws ProcessRequestException {
        logger.info("Accepting query sm, but not implemented");
        return null;
    }
    
    public MessageId onAcceptSubmitSm(SubmitSm submitSm,
            SMPPServerSession source) throws ProcessRequestException {
        MessageId messageId = messageIDGenerator.newMessageId();
        logger.debug("Receiving submit_sm {}, and return message id {}", new String(submitSm.getShortMessage()), messageId.getValue());
        if (SMSCDeliveryReceipt.SUCCESS.containedIn(submitSm.getRegisteredDelivery()) || SMSCDeliveryReceipt.SUCCESS_FAILURE.containedIn(submitSm.getRegisteredDelivery())) {
            execServiceDelReciept.execute(new DeliveryReceiptTask(source, submitSm, messageId));
        }
        return messageId;
    }
    
    public void onSubmitSmRespSent(MessageId messageId,
            SMPPServerSession source) {
        logger.debug("submit_sm_resp with message_id {} has been sent", messageId);
    }
    
    public SubmitMultiResult onAcceptSubmitMulti(SubmitMulti submitMulti,
            SMPPServerSession source) throws ProcessRequestException {
        return null;
    }
    
    public DataSmResult onAcceptDataSm(DataSm dataSm, Session source)
            throws ProcessRequestException {
        return null;
    }
    
    public void onAcceptCancelSm(CancelSm cancelSm, SMPPServerSession source)
            throws ProcessRequestException {
    }
    
    public void onAcceptReplaceSm(ReplaceSm replaceSm, SMPPServerSession source)
            throws ProcessRequestException {
    }
    
    private class WaitBindTask implements Runnable {
        private final SMPPServerSession serverSession;
        
        public WaitBindTask(SMPPServerSession serverSession) {
            this.serverSession = serverSession;
        }

        public void run() {
            try {
                BindRequest bindRequest = serverSession.waitForBind(1000);
                logger.info("Accepting bind for session {}", serverSession.getSessionId());
                try {
                    bindRequest.accept("sys");
                } catch (PDUStringException e) {
                    logger.error("Invalid system id", e);
                    bindRequest.reject(SMPPConstant.STAT_ESME_RSYSERR);
                }
            
            } catch (IllegalStateException e) {
                logger.error("System error", e);
            } catch (TimeoutException e) {
                logger.warn("Wait for bind has reach timeout", e);
            } catch (IOException e) {
                logger.error("Failed accepting bind request for session {}", serverSession.getSessionId());
            }
        }
    }
    
    private class DeliveryReceiptTask implements Runnable {
        private final SMPPServerSession session;
        private final SubmitSm submitSm;
        private MessageId messageId;
        public DeliveryReceiptTask(SMPPServerSession session,
                SubmitSm submitSm, MessageId messageId) {
            this.session = session;
            this.submitSm = submitSm;
            this.messageId = messageId;
        }

        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            String stringValue = Integer.valueOf(messageId.getValue(), 16).toString();
            try {
                
                DeliveryReceipt delRec = new DeliveryReceipt(stringValue, 1, 1, new Date(), new Date(), DeliveryReceiptState.DELIVRD,  null, new String(submitSm.getShortMessage()));
                session.deliverShortMessage(
                        "mc", 
                        TypeOfNumber.valueOf(submitSm.getDestAddrTon()), 
                        NumberingPlanIndicator.valueOf(submitSm.getDestAddrNpi()), 
                        submitSm.getDestAddress(), 
                        TypeOfNumber.valueOf(submitSm.getSourceAddrTon()), 
                        NumberingPlanIndicator.valueOf(submitSm.getSourceAddrNpi()), 
                        submitSm.getSourceAddr(), 
                        new ESMClass(MessageMode.DEFAULT, MessageType.SMSC_DEL_RECEIPT, GSMSpecificFeature.DEFAULT), 
                        (byte)0, 
                        (byte)0, 
                        new RegisteredDelivery(0), 
                        DataCoding.newInstance(0), 
                        delRec.toString().getBytes());
                logger.debug("Sending delivery reciept for message id " + messageId + ":" + stringValue);
            } catch (Exception e) {
                logger.error("Failed sending delivery_receipt for message id " + messageId + ":" + stringValue, e);
            }
        }
    }
    
    
    public static void main(String[] args) {
        int port;
        try {
            port = Integer.parseInt(System.getProperty("jsmpp.simulator.port", DEFAULT_PORT.toString()));
        } catch (NumberFormatException e) {
            port = DEFAULT_PORT;
        }
        BasicConfigurator.configure();
        SMPPServerSimulator smppServerSim = new SMPPServerSimulator(port);
        smppServerSim.run();
    }
}

Olá,

Estou tentando fazer funcionar esse mesmo exemplo, mas eu ainda tenho algumas dúvidas.
Executei o simulador e a classe exemplo utilizada pelo w4rl0ck e não obtive erros.
Mas também não enviou mensagens para o meu celular.

Esse simulador simula que tipo de servidor?
Eu to pesquisando há 2 dias sobre o assunto, mas ainda não consegui entender direito.
Esses parâmetros abaixo: ip, porta, usuário, senha. Como consigo esses dados para mandar uma mensagem para o celular? Preciso contratar um plano de alguma operadora?

         SMPPSession session = new SMPPSession();     
         try {     
             session.connectAndBind("localhost", 1817, new BindParameter(BindType.BIND_TX, "teste", "teste", "cp", TypeOfNumber.UNKNOWN, NumberingPlanIndicator.UNKNOWN, null));     
         } catch (IOException e) {     
             System.err.println("Failed connect and bind to host");     
             e.printStackTrace();     
         }

O problema de enviar sms direto como celular e que a operadora bloqueia os envios a partir de determinada quantidade. Sujiro uma solução via operadora.
A solução www.smscel.com.br a qual eles vão te fornecedor o modelo em java prontos em http, post ou webservice. Porém esta solução e paga por sms. Envio e resposta de sms e status de processamento.

rafaunitri

Eu optei pela opção que vc disse mesmo, mas gostei bastante de uma outra empresa: http://www.zenvia.com.br/.

Obrigado pela resposta :slight_smile: