Verständnisfrage Asynctask

Hi Snipor,

deine Fragen 1 & 2 laufen eignetlich aufs selbe hin:
Wenn du deine ipcon / socket etc variablen nur im "doinbackground" hälts und keine refernez in deiner klasse die den async task aufruft hälst, oder sonst wo, dann kannst du ausserhalb des async task sowieso nicht mehr darauf zugreifen, der garbage collector wird die nach belieben verwerfen.
Wenn du die variablen aber in deiner klasse definiert hast, und nicht nur im "doinbackground", dann sind sie auch nacher noch vorhanden. die methoden werden aber immer in dem thread ausgführt, von dem du sie aufrufst. instanziert du deine tcp/ip sachen also im "doinbackground" gibts keinen fehler, führst du dann aber im mainthread eine funktion darauf aus, wirds wohl eine "networkonmainthread" exception geben.
Gut, dass nützt dir nichts

Ich denke eher es ist eine konzeptionelle frage. Was willst du genau anstellen?
Willst du etwas einmalig tun, zB ein Bild herunterladen oder eine http get / post anwort erhalten? Dann ist der AsyncTask okay, du instanziert alle network sachen im DoInBackground, führst deine anfragen aus, schliesst alle connections wieder sauber.
Willst du allerdings etwas machen das "länger" hält, also die verbindung aufrecht erhält und auf einen aktion vom server wartet um antwort zu geben, oder vielleicht alle 10sekunden etwas schickt? Dann würde ich eine separate Klasse erstellen welche einen eigenen Thread erstellet der solange läuft wie deine App läuft (oder du halt die Verbindung brauchst)

Ja, bei dauerhafter Verbindung ist der AsyncTask aber nicht zu empfehlen!

Genau, separate Klasse mit einem Endlos Loop der deine Kommunikation macht, dazu ein paar Callbacks für deine Acitvity das neue Daten parat sind.
Dort dann einfach darauf schauen, dass wenn du UI Elemente aktualisiert, dies unbedignt auf dem MainThread tun musst.
Da mir gerade ein bisschen langweilig war habe ich dir ein kleines Demo Project gemacht.
Das liest alle 5 Sekunden die aktuelle Uhrzeit von einer Webseite und senden sie an deine MainActivity, dort wird auf dem UI Thread die View aktualisiert.
Der Code ist extra simpel gehalten, keine saubere Exception auswertung, das warten ist hässlich gelöst, der Client sollte noch disposed werden etc, aber je weniger code desto einfacher zu verstehen. Einfach fragen wenn etwas nicht klar ist.

Zip File ist hier:
http://nibdev.com/NetTimeDemo.zip

Zitat von snipor

Wird das vom Garbage Collector dann einfach aufgeräumt, oder kann ich das noch nutzen?

Diese Frage ist etwas schwierig zu beantworten.
Die Kurzfassung ist: du sollst dich selbst darum kümmern, deine Dinge (geöffnete Streams, Sockets, Connections, Files etc.pp.) selbst wieder frei zu geben.
Im Falle des Async Task hast du den Vorteil, dass nach dessen Beendigung sämtliche Instanzvariablen ihr Signal zur Freigabe erhalten. Der Garbage Collector räumt dann also alles auf. Leider kann es einige Dinge geben, die beim Aufräumen nicht durchgeführt werden. Das Schließen von Streams einer Socketverbindung zum Beispiel. Hängt also ganz von der Implementierung des Objektes ab.

Zurück zum Thema: solltest du die Verbindung oder Instanz ausschließlich in diesem AsyncTask deklariert und zugewiesen haben, dann kommst du nach Beendigung des Tasks nicht mehr ran. Dir fehlt einfach die Referenz zu dem Objekt. Hast du deinem AsyncTask hingegen das Objekt als Referenz mitgegeben, ist es nach Beendigung des Tasks für dich noch immer verfügbar.

Also zunächst einmal ist das Java, kein Assembler. Man darf, kann und soll seine Variablen sinnvoll ausschreiben.

Weiterhin finde ich es nicht wartbar, wenn irgendwelche Klassen auf irgendwelche Member irgendwelcher anderen Klassen zugreifen.

Die Main würde ich dann so gestalten:

//Blah blah blah... OMG! It's a nipple.
Socket clientSocket = new Socket("192.168.1.1", 2002);
BufferedReader inputBufferedReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
BufferedReader outputBufferedReader = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));
OwnAsyncTask theBackgroundTask = new OwnAsyncTask();
// Jetzt kannst du je nach Implementierung deines Tasks noch weitere Dinge angeben!
theBackgroundTask.setSocket(clientSocket);
theBackgroundTask.setInputReader(inputBufferedReader);
theBackgroundTask.setOutputReader(outputBufferedReader);
// Hier wird der Task erst gestartet.
theBackgroundTask.execute();


// Und hier können die Sockets und Reader und wat weiß ich noch weiter bearbeitet werden. Aber ob das eine gute Idee ist...
inputReader.flush();
outputReader.flush();
clientSocket.close();

Und den Task selbst einfach ein wenig erweitern.

class MyOwnTask extends AsyncTask
{
  private Socket connectionSocket;
  private BufferedReader inputReader;
  private BufferedReader outputReader;


  public void setSocket(Socket theSocket)<Void, Void, Void>
  {
    // Ich will den Socket nur ersetzen, allerdings nicht mit einem NULL Objekt.    
    if(theSocket != null && theSocket != connectionSocket)
    {
        connectionSocket = theSocket;
    }
  }


  public void setInputReader(BufferedReader reader)
  {
    if(reader != null && inputReader != reader)
    {
      inputReader = reader;
    }
  }


  public void setOutputReader(BufferedReader reader)
  {
    if(reader != null && outputReader != reader)
    {
      outputReader = reader;
    }
  }


  private Socket getConnectionSocket()
  {
    // Der Socket ist existenziell.
    if(connectionSocket = null) throw new IllegalArgumentException();
    return connectionSocket;
  }


  private BufferedReader getInputReader()
  {
    if(inputReader == null)
    {
      inputReader = new BufferedReader(new InputStreamReader(getConnectionSocket().getInputStream())); 
    }
    return inputReader;
  }


  private BufferedReader getOutputReader()
  {
    if(outputReader == null)
    {
      outputReader = new BufferedReader(new OutputStreamReader(getConnectionSocket().getOutputStream());
    }
    return outputReader;
  }


  /* Und zum Ende das Bekannte */


  public Void doInBackground(Void... param)
  {
    // Hier kann ganz entspannt auf getConnectionSocket(), getInputReader() und getOutputReader() zugegriffen werden.
  }  


  public Void onPostExecute()
  {
    // Hier ist es auf jeden Fall sicher, sämtlichen Netzwerkverkehr zu unterbinden und freizugeben.
    getInputReader().flush;
    getOutputReader().flush;
    getConnectionSocket().close();
  }
}

Solange du nur ein Socket Objekt erstellst (oder ein Netzwerkobjekt im Allgemeinen) dürfte soweit ich weiß keine Exception gefeuert werden.
Erst wenn du die Verbindung startest, solltest du dich außerhalb des UI Threads befinden.

Zu deinem theoretischen Ansatz:
Neuen Task starten und da die Socketverbindung erstellen klingt gut.

Doch warum willst du die Buffererstellung in einem weiteren Task ausführen?
Da jeder Task wohl sequentiell abgearbeitet wird bringt dir das relativ wenig. Wenn du auf parallele Ausführung bestehst, bringt dir das ebenfalls wenig, da jeder Thread seinen eigenen Speicherbereich zugeteilt bekommt. Hin und her referenzieren wird da also schwierig.

Wofür du jetzt die Referenz auf die Buffer brauchst erschließt sich mir nicht. Doch mit meinem Beispiel hast du sie ja.
(Natürlich sind die irgendwann fertig und könnten geschlossen werden. Ein read auf einen solchen Buffer zu werfen würde dann schwierig und vermutlich in einer Exception enden.)

Aber so ganz konkret habe ich keine Idee was genau du eigentlich bezweckst.
Eventuell wäre es hilfreich, du würdest dein Vorhaben konkreter beschreiben anstatt deines Lösungsansatzes.
Dann kann man dir nämlich nicht nur sagen, ob dein Lösungsansatz der richtige ist, man könnte dir auch sagen, wie du ihn optimiert bekommst.

Wenn du das verständlicherweise nicht in öffentlichen Foren machen möchtest, dann geht das sicher auch per PN.

In dem Fall sollte sich ein Service in einem eigenen Thread um die Verbindung zum WLAN Modul kümmern.
Deine App(s) kommunizier(t/en) dann über Broadcast Messages mit dem Service und vice verda.