Bluetooth duvida para colocar acao nos Botoes e chamar outra classe

Boa Tarde!
Sou novo na programacao J2ME e gostaria de sabe se tambem seria possivel
trabalhar com varias classes aproveitando a mesma ideia do JAVA desktop.
enfim Estou tentando desenvolver um programa baseado nos exemplos de codigos que estao abaixo
voltado para o bluetooth. O objetivo é mandar um String(sinal d comando para o microcontrolador ArduinoBT) e estou com duvina na hora de chamar a classe
BluetoothConnectionClient ao pressionar na opcao abrir

obrigado a todos que tentaram me ajudar e desculpe pelos erros d portugues mas estou usando teclado US!

classe principal

// gostaria de saber como q eu faco a chamada da classe BluetoothConnectionClient quando eu pressionar os botoes abrir e desligar
package src;

import java.io.IOException;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Item;
import javax.microedition.lcdui.ItemStateListener;
import javax.microedition.lcdui.Choice;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Form;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.ImageItem;
import javax.microedition.lcdui.List;

import src.BluetoothConnectionClient;


public  class Test extends MIDlet implements CommandListener,ItemStateListener {
	private Display display;
	private List opcoesItens;
	private Command sair;
	private Command voltar;
	private Command fechar;
	private Command abrir;
	
	private BluetoothConnectionClient bluetoothConnectionClient;

	public Test() {
		System.out.println("entrou --- ");
		opcoesItens=new List("Lista de Tipos Itens", Choice.IMPLICIT);
		sair= new Command("Sair",Command.EXIT,0);
		voltar=new Command("Voltar",Command.OK,1);
	    fechar=new Command("Fechar",Command.OK,1);
	    	    
	    abrir=new Command("Abrir",Command.OK,1);
	}

	protected void startApp(){
		System.out.println("entrou");
		display= Display.getDisplay(this);
		opcoesItens.append("ImageItem",null);
		opcoesItens.addCommand(sair);
		opcoesItens.addCommand(voltar);
	
		opcoesItens.addCommand(abrir);
		opcoesItens.addCommand(fechar);
		
		opcoesItens.setCommandListener(this);
		display.setCurrent(opcoesItens);
		this.exemploImagemItem();
		System.out.println("fim");
	}
	public void exemploImagemItem(){
		System.out.println("entrou no metodo imagem item");
		Form form =new Form("ImagemItem");
		try{
			Image cima=Image.createImage("/src/imagem.png");// caminho do diretorio da imagem
			form.append(new ImageItem("Center",cima,ImageItem.LAYOUT_CENTER,null));

		}catch(IOException ex){
			ex.printStackTrace();
			form.append("Erro ao abrir Imagens");
		}
		form.addCommand(sair);
		form.addCommand(voltar);
		form.addCommand(abrir);
		form.addCommand(fechar);		
		form.setCommandListener(this);
		display.setCurrent(form);
	}
	protected void pauseApp() {
	}
	protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
		notifyDestroyed();
	}
	
	public void itemStateChanged(Item arg0) {
		// TODO Auto-generated method stub

	}

	public void commandAction(Command arg0, Displayable arg1) {
		if (arg0==sair){
			try{
				destroyApp(true);
			}catch (Exception e){
				e.printStackTrace();
			}
		}else if(arg0==voltar){
			display.setCurrent(opcoesItens);
		}else if(arg0==fechar){
			display.setCurrent(opcoesItens);
		}else if(arg0==abrir){
			display.setCurrent(opcoesItens);
		}  
	}
	}

//classe do cliente conexao bluetooth


package src;

import java.io.IOException;
import java.util.Hashtable;
import java.util.Vector;

import javax.bluetooth.BluetoothStateException;
import javax.bluetooth.DataElement;
import javax.bluetooth.DeviceClass;
import javax.bluetooth.DiscoveryAgent;
import javax.bluetooth.DiscoveryListener;
import javax.bluetooth.LocalDevice;
import javax.bluetooth.RemoteDevice;
import javax.bluetooth.ServiceRecord;
import javax.bluetooth.UUID;

import javax.microedition.io.Connector;
import javax.microedition.io.StreamConnection;

/**
 * This class is responsible for establishing the bluetooth connection acting as
 * a client. It is also responsible for searching for servers in the network.
 * 
 */
