×

Discussion Board

Results 1 to 6 of 6
  1. #1
    Registered User
    Join Date
    Mar 2003
    Posts
    16

    S60 communication issues

    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
    Last edited by schien; 2004-07-05 at 07:08.

  2. #2
    Registered User
    Join Date
    Mar 2003
    Posts
    16

    BufferedReader.java

    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;
    }
    }
    }

  3. #3
    Registered User
    Join Date
    Mar 2003
    Posts
    16

    ServerConnection.java

    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);
    }
    }
    }

  4. #4
    Registered User
    Join Date
    Mar 2003
    Posts
    16

    TCPForm.java

    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);
    }
    }

  5. #5
    Registered User
    Join Date
    Mar 2003
    Posts
    16

    TCPHandlerListener.java

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

  6. #6
    Registered User
    Join Date
    Mar 2003
    Posts
    16

    TCPMIDlet.java

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

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  
×