[J2ME] Meerdere requests over 1 HttpConnection

[Verwijderd]

Ik wil via een MIDlet communiceren met een server. Om het portable te maken ben ik toegwezen op de HttpConnection-interface omdat deze minimaal in elke MIDP implementatie zit. Om het dataverkeer tot een minimum te beperken wil ik het verzenden van http-headers beperken.

Door testen met een eigen-geschreven-server ben ik erachter gekomen dat je voor de reactie van server naar client (MIDP enabled device) iig wel de juiste http-headers moet gebruiken omdat de client het anders niet kan verwerken Daar valt dus weinig op te besparen.

Aangezien de server van eigen hand is ben ik dus voor het verkeer van client naar server niet afhankelijk van http-headers. Echter zorgt de HttpConnection-interface er automagisch voor dat er bij een request toch headers mee worden gestuurd
Nou vroeg ik me af of het mogelijk zou zijn om die maar 1 keer te laten verzenden om vervolgens data naar de server te sturen zonder die headers. Of zou het zelfs mogelijk zijn om het versturen van die headers uit te zetten? (wat btw me sterk lijkt)

Hieronder wat testcode die een request verstuurd en een reactie daarop van de server verwerkt. Dit werkt prima. Als ik nu echter na het gebruik van de InputStream opnieuw een request wil versturen mbv de OutputStream krijg ik een fout: "connection already open". Dit zou er op kunnen wijzen dat een request-response model zoals ik die zou willen toepassen niet mogelijk is. Dit weet ik echter niet zeker. Zou iemand een licht in de duisternis kunnen schijnen?

Java:

package TestMIDlet;

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

//Nodig om netwerkverbindingen te maken
import java.io.*;
import javax.microedition.io.*;

public class TestSuiteMIDlet extends javax.microedition.midlet.MIDlet {

    HttpConnection m_Con     = null;
    OutputStream   m_Os      = null;
    InputStream    m_Is      = null;    
    Display        m_Display = null;
    TextBox        m_Tb      = null;
    StringBuffer   m_Buff    = new StringBuffer();
    String         m_Url     = "http://localhost:9999";
    int            i         = 0;
      
    public TestSuiteMIDlet(){
        m_Display = Display.getDisplay(this);
    }
    
    public void startApp() {
        m_Tb = new TextBox("TestMIDlet", "Opening conn...\n", 1024, 0);
        m_Display.setCurrent(m_Tb);
        
        try{
            m_Con = (HttpConnection)Connector.open(m_Url);
            m_Os  = m_Con.openOutputStream();//tijdens deze aanroep vind de daadwerkelijke connect() plaats
            
            i = m_Tb.size();
            m_Tb.insert("Connected!\n", i);                 
            
            //versturen request 1
            m_Os.write("request1".getBytes());
            m_Os.flush();
            
            //ontvangen en verwerken response server
            m_Is = m_Con.openInputStream();
            int ch;
            while ((ch = m_Is.read()) != -1){
                m_Buff.append((char) ch);
            }
       
            i = m_Tb.size();
            m_Tb.insert(m_Buff.toString(), i);
            
            //Nog een request na gebruik Inputstream, geeft een Exception :(
            //m_Os.write("request2".getBytes());
            //m_Os.flush();
        }
        catch(IOException e){
            i = m_Tb.size();
            m_Tb.insert(e.toString(), i);
        }
    }
    
    public void pauseApp() {
    }
    
    public void destroyApp(boolean unconditional) {
    }
}

[Postman]

Je gebruikt streams zo te zien. Een stream (in tegenstelling tot een socket) blijft altijd open staan, tenzij je hem zelf sluit (of via een time-out?). Dat je die error krijgt is dus niet verwonderlijk, je connectie staat immers ook nog open. Dit lost denk ik ook meteen je probleem op: je hebt namelijk al een openstaande connectie, en zult dus (waarschijnlijk) geen nieuwe headers hoeven te versturen. Je moet alleen nog zorgen dat je maar 1 keer een connectie opent, en daarna alleen maar schrijft.
_{Ik heb _geen_ ervaring met de MicroEdition, en of wat ik zeg helemaal klopt weet ik niet. Ik vertel alleen maar wat ik weet over de 'standaard' Java. Mocht ik onzin blaten, bekijk deze post dan alszijnde niet geplaatst.}

[Verwijderd]

Ik open maar 1 HttpConnection, 1 OutputStream en 1 Inputstream. Ik open dus 1 connectie en 2 streams. Deze probeer ik opnieuw te gebruiken maar dat wil dus niet lukken en dat is mijn probleem. Zoals je kunt zien in de code probeer ik dan ook niet opnieuw een connectie te openen maar probeer ik de OutputStream opnieuw te gebruiken nadat ik de response van de server verwerkt heb dmv een InputStream.

[Postman]

Probeer die flush eens te doen na de 2de write. Ik denk namelijk dat het daar aan ligt. Ik kan namelijk ook nergens een voorbeeld vinden waar ze write, flush, write, flush, etc. doen en dan pas close. m_Os.close is dus ook nodig, anders blijft je verbinding open staan.

[Verwijderd]

Als ik maar 1 keer flush stuur ik ook maar 1 keer iets naar de server...

In bovenstaande situatie wordt 'request1' verstuurd omdat er gelijk daarna een flush plaatsvind. Als ik die flush verplaats zoals jij aangeeft wordt 'request1' pas verstuurd met 'request2'. Ik kan dan ook nooit een response krijgen na de eerste request in deze situatie omdat ik dan enkel de OutputStream (=buffer) gevuld heb met 'request1' en deze pas verstuurd wordt als er een flush plaatsvind.