public class BluetoothConnectionClient extends BluetoothConnection implements  // esta linha chama a classe BluetoothConnection
        DiscoveryListener {

    // Stores the servers address.
    private Hashtable serverAddress;

    // Stores the names of the opponents.
    private Vector opponentNames;

    // Bluetooth transaction ID of the actual service search.
    private int actualTransID = 0;

    // 'True' if the search was canceled.
    private boolean searchCanceled;

    // Actual device under service search.
    private int actualDevice;

    //The devices discovered during the inquiry.
    private RemoteDevice[] devicesDiscovered;

    /**
     * Creates a BluetoothConnectionClient.
     */
    public BluetoothConnectionClient() {
    	
    	System.out.println("chamou a classe bluetoothConnectionClient");
    }

    
    
    /**
     * Searches for new servers.
     * 
     * @return A vector containing strings with the player names of the servers
     *         found.
     * @throws BluetoothStateException
     *             if a bluetooth error is raised.
     * @throws SearchCanceledException
     *             if the search is canceled before finishing.
     */
    public Vector search() throws BluetoothStateException,
            SearchCanceledException {
        opponentNames = new Vector();
        serverAddress = new Hashtable();

        localDevice = LocalDevice.getLocalDevice();
        DiscoveryAgent discoveryAgent = localDevice.getDiscoveryAgent();
        discoveryAgent.startInquiry(DiscoveryAgent.GIAC, this);

        synchronized (this) {
            try {
                this.wait();
            } catch (InterruptedException ignored) {
            }
        }
        if (searchCanceled) {
            throw new SearchCanceledException();
        }
        return opponentNames;
    }

    /**
     * deviceDiscovered method called when a device is discovered in the inquiry. 
     * See javax.bluetooth.DiscoveryListener#deviceDiscovered()
     */
    public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
    }

    /**
     * callBack method called when a server is found.
     * 
     * @param transID
     *            The transaction ID of the service search that is posting the
     *            result
     * @param servRecord
     *            a list of services found during the search request
     */
    public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
        for (int i = 0; i < servRecord.length; i++) {
            DataElement data = servRecord[i].getAttributeValue(PLAYER_NAME_KEY);
            opponentNames.addElement(data.getValue());
            //Record the server address.
            serverAddress.put(data.getValue(), servRecord[i].getConnectionURL(
                    0, false));
        }
    }

    /**
     * serviceSearchCompleted method called when a service search is completed or was
     * terminated because an error occurred or was canceled.
     * 
     * @param transID
     *            the transaction ID identifying the request which initiated the
     *            service search
     * @param respCode
     *            the response code that indicates the status of the transaction
     *  
     */
    public void serviceSearchCompleted(int transID, int respCode) {
        if (++actualDevice >= devicesDiscovered.length) {
            synchronized (this) {
                this.notify();
            }
        } else if (respCode == SERVICE_SEARCH_TERMINATED) {
            searchCanceled = true;
            synchronized (this) {
                this.notify();
            }
        } else {
            searchServiceOnDevice(actualDevice);
        }
    }

    /**
     * inquiryCompleted method called when an inquiry is completed.
     * 
     * @param discType
     *            the type of request that was completed; either
     *            INQUIRY_COMPLETED, INQUIRY_TERMINATED, or INQUIRY_ERROR
     */
    public void inquiryCompleted(int discType) {
        if (discType == INQUIRY_COMPLETED) {
            DiscoveryAgent discoveryAgent = localDevice.getDiscoveryAgent();
            devicesDiscovered = discoveryAgent
                    .retrieveDevices(DiscoveryAgent.CACHED);
            if (devicesDiscovered != null) {
                actualDevice = 0;
                searchServiceOnDevice(actualDevice);
            } else {
                synchronized (this) {
                    this.notify();
                }
            }

        } else if (discType == INQUIRY_TERMINATED) {
            searchCanceled = true;
            synchronized (this) {
                this.notify();
            }
        }
    }

    
    // Searches for a service in an specific device.
    private void searchServiceOnDevice(int device) {
        DiscoveryAgent discoveryAgent = localDevice.getDiscoveryAgent();
        try {
            actualTransID = discoveryAgent
                    .searchServices(new int[] { PLAYER_NAME_KEY },
                            new UUID[] { RFCOMM_UUID },
                            devicesDiscovered[device], this);
        } catch (BluetoothStateException e) {
            e.printStackTrace();
            synchronized (this) {
                this.notify();
            }
        }
    }

    /**
     * Run the client mode and sends a success message when the 
     * connection is established.
     * 
     * @see java.lang.Runnable#run()
     */
    public void run() {
        try {
            conn = (StreamConnection) Connector.open((String) serverAddress
                    .get(playerName));
            fireConnectionEstablishedEvent();
        } catch (IOException e) {
            fireConnectionErrorEvent(e);
        }
    }

    /**
     * Stops the server.
     */
    public void stop() {
        if (conn == null && localDevice != null) {
            DiscoveryAgent discoveryAgent = localDevice.getDiscoveryAgent();
            discoveryAgent.cancelInquiry(this);
            discoveryAgent.cancelServiceSearch(actualTransID);
        } else {
            try {
                conn.close();
            } catch (Exception ignored) {
            } 
        }
    }

}
// codigo de conexao
package src;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import javax.bluetooth.LocalDevice;
import javax.bluetooth.UUID;
import javax.microedition.io.StreamConnection;

