S60 communication issues

[schien]

Program can work well on WTK2.0 and WTK2.1, but when use nokia midp sdk for symbian os, it can only send data, rather than receive data, and the same condition with the mobilephone, but through interception tools, message is returned, but program can not read out it.

source

BufferedReader.java
ServerConnection.java
TCPForm.java
TCPHandlerListener.java
TCPMIDlet.java

[schien]

import java.io.*;

public class BufferedReader
extends Reader {

private Reader in;

private char cb[];
private int nChars, nextChar;

private static final int INVALIDATED = -2;
private static final int UNMARKED = -1;
private int markedChar = UNMARKED;
private int readAheadLimit = 0;
private boolean skipLF = false;
private boolean markedSkipLF = false;
private static int defaultCharBufferSize = 8192;
private static int defaultExpectedLineLength = 80;
public BufferedReader(Reader in, int sz) {
super(in);
if (sz <= 0) {
throw new IllegalArgumentException("Buffer size <= 0");
}
this.in = in;
cb = new char[sz];
nextChar = nChars = 0;
}

public BufferedReader(Reader in) {
this(in, defaultCharBufferSize);
}

private void ensureOpen() throws IOException {
if (in == null) {
throw new IOException("Stream closed");
}
}

private void fill() throws IOException {
int dst;
if (markedChar <= UNMARKED) {
dst = 0;
}
else {
int delta = nextChar - markedChar;
if (delta >= readAheadLimit) {
markedChar = INVALIDATED;
readAheadLimit = 0;
dst = 0;
}
else {
if (readAheadLimit <= cb.length) {
System.arraycopy(cb, markedChar, cb, 0, delta);
markedChar = 0;
dst = delta;
}
else {
char ncb[] = new char[readAheadLimit];
System.arraycopy(cb, markedChar, ncb, 0, delta);
cb = ncb;
markedChar = 0;
dst = delta;
}
nextChar = nChars = delta;
}
}

int n;
do {
n = in.read(cb, dst, cb.length - dst);
}
while (n == 0);
if (n > 0) {
nChars = dst + n;
nextChar = dst;
}
}

public int read() throws IOException {
synchronized (lock) {
ensureOpen();
for (; ; ) {
if (nextChar >= nChars) {
fill();
if (nextChar >= nChars) {
return -1;
}
}
if (skipLF) {
skipLF = false;
if (cb[nextChar] == '\n') {
nextChar++;
continue;
}
}
return cb[nextChar++];
}
}
}

private int read1(char[] cbuf, int off, int len) throws IOException {
if (nextChar >= nChars) {
if (len >= cb.length && markedChar <= UNMARKED && !skipLF) {
return in.read(cbuf, off, len);
}
fill();
}
if (nextChar >= nChars) {
return -1;
}
if (skipLF) {
skipLF = false;
if (cb[nextChar] == '\n') {
nextChar++;
if (nextChar >= nChars) {
fill();
}
if (nextChar >= nChars) {
return -1;
}
}
}
int n = Math.min(len, nChars - nextChar);
System.arraycopy(cb, nextChar, cbuf, off, n);
nextChar += n;
return n;
}

public int read(char cbuf[], int off, int len) throws IOException {
synchronized (lock) {
ensureOpen();
if ( (off < 0) || (off > cbuf.length) || (len < 0) ||
( (off + len) > cbuf.length) || ( (off + len) < 0)) {
throw new IndexOutOfBoundsException();
}
else if (len == 0) {
return 0;
}

int n = read1(cbuf, off, len);
if (n <= 0) {
return n;
}
while ( (n < len) && in.ready()) {
int n1 = read1(cbuf, off + n, len - n);
if (n1 <= 0) {
break;
}
n += n1;
}
return n;
}
}

String readLine(boolean ignoreLF) throws IOException {
StringBuffer s = null;
int startChar;
boolean omitLF = ignoreLF || skipLF;
synchronized (lock) {
ensureOpen();

bufferLoop:
for (; ; ) {
if (nextChar >= nChars) {
fill();
}
if (nextChar >= nChars) {
if (s != null && s.length() > 0) {
return s.toString();
}
else {
return null;
}
}
boolean eol = false;
char c = 0;
int i;
if (omitLF && (cb[nextChar] == '\n')) {
nextChar++;
}
skipLF = false;
omitLF = false;

charLoop:
for (i = nextChar; i < nChars; i++) {
c = cb[i];
if ( (c == '\n') || (c == '\r')) {
eol = true;
break charLoop;
}
}

startChar = nextChar;
nextChar = i;

if (eol) {
String str;
if (s == null) {
str = new String(cb, startChar, i - startChar);
}
else {
s.append(cb, startChar, i - startChar);
str = s.toString();
}
nextChar++;
if (c == '\r') {
skipLF = true;
}
return str;
}

if (s == null) {
s = new StringBuffer(defaultExpectedLineLength);
}
s.append(cb, startChar, i - startChar);
}
}
}

public String readLine() throws IOException {
return readLine(false);
}

public long skip(long n) throws IOException {
if (n < 0L) {
throw new IllegalArgumentException("skip value is negative");
}
synchronized (lock) {
ensureOpen();
long r = n;
while (r > 0) {
if (nextChar >= nChars) {
fill();
}
if (nextChar >= nChars) {
break;
}
if (skipLF) {
skipLF = false;
if (cb[nextChar] == '\n') {
nextChar++;
}
}
long d = nChars - nextChar;
if (r <= d) {
nextChar += r;
r = 0;
break;
}
else {
r -= d;
nextChar = nChars;
}
}
return n - r;
}
}

public boolean ready() throws IOException {
synchronized (lock) {
ensureOpen();
if (skipLF) {
if (nextChar >= nChars && in.ready()) {
fill();
}
if (nextChar < nChars) {
if (cb[nextChar] == '\n') {
nextChar++;
}
skipLF = false;
}
}
return (nextChar < nChars) || in.ready();
}
}

public boolean markSupported() {
return true;
}

public void mark(int readAheadLimit) throws IOException {
if (readAheadLimit < 0) {
throw new IllegalArgumentException("Read-ahead limit < 0");
}
synchronized (lock) {
ensureOpen();
this.readAheadLimit = readAheadLimit;
markedChar = nextChar;
markedSkipLF = skipLF;
}
}

public void reset() throws IOException {
synchronized (lock) {
ensureOpen();
if (markedChar < 0) {
throw new IOException( (markedChar == INVALIDATED)
? "Mark invalid"
: "Stream not marked");
}
nextChar = markedChar;
skipLF = markedSkipLF;
}
}

public void close() throws IOException {
synchronized (lock) {
if (in == null) {
return;
}
in.close();
in = null;
cb = null;
}
}
}

