/* * SipChat.java * *Aplicacion como proyecto del ramo Redes de Computadores II. * * Created on 5 de noviembre de 2006, 05:43 PM */ import javax.microedition.midlet.*; import javax.microedition.lcdui.*; import sip.address.NameAddress; import sip.address.SipURI; import sip.header.StatusLine; import sip.message.MessageFactory; import sip.message.SipMessage; import sip.message.SipResponses; import sip.provider.SipProvider; import sip.provider.SipProviderListener; import sip.transaction.TransactionClient; import sip.transaction.TransactionClientListener; import sip.transaction.TransactionServer; /** * * @author Rodrigo */ public class SipChat extends MIDlet implements CommandListener, SipProviderListener, TransactionClientListener { /** Creates a new instance of SipChat */ public SipChat() { initialize(); } private Form mainform; private Form chatForm; private Command okCommand1; private Command exitCommand; private Command exitCommand2; private TextField addressTextField; private TextField chatTextField; private StringItem conversacion; private Command itemCommand; NameAddress remote_user; SipMessage message=null; SipProvider sip_provider=null; String host_addr="127.0.0.1"; int host_port=5070; String local_user="rodrigo.j2me"; SipURI uri = new SipURI("rodrigo","localhost",host_port); NameAddress from_url = new NameAddress("Rodrigo Loyola j2me",uri); /** Metodo llamado por el sistema para indicar que un comando ha sido llamado * en un display determinada. * @param command el comando que fue invocado * @param displayable el objeto de tipo Displayable sobre el cual el comando * fue invocado */ public void commandAction(Command command, Displayable displayable) { if (displayable == chatForm) { if (command == exitCommand2) { exitMIDlet(); } else if (command == itemCommand) { String text = chatTextField.getString(); send( remote_user , from_url , text); } } else if (displayable == mainform) { if (command == okCommand1) { // extraer la direcion sip remote_user = new NameAddress(addressTextField.getString()); getDisplay().setCurrent(get_chatForm()); } else if (command == exitCommand) { exitMIDlet(); } } } /** Este metodo incializa la aplicacion. */ private void initialize() { String[] protocols={ SipProvider.PROTO_UDP }; sip_provider=new SipProvider(host_addr,host_port,protocols,null); sip_provider.addSipProviderListener(SipProvider.ANY,this); getDisplay().setCurrent(get_mainform()); } /** * Este metodo retorna una instancia de la pantalla. */ public Display getDisplay() { return Display.getDisplay(this); } /** * Este metodo termina el midlet. */ public void exitMIDlet() { getDisplay().setCurrent(null); destroyApp(true); notifyDestroyed(); } /** This method returns instance for mainform component and should be called instead of accessing mainform field directly. * @return Instance for mainform component */ public Form get_mainform() { if (mainform == null) { mainform = new Form("chat SIP", new Item[] {get_addressTextField()}); mainform.addCommand(get_okCommand1()); mainform.addCommand(get_exitCommand()); mainform.setCommandListener(this); } return mainform; } /** Este metodo retona una instancia para chatForm y debe ser llamado para * acceder a un campo de chatForm directamente. * @return Instance for chatForm componente */ public Form get_chatForm() { if (chatForm == null) { chatForm = new Form(null, new Item[] { get_chatTextField(), get_conversacion() }); chatForm.addCommand(get_exitCommand2()); chatForm.addCommand(get_itemCommand()); chatForm.setCommandListener(this); } return chatForm; } /** Este metodo retorna una instancia de okCommand1. * @return Instance for okCommand1 component */ public Command get_okCommand1() { if (okCommand1 == null) { okCommand1 = new Command("Ok", Command.OK, 1); } return okCommand1; } /** Este metodo retorna una instancia de exitCommand. * @return Instance for exitCommand component */ public Command get_exitCommand() { if (exitCommand == null) { exitCommand = new Command("Exit", Command.EXIT, 1); } return exitCommand; } /** Este metodo retorna una instancia de exitCommand2. * @return Instance for exitCommand2 component */ public Command get_exitCommand2() { if (exitCommand2 == null) { exitCommand2 = new Command("Exit", Command.EXIT, 1); } return exitCommand2; } /** Este metodo retorna una instancia de addressTextField. * @return Instance for addressTextField component */ public TextField get_addressTextField() { if (addressTextField == null) { addressTextField = new TextField("SIP Address", "sip:rodrigo.xlite@localhost:5060", 120, TextField.ANY); addressTextField.setInitialInputMode(""); } return addressTextField; } /** Este metodo retorna una instancia de chatTextField. * @return Instance for chatTextField component */ public TextField get_chatTextField() { if (chatTextField == null) { chatTextField = new TextField("Mensaje", null, 120, TextField.ANY); } return chatTextField; } /** este metodo retorna una instancia del stringItem conversacion. * @return Instance for conversacion component */ public StringItem get_conversacion() { if (conversacion == null) { conversacion = new StringItem("Chat:", ""); } return conversacion; } /** Este metodo retorna una instancia de itemCommand1. * @return Instance for itemCommand1 component */ public Command get_itemCommand() { if (itemCommand == null) { itemCommand = new Command("Enviar", Command.ITEM, 1); } return itemCommand; } public void startApp() { } public void pauseApp() { } public void destroyApp(boolean unconditional) { } /** * Metodo que escucha cuando se recibe un mensaje y crea una nueva transaccion * @param provider Provee los metodos necesarios para enviar y recibir mensajes. * @param msg Mensaje que se recibe. */ public void onReceivedMessage(SipProvider provider, SipMessage msg) { if (msg.isRequest() && msg.isMessage()) { remote_user=msg.getFromHeader().getNameAddress(); conversacion.setText(conversacion.getText()+"\nreceived: "+msg.getBody()); TransactionServer t=new TransactionServer(sip_provider,msg,null); t.respondWith(MessageFactory.createResponse(msg,200,SipResponses.reasonOf(200),null)); } } public void onTransProvisionalResponse(TransactionClient tc, SipMessage resp) { } /** * Implementacion del metodo definido en la interface TransactionClientListener, * este metodo es llamado cuando se recibe una respuesta del tipo 2xx * @param tc Transacion que se esta utilizando. * @param resp Mensaje recibido como respuesta. */ public void onTransSuccessResponse(TransactionClient tc, SipMessage resp) { String result; StatusLine statusLine = resp.getStatusLine(); if (statusLine == null) result="Timeout"; else result = statusLine.getCode() + " " + statusLine.getReason(); conversacion.setText(conversacion.getText()+"\n"+result); } /** * Este metodo escucha cuando se produce un timeout o se recibe una respuesta * de falla. * @param tc Transacion * @param resp respuesta */ public void onTransFailureResponse(TransactionClient tc, SipMessage resp) { conversacion.setText(conversacion.getText() + "\n" + "Error o Timeout"); } public void onTransTimeout(TransactionClient tc) { } /** * Metodo para enviar un mensaje SIP de tipo MESSAGE. * @param to URL Local * @param from URL Remota * @param text texto del mensaje. */ private void send(NameAddress to, NameAddress from, String text) { message=MessageFactory.createMessageRequest(sip_provider,to,from,null,"application/text",text); TransactionClient t=new TransactionClient(sip_provider,message,this); t.request(); } }