Question about bluetooth communication between PC and mobile device

Question

I am a newbie of bluetooth communication. This time I need to have connumication between PC and mobile device (mainly mobile phone) by sending strings. PC is acted as server and mobile device act as client.
For using bluetooth in PC, I use bluecove 2.0.1
I have already connected them successfully.
When I want to send strings between them, it is found that it can only do one cycle of communication (client -> server -> client).
For my design, they can communicate multiple times.
I simulate the core class of the system, the performance is fine.
Cound anyone help me to watch the code and give me some advices?
Server Side - ServerBox.java
public class ServerBox implements Runnable {
   LocalDevice localDevice;
   StreamConnectionNotifier notifier;
   ServiceRecord record;
   boolean isClosed;
   ClientProcessor processor;
   CMDProcessor cmd;
   MainInterface midlet;
   private static final UUID ECHO_SERVER_UUID = new UUID(
           "F0E0D0C0B0A000908070605040302010", false);
   public ServerBox(MainInterface midlet) {
       this.midlet = midlet;
   public void run() {
       boolean isBTReady = false;
       try {
           localDevice = LocalDevice.getLocalDevice();
           if (!localDevice.setDiscoverable(DiscoveryAgent.GIAC)) {
               midlet.showInfo("Cannot set to discoverable");
               return;
           // prepare a URL to create a notifier
           StringBuffer url = new StringBuffer("btspp://");
           url.append("localhost").append(':');
           url.append(ECHO_SERVER_UUID.toString());
           url.append(";name=Echo Server");
           url.append(";authorize=false");
           // create notifier now
           notifier = (StreamConnectionNotifier) Connector.open(url.toString());
           record = localDevice.getRecord(notifier);
           isBTReady = true;
       } catch (Exception e) {
           e.printStackTrace();
       // nothing to do if no bluetooth available
       if (isBTReady) {
           midlet.showInfo("Initalization complete. Waiting for connection");
           midlet.completeInitalization();
       } else {
           midlet.showInfo("Initalization fail. Exit.");
           return;
       // produce client processor
       processor = new ClientProcessor();
       cmd = new CMDProcessor();
       // start accepting connections then
       while (!isClosed) {
           StreamConnection conn = null;
           try {
               conn = notifier.acceptAndOpen();
           } catch (IOException e) {
               // wrong client or interrupted - continue anyway
               continue;
           processor.addConnection(conn);
   // activate the set up of process
   public void publish() {
       isClosed = false;
       new Thread(this).start();
   // stop the service
   public void cancelService() {
       isClosed = true;
       midlet.showInfo("Service Terminate.");
       midlet.completeTermination();
   // inner private class for handling connection and activate connection handling
   private class ClientProcessor implements Runnable {
       private Thread processorThread;
       private Vector queue = new Vector();
       private boolean isOk = true;
       ClientProcessor() {
           processorThread = new Thread(this);
           processorThread.start();
       public void run() {
           while (!isClosed) {
               synchronized (this) {
                   if (queue.size() == 0) {
                       try {
                           // wait for new client
                           wait();
                       } catch (InterruptedException e) { }
               StreamConnection conn;
               synchronized (this) {
                   if (isClosed) {
                       return;
                   conn = (StreamConnection) queue.firstElement();
                   queue.removeElementAt(0);
                   processConnection(conn);
       // add stream connection and notify the thread
       void addConnection(StreamConnection conn) {
           synchronized (this) {
               queue.addElement(conn);
               midlet.showInfo("A connection is added.");
               notify();    // for wait() command in run()
   // receive string
   private String readInputString(StreamConnection conn) {
       String inputString = null;
       try {
           DataInputStream dis = conn.openDataInputStream();
           inputString = dis.readUTF();
           dis.close();
       } catch (Exception e) {
           e.printStackTrace();
       return inputString;
   private void sendOutputData(String outputData, StreamConnection conn) {
       try {
           DataOutputStream dos = conn.openDataOutputStream();
           dos.writeUTF(outputData);
           dos.close();
       } catch (IOException e) {
   // process connecion
   private void processConnection(StreamConnection conn) {
       String inputString = readInputString(conn);
       String outputString = cmd.reactionToCMD(inputString);
       sendOutputData(outputString, conn);
/*       try {
           conn.close();
       } catch (IOException e) {}*/
       midlet.showInfo("Client input: " + inputString + ", successfully received.");
}For "CMDProcessor" , it is the class of message processing before feedback to client.
Client side - ClientBox.java
public class ClientBox implements Runnable, CommandListener{
    StringItem result = new StringItem("","");
    private DiscoveryAgent discoveryAgent;
    private String connString;
    private boolean isClosed = false;
    private boolean boxReady = false;
    StreamConnection conn;
    private static final UUID ECHO_SERVER_UUID = new UUID( "F0E0D0C0B0A000908070605040302010", false);
    Form process = new Form("Process");
    ClientInterface midlet;
    public ClientBox(ClientInterface mid){
        this.midlet = mid;
        process.append(result);
        process.addCommand(new Command("Cancel",Command.CANCEL,1));
        process.setCommandListener(this);
        new Thread(this).start();
    public void commandAction(Command arg0, Displayable arg1) {    
        if(arg0.getCommandType()==Command.CANCEL){
            isClosed = true;
            midlet.notifyDestroyed();
    public synchronized void run() {
        LocalDevice localDevice = null;
        boolean isBTReady = false;
        /* Process Gauge screen */
        midlet.displayPage(process);
        Gauge g=new Gauge(null,false,Gauge.INDEFINITE,Gauge.CONTINUOUS_RUNNING);
        process.append(g);
        showInfo("Initalization...");
        System.gc();
        try {
            localDevice = LocalDevice.getLocalDevice();
            discoveryAgent = localDevice.getDiscoveryAgent();
            isBTReady = true;
        } catch (Exception e) {
            e.printStackTrace();
        if (!isBTReady) {
            showInfo("Bluetooth is not avaliable. Please check the device.");
            return;
        if(!isClosed){
            try {
                connString = discoveryAgent.selectService(ECHO_SERVER_UUID, ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false);
            } catch (BluetoothStateException ex) {
                ex.printStackTrace();
        else return;
        if (connString == null) {
            showInfo("Cannot Find Server. Please check the device.");
            return;
        else showInfo("Can Find Server, stand by for request.");
        boxReady = true;
    /* True if the clientbox is ready */
    public boolean getBoxReady(){
        return boxReady;
    /* True if the clientbox is closed in run() */
    public boolean getIsClosed(){
        return isClosed;
    public String accessService(String input) {
        String output = null;
        try {
            /* Connect to server */
            StreamConnection conn = (StreamConnection) Connector.open(connString);
            /* send string */
            DataOutputStream dos = conn.openDataOutputStream();
            dos.writeUTF(input);
            dos.close();
            /* receive string */
            DataInputStream dis = conn.openDataInputStream();
            output = dis.readUTF();
            dis.close();
        } catch (IOException ex){
            showInfo("Fail connect to connect to server.");
        return output;
    private void showInfo(String s){
        StringBuffer sb=new StringBuffer(result.getText());
        if(sb.length()>0){ sb.append("\n"); }
        sb.append(s);
        result.setText(sb.toString());
}Client side - ClientInterface.java
public class ClientInterface extends MIDlet implements Runnable, CommandListener{
    private ClientBox cb = new ClientBox(this);
    private Form temp = new Form("Temp");
    private Command select = new Command("Select", Command.OK, 1);
    private Command back = new Command("Back", Command.BACK, 1);
    Alert alert;
    String[] element;
    String out;
    List list;
    public void run(){
        /* Send message and get reply */
        out = cb.accessService("Proglist");
        element = split(out,",");
        /* Use the reply to make list */
        list = createList(element[0], List.IMPLICIT, out);
        list.addCommand(select);
        list.addCommand(back);
        list.setCommandListener(this);
        Display.getDisplay(this).setCurrent(list);
    public void startApp() {
        System.gc();
        waitForBoxSetUp(); /* Recursively check for clientbox status */
        new Thread(this).start();
    public void pauseApp() {
    public void destroyApp(boolean unconditional) {
        notifyDestroyed();
    public void displayPage(Displayable d){
        Display.getDisplay(this).setCurrent(d);
    private void waitForBoxSetUp(){
        while(!cb.getBoxReady()){
            if(cb.getIsClosed())
                notifyDestroyed();
    public void commandAction(Command c, Displayable d){
        if (c.getCommandType() == Command.OK){
            if (d == list){
                /* Send the choice to server */
                out = cb.accessService(list.getString(list.getSelectedIndex()));
                alert = new Alert("Output", "selected = "+out, null, AlertType.ALARM);
                alert.setTimeout(2000);
                Display.getDisplay(this).setCurrent(alert,list);
        if (c.getCommandType() == Command.BACK){
            notifyDestroyed();
    public void showWarning(String title, String content){
        alert = new Alert("Output", "selected = "+list.getString(list.getSelectedIndex()), null, AlertType.ALARM);
        alert.setTimeout(3000);
        Display.getDisplay(this).setCurrent(alert,list);
    private List createList(String name, int type, String message){
        List temp;
        String[] source = split(message,",") ;
        temp = new List(name, type, source, null);
        return temp;
    private static String[] split(String original,String regex)
        int startIndex = 0;
        Vector v = new Vector();
        String[] str = null;
        int index = 0;
        startIndex = original.indexOf(regex);
        while(startIndex < original.length() && startIndex != -1)
            String temp = original.substring(index,startIndex);
            v.addElement(temp);
            index = startIndex + regex.length();
            startIndex = original.indexOf(regex,startIndex + regex.length());
        v.addElement(original.substring(index + 1 - regex.length()));
        str = new String[v.size()];
        for(int i=0;i<v.size();i++)
            str[i] = (String)v.elementAt(i);
        return str;
}

Answer 1

i haven't worked with devices but only with the toolkit emulators;
it definitely is possible...
u have to send the image as a bytestream and receive the image at the jsp end...
and then reconstruct the image.
the Stream classes in J2ME AND J2SE are all u will require.
also the Image class.
i have not done this but i have successfully sent an image frm a jsp and displayed it on the emulator.