[schien]

import java.io.*;
import java.util.*;
import javax.microedition.io.*;

public class ServerConnection {
DataOutputStream dos;
StreamConnection connection;
TCPHandlerListener listener;
boolean connected = false;
public ServerConnection(String serverAddress, int port,
TCPHandlerListener listener) {

this.listener = listener;
try {
this.connection = (StreamConnection) Connector.open("socket://" +
serverAddress + ":" + port);
connected = true;
}
catch (IOException e) {
connected = false;
listener.serverDisconnected();
return;
}
readLoop();
}

public synchronized boolean isConnected() {
return connected;
}

synchronized void disconnect() {
try {
connected = false;
listener.serverDisconnected();
if (connection != null) {
connection.close();
}
}
catch (IOException e) {}
}

public void sendMessage(String msg) {

try {
if (dos == null) {
dos = new DataOutputStream(connection.openDataOutputStream());
}
byte cmd[] = msg.getBytes("UTF-8");
dos.write(cmd, 0, cmd.length);
dos.flush();
System.out.println("ServerConnection::sendMessage>>> " +
msg.toString());
}
catch (Exception e) {}
}

private void readLoop() {
Thread readThread = new Thread() {
public void run() {
BufferedReader br;
try {
br = new BufferedReader(new InputStreamReader(connection.
openDataInputStream(), "UTF-8"));
}
catch (IOException e) {
disconnect();
return;
}
String inputLine;
int i = 0;
while (connected) {
try {
inputLine = br.readLine();
System.out.print(i++);
System.out.println("<<< " + inputLine);
if (inputLine == null) {
disconnect();
break;
}
}
catch (NoSuchElementException e) {
System.out.println("NoSuchElementException");
continue;
}
catch (IOException e) {
System.out.println("IOException");
continue;
}
(new HandleMessage(inputLine)).run();
}
disconnect();
}
};
readThread.start();
}

class HandleMessage
extends Thread {
String msg;
public HandleMessage(String msg) {
this.msg = msg;
}

public void run() {
listener.incomingMessage(msg);
}
}
}

[schien]

import javax.microedition.lcdui.*;

class TCPForm
extends Form
implements CommandListener, TCPHandlerListener {
private final TCPMIDlet midlet;
private final TextField dataField;
private final StringItem statusField;
private final Command sendCommand;
private final Command quitCommand;
private ServerConnection sc;

TCPForm(TCPMIDlet midlet) {
super("TCP MIDlet");
this.midlet = midlet;
sc = new ServerConnection("207.46.104.20",1863,this);
dataField = new TextField("Commands", "VER 1 MSNP10 MSNP9", 255,
TextField.ANY);
append(dataField);
statusField = new StringItem("Status", null);
append(statusField);

sendCommand = new Command("Send", Command.SCREEN, 2);
addCommand(sendCommand);
quitCommand = new Command("Quit", Command.EXIT, 1);
addCommand(quitCommand);
setCommandListener(this);
}

public void commandAction(Command cmd, Displayable disp) {
if (cmd == sendCommand) {
String data = dataField.getString()+"\r\n";
statusField.setText("Sending...");
sc.sendMessage(data);
//handler.queueMessageForSending(data);
}
else if (cmd == quitCommand) {
midlet.formQuit();
}
}

public void handleMessage(byte[] data) {
String msg = new String(data);
statusField.setText("Received: \"" + msg + "\"");
}

public void handleError(String errorMessage) {
statusField.setText("I/O Error in receive: \"" + errorMessage + "\"");
}
public void serverDisconnected(){
sc = null;
}
public void incomingMessage(String msg) {
this.append("R:"+msg);
System.out.println(msg);
}
}

[schien]

interface TCPHandlerListener {
void handleMessage(byte[] data);
public void incomingMessage(String msg);
public void serverDisconnected();
void handleError(String errorMessage);
}

[schien]

import java.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;

public class TCPMIDlet
extends MIDlet {
private final TCPForm form;
public TCPMIDlet() throws IOException {
form = new TCPForm(this);
}

public void startApp() {
Display.getDisplay(this).setCurrent(form);
}

public void pauseApp() {
}

public void destroyApp(boolean unconditional) {
}

private void quit() {
destroyApp(false);
notifyDestroyed();
}

void formQuit() {
quit();
}
}