/*
* 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();
}
}