/**
 * This class is responsible for establishing the bluetooth connection. It has
 * the common code between a bluetooth client and a server, and must be extended
 * with the properly behaviour.
 * 
 */
public abstract class BluetoothConnection implements Runnable {
 
    /**
     * The object that represents the local device.
     */
    protected LocalDevice localDevice;

    /**
     * The name of the player.
     */
    protected String playerName;

    /**
     * Attribute value that will be retrieved on services which have the RFCOMM_UUID.
     */
    public static final int PLAYER_NAME_KEY = 51;

    /**
     * Shared UUID by server and client.
     */
    protected static final UUID RFCOMM_UUID = new UUID(0x7C3434CC);

    /**
     * The object that represents the connection.
     */
    protected StreamConnection conn;

    /**
     * The Server URL.
     */
    protected static String serverUrl = "btspp://localhost:"
            + RFCOMM_UUID.toString() + ";name=tictactoe;authorize=false";

    /**
     * Thread of the connection.
     */
    private Thread thread;

    /**
     * Listener of the connection.
     */
    //private ConnectionListener listener;

    /**
     * Retrieves a DataInputStream
     * 
     * @return The stream used to receive data from another device.
     * @throws IOException
     *             if an I/O error is raised.
     */
    public DataInputStream getDataInputStream() throws IOException {
        return conn.openDataInputStream();
    }

    /**
     * Retrieves the DataOutputStream
     * 
     * @return The stream used to send data to another device.
     * @throws IOException
     *             if an I/O error is raised.
     */
    public DataOutputStream getDataOutputStream() throws IOException {
        return conn.openDataOutputStream();
    }

    /**
     * Starts the process of establishing a bluetooth connection.
     * 
     * @param playerName
     *            A string containing the name of this player.
     * @param listener
     *            The object that will receive connection events.
     */
    /*
    public void start(String playerName, ConnectionListener listener) {
        this.listener = listener;
        this.playerName = playerName;
        thread = new Thread(this);
        thread.start();
    } */

    /**
     * Stops the connection.
     */
    public abstract void stop();

    /**
     * Sends an event to the listener informing that the connection was
     * established.
     */
    protected void fireConnectionEstablishedEvent() {
  //      listener.connectionEstablished();
    }

    /**
     * Sends an event to the listener informing if a connection error happens.
     */
    protected void fireConnectionErrorEvent(Exception e) {
    //    listener.connectionError(e);
    }
}

Sim é possível. Próximo !

Entao se entendi bem oque tu quer fazer ,


 public void commandAction(Command arg0, Displayable arg1) {  
         if (arg0==sair){  
             try{  
                 destroyApp(true);  
             }catch (Exception e){  
                 e.printStackTrace();  
             }  
         }else if(arg0==voltar){  
             display.setCurrent(opcoesItens);  
         }else if(arg0==fechar){  
             display.setCurrent(opcoesItens);  
         }else if(arg0==abrir){  
             display.setCurrent(opcoesItens);  
         }    
     }  

Qualquer evento de botao , vai chamar no commandAction , oque tu quer que o botão faça


      }else if(arg0==abrir){  
             //aqui tu chama a classe que deseja ou o que queira fazer
         }    

não sei se era isso que tu queria , mais ta ae
flw

[quote=nikomv999]Entao se entendi bem oque tu quer fazer ,


 public void commandAction(Command arg0, Displayable arg1) {  
         if (arg0==sair){  
             try{  
                 destroyApp(true);
             }catch (Exception e){  
                 e.printStackTrace();  
             }  
         }else if(arg0==voltar){  
             display.setCurrent(opcoesItens);  
         }else if(arg0==fechar){  
             display.setCurrent(opcoesItens);  
         }else if(arg0==abrir){  
             display.setCurrent(opcoesItens);  
         }    
     }  

[/quote]

Se for para ensinar, ensina certinho…

O método destroyApp nunca deve ser chamado, pois quem chama é a implementação Java.
Se quer encerrar a aplicação, chame notifyDestroyed, este sim criado para ser chamado por você (aplicação).

[quote=boone][quote=nikomv999]Entao se entendi bem oque tu quer fazer ,


 public void commandAction(Command arg0, Displayable arg1) {  
         if (arg0==sair){  
             try{  
                 destroyApp(true);
             }catch (Exception e){  
                 e.printStackTrace();  
             }  
         }else if(arg0==voltar){  
             display.setCurrent(opcoesItens);  
         }else if(arg0==fechar){  
             display.setCurrent(opcoesItens);  
         }else if(arg0==abrir){  
             display.setCurrent(opcoesItens);  
         }    
     }  

[/quote]

Se for para ensinar, ensina certinho…

O método destroyApp nunca deve ser chamado, pois quem chama é a implementação Java.
Se quer encerrar a aplicação, chame notifyDestroyed, este sim criado para ser chamado por você (aplicação).[/quote]

é realmente tu esta correto boone , so que o mais importante ele intender o conceito