DAten von der Activity an einen Thread senden

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • DAten von der Activity an einen Thread senden

    Hallo Gemeinde,
    ich grüble schon seit Tagen über ein Problem und finde keine Lösung:
    Meine Activity startet einen separaten "Netzwerk"-Thread, der eine TCP/IP Kommunikation mit einem Server handelt.
    Momentan übergebe ich das Sendekommando einfach im Konstruktor des Netzwerk-Threads.
    Der Thread baut eine Verbindung zum Server auf, schickt das im Konstruktor übergebene Kommando an den Server,
    liest die Antwort zurück und sendet sie über einen Handler per Message an den UI-Thread.
    Danach wird die Verbindung und der Thread wieder beendet.

    Ich möchte allerdings, dass der Thread die Verbindung hält, und weitere Sendekommandos ausführt.
    Nur: Wie bekomme ich die Kommandos vom UI Thread an den Netzwerk-Thread?

    Alle Beispiele, die ich bisher gefunden haben, zeigen nur den Empfangsweg, nicht aber das Senden.
    Ich stehe auf dem Schlauch.
    Hier ist mein Code, den ich auf das Wesentliche zusammengeschrumpft habe:

    Quellcode

    1. public class MainActivity extends AppCompatActivity implements View.OnClickListener
    2. {
    3. private Thread networkThread = null;
    4. @Override
    5. protected void onCreate(Bundle savedInstanceState)
    6. {
    7. super.onCreate(savedInstanceState);
    8. // Hier wird das Kommando übergeben
    9. // Das möchte ich hier aber nicht, sondern später per Buttonklick
    10. networkThread = NetworkThread(mHandler, "GETSTATE");
    11. networkThread.start();
    12. }
    13. final Handler mHandler = new Handler()
    14. {
    15. public void handleMessage(Message msg)
    16. {
    17. Bundle bundle;
    18. if(msg.what==1)
    19. {
    20. bundle = msg.getData();
    21. Toast.makeText(getApplicationContext(),
    22. String.valueOf(bundle.getInt("key1")),
    23. Toast.LENGTH_LONG).show();
    24. }
    25. super.handleMessage(msg);
    26. }
    27. };
    28. public void onClick(View v)
    29. {
    30. if ( v == buttonSend )
    31. {
    32. // hier sollen andere Kommandos gesendet werden
    33. }
    34. }
    35. }
    36. // der Netztwerk.Thread:
    37. public class NetworkThread extends Thread
    38. {
    39. private static final String SERVER_URL = "Server";
    40. private static final int SERVER_PORT = 8007;
    41. private Handler messageHandler;
    42. private String messageSend;
    43. private String messageReceive;
    44. public NetworkThread( Handler msgHandler, String msg )
    45. {
    46. this.messageHandler = msgHandler;
    47. this.messageSend = msg;
    48. }
    49. // runnable
    50. public void run()
    51. {
    52. //create the bundle
    53. Bundle bundle = new Bundle(4);
    54. try
    55. {
    56. Socket socket = new Socket( SERVER_URL, SERVER_PORT );
    57. BufferedWriter out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
    58. BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    59. // Write request to server
    60. out.write(this.messageSend);
    61. out.flush();
    62. // read request response from server
    63. this.messageReceive = in.readLine();
    64. // Close the output stream
    65. out.close();
    66. in.close();
    67. // Close the socket connection
    68. socket.close();
    69. }
    70. catch(Exception ex)
    71. {
    72. //:TODO Handle exceptions
    73. }
    74. //create a message from the message handler to send it back to the main UI
    75. Message msg = this.messageHandler.obtainMessage();
    76. //specify the type of message
    77. msg.what = 1;
    78. //attach the bundle to the message
    79. msg.setData(bundle);
    80. //send the message back to main UI thread
    81. this.messageHandler.sendMessage(msg);
    82. }
    83. }
    Alles anzeigen
  • Danke für die Antwort,
    ich verstehe allerdings nicht, wie mir das jetzt bei meinem Problem helfen soll.
    Ob ich jetzt normale Tasks oder Async-Tasks verwende bleibt gleich.
    Ein Thread/Task wird gestartet, bekommt beim Start Parameter übergeben (was er machen soll) ,
    führt etwas aus und wird nach der Ausführung beendet.

    Ich möchte einen Thread / Task ohne Parameter starten, der solange läuft, wie die Main Activity läuft.
    Und ich möchte on demand Kommandos von der Main-Activity an den Task senden, die er dann ausführt.

    Ich habe heute ein paar Beispiele gefunden, wie man einen Thread mit einem Handler/Looper erweitert.
    Ich glaube, das ist das, was ich suche, allerdings sind die Beispiele nicht kompilierbar.
    Das ist echt schwer zu verstehen.
  • Das ist ja alles ganz nett, nur beantwortet es meine Frage nicht.

    Meine Frage war: Wie kann ich (egal ob Thread, Task, Service, was auch immer ) starten,
    und dann mehrmals hintereinander Daten an den Thread/Task/Serviece/WasAuch immer senden?

    Ich habe jetzt ein Beispiel gefunden, bei dem ein Handler-Thread mit einem Handler versehen wird.
    Die Main Activity startet den Handler Thread, der Handler Thread erzeugt einen Handler, über den ich Daten an
    ihn senden kann ( genau das suche ich ! ), die der Handler dann ausführt.

    Nur leider: Es funktioniert nicht so, wie im Tutorial beschrieben.

    Die Daten werden von der Main-Activity an den Handler des Threads gesendet mit:

    Quellcode

    1. Message msg = new Message();
    2. msg.what = 1;
    3. threadNetwork.handlerNetwork.sendMessage(msg);
    Auf den Handler handlerNetwork kann ich aber von der Main-Activity nicht zugreifen. (Compilerfehler).

    Wenn es so gehen würde, wäre es genau das, was ich suche.
    Hier der komplette Code.

    Quellcode

    1. public class NetworkThread extends HandlerThread
    2. {
    3. public Handler handlerNetwork;
    4. public NetworkThread(String name)
    5. {
    6. super(name);
    7. }
    8. @Override
    9. protected void onLooperPrepared()
    10. {
    11. handlerNetwork = new Handler(getLooper())
    12. {
    13. @Override
    14. public void handleMessage(Message msg)
    15. {
    16. // process incoming messages here
    17. // this will run in non-ui/background thread
    18. }
    19. };
    20. }
    21. }
    Alles anzeigen


    Quellcode

    1. public class MainActivity extends AppCompatActivity implements View.OnClickListener
    2. {
    3. Button button;
    4. TextView textview;
    5. HandlerThread threadNetwork;
    6. @Override
    7. protected void onCreate(Bundle savedInstanceState)
    8. {
    9. super.onCreate(savedInstanceState);
    10. setContentView(R.layout.activity_main);
    11. textview = findViewById(R.id.textview);
    12. button = findViewById(R.id.button);
    13. button.setOnClickListener(this);
    14. threadNetwork = new HandlerThread("Network Handler");
    15. threadNetwork.start();
    16. }
    17. @Override
    18. protected void onDestroy ()
    19. {
    20. super.onDestroy();
    21. threadNetwork.quit();
    22. }
    23. public void onClick(View v)
    24. {
    25. if ( v == button )
    26. {
    27. Message msg = new Message();
    28. msg.what = 1;
    29. threadNetwork.handlerNetwork.sendMessage(msg);
    30. }
    31. return;
    32. }
    33. }
    Alles anzeigen

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Adreoid ()

  • Hallo dann schaue dir mal die das Beispiel an.
    Würde sagen das zweite ist das was du suchst.

    oreilly.com/library/view/effic…g/9781449364120/ch04.html

    Quellcode

    1. public class LooperActivity extends Activity { LooperThread mLooperThread; private static class LooperThread extends Thread { public Handler mHandler; public void run() { Looper.prepare(); mHandler = new Handler() { public void handleMessage(Message msg) { if(msg.what == 0) { doLongRunningOperation(); } } }; Looper.loop(); } } public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); mLooperThread = new LooperThread(); mLooperThread.start(); } public void onClick(View v) { if (mLooperThread.mHandler != null) { Message msg = mLooperThread.mHandler.obtainMessage(0); mLooperThread.mHandler.sendMessage(msg); } } private void doLongRunningOperation() { // Add long running operation here. } protected void onDestroy() { mLooperThread.mHandler.getLooper().quit(); } }
    Ein Feedback auf Tipps ist auch schön. :P

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von jogimuc ()

  • Hallo dann schaue dir mal die das Beispiel an.
    Würde sagen das zweite ist das was du suchst.

    oreilly.com/library/view/effic…g/9781449364120/ch04.html

    Quellcode

    1. public class LooperActivity extends Activity { LooperThread mLooperThread; private static class LooperThread extends Thread { public Handler mHandler; public void run() { Looper.prepare(); mHandler = new Handler() { public void handleMessage(Message msg) { if(msg.what == 0) { doLongRunningOperation(); } } }; Looper.loop(); } } public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); mLooperThread = new LooperThread(); mLooperThread.start(); } public void onClick(View v) { if (mLooperThread.mHandler != null) { Message msg = mLooperThread.mHandler.obtainMessage(0); mLooperThread.mHandler.sendMessage(msg); } } private void doLongRunningOperation() { // Add long running operation here. } protected void onDestroy() { mLooperThread.mHandler.getLooper().quit(); } }
    Ein Feedback auf Tipps ist auch schön. :P