[RESOLVIDO] J2ME SocketConnection não mantém conexão

private String URL = "socket://127.0.0.1:6789";
private InputStream  Input;
private OutputStream  Output;
private void OpenConnection() throws Exception{
    client = (SocketConnection) Connector.open(URL,Connector.READ_WRITE);
    client.setSocketOption(SocketConnection.DELAY, 0);
    client.setSocketOption(SocketConnection.KEEPALIVE, 0);
    client.setSocketOption(SocketConnection.SNDBUF, 512);
    client.setSocketOption(SocketConnection.RCVBUF, 512);
    Output = client.openOutputStream();
    Input = client.openInputStream();
}
private void ReceiveMessage(){
        if(client != null){
            try {
                int c = 0;
                StringBuffer sb = new StringBuffer();
                while (((c = Input.read()) != '\n') && (c != -1)) {
                    sb.append((char) c);
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
 private void SendMessage(String Message){
        if(client != null){
            try {
                Output.write((Message).getBytes());
                Output.flush();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
public void run() {
            OpenConnection();
        while(true){
            try {
                SendMessage("0:OK");
                ReceiveMessage();
                Thread.sleep(500);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

import java.io.*;
import java.net.*;

public class Main {
    public static void main(String[] args) {
        try {
            ServerSocket welcomeSocket = new ServerSocket(6789);
            
            System.out.println("Servidor Iniciado na Porta 6789;");
            System.out.println("Iniciando Listener...");
            while (true) {
                Socket connectionSocket = welcomeSocket.accept();
                TcpThread t = new TcpThread(connectionSocket);
                t.start();
            }
        } catch (IOException ex) {
            System.out.println("Ocorreu um Erro: " + ex.getMessage());
        }
    }

    static class TcpThread extends Thread {
        Socket socket;
        DataInputStream Sinput;
        DataOutputStream Soutput;
        TcpThread(Socket socket) {
                this.socket = socket;
        }
        public void run(){
            while(true){
                try{
                    Soutput = new DataOutputStream(socket.getOutputStream());
                    Soutput.flush();
                    Sinput = new DataInputStream(socket.getInputStream());
                }catch(Exception ex){
                    System.out.println("Ocorreu um Erro: " + ex.getMessage());
                    return;
                }
                try{
                    String Input = Sinput.readUTF();
                    if(Input != null){
                        String[] Commands = Input.split(":");
                        int command = Integer.parseInt(Commands[0]);
                        switch(command){
                             case 0://Requisição de ID
                            Soutput.writeUTF("1");
                            Soutput.flush();
                        }
                    }
                }catch(Exception ex){
                    System.out.println("Ocorreu um Erro: " + ex.getMessage());
                    return;
                }finally{
                    try {
                        System.out.println("Fechando I/O");
                        Soutput.close();
                        Sinput.close();
                    }catch (Exception e) {}
                }
            }
        }
    }
}

String receive = Input.readUTF();

import java.io.*;
import javax.microedition.io.*;
import java.io.IOException;
public class SocketController implements Runnable, ISocketSubject {

    private SocketConnection client;
    private String URL = "socket://127.0.0.1:6789";
    private DataInputStream  Input;
    private DataOutputStream  Output;
    private String SocketStatus = "";

    public SocketController(ISocketObservable observer){
        this.observer = observer;
    }

    private void SendMessage(String Message){
        if(client != null){
            try {
                Output.writeUTF(Message);
                Output.flush();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
    private void StartSocket(){
        try {
            client = (SocketConnection) Connector.open(URL,Connector.READ_WRITE);
            //if(PingServer(true)){
                client.setSocketOption(SocketConnection.DELAY, 0);
                client.setSocketOption(SocketConnection.KEEPALIVE, 1);
                client.setSocketOption(SocketConnection.RCVBUF, 512);
                client.setSocketOption(SocketConnection.SNDBUF, 512);
                client.setSocketOption(SocketConnection.LINGER, 5);
                Output = client.openDataOutputStream();
                Input = client.openDataInputStream();
            //}
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    private void ReceiveMessage(){
        new Thread(){
            public void run(){
                if(client != null && Input != null){
                    try {
                        String receive = Input.readUTF();
                        if(receive != null){
                            NotifyObservers(receive);
                        }
                    } catch (IOException ex) {

                    }
                }
            }
        }.start();
    }

    public void run() {
            StartSocket();
            ReceiveMessage();
            SendMessage("0:OK");
        while(true){
            try {
                Thread.sleep(500);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
    
    private ISocketObservable observer;
    public void AttachObserver(ISocketObservable observer) {
        this.observer = observer;
    }

    public void DettachObserver(ISocketObservable observer) {
        this.observer = null;
    }

    public void NotifyObservers(String info) {
        this.observer.Notified(info);
    }

}

DataInputStream dIS;
/*esse é o metodo runCliente chame ele assim q voce quiser iniciar a conexao*/
public void runClient(){
new Thread(){
public void run(){
conectado=false;
while(!conectado){
try{
SocketConnection conn=(SocketConnection)Connector.open(url);
//Conectado
dIS=conn.OpenDataInputStream();
DataOutputStream dOS=conn.OpenDataOutputStream();
//Conexao aberta
dOS.writeUTF("0:OK");
dOS.flush();
//Chama o metodo q cria a thread q espera pela mensagem
aguardaMsgs();
conectado=true;
//para a execucao da Thread
}catch(Exception ex){
ex.printStackTrace();
}
}.start();
}

public void aguardaMsgs(){
new Thread(){
public void run(){
try{
 String mensagem=dIS.readUTF();
/*faz o que voce quiser com a mensagem e se for receber outra ou mais mensagens coloca esse try dentro de um while*/
}catch(Exception ex){
ex.printStackTrace();
}
}.start();
}