1. Nimm jetzt an unserem 2. ADVENT-Gewinnspiel teil - Alle Informationen findest Du hier!

Android Socketanbindung geht mit Android 3.2 nicht

Dieses Thema im Forum "Android App Entwicklung" wurde erstellt von rotaugenbaumfrosch, 23.03.2012.

  1. rotaugenbaumfrosch, 23.03.2012 #1
    rotaugenbaumfrosch

    rotaugenbaumfrosch Threadstarter Neuer Benutzer

    Beiträge:
    6
    Erhaltene Danke:
    0
    Registriert seit:
    23.03.2012
    Hallo zusammen!

    Mein Problem ist, ich habe eine App die eine Socketverbindung von einem Android Gerät (Motorola Xoom, Android 3.2) zu einem PC aufbauen soll.
    Es soll der Text aus einer XML-Datei eingelesen und über die Verbindung verschickt werden.

    Wenn ich meinen Quellcode mit einem Android 4.0 Emulator in Eclipse laufen lasse funktioniert alles einwandfrei,
    mit Android 3.2 leider nicht. Mit Android 3.2 ist es mit nicht möglich Daten zu senden oder zu empfangen und ich verstehe nicht wieso.

    Ich hoffe jemand kann mir ein paar Tipps geben woran es liegen könnte.

    Vielen Dank in voraus :)

    Anbei mein Quellcode

    Code:
    
    package a.b.c;
    
    import java.io.BufferedReader;
    import java.io.DataInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.net.InetSocketAddress;
    import java.net.Socket;
    import java.net.SocketAddress;
    
    import org.xmlpull.v1.XmlSerializer;
    
    //import Packet.XML.Datei.R;
    import android.R.layout;
    import android.app.Activity;
    import android.content.Context;
    import android.os.AsyncTask;
    import android.os.Bundle;
    import android.os.Environment;
    import android.util.Log;
    import android.util.Xml;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.Button;
    import android.widget.EditText;
    import android.widget.TextView;
    import android.widget.Toast;
    
    public class TesttestActivity extends Activity 
    {
        /** Called when the activity is first created. */
       
         
            Button btnStart, btnSend, btnEnde;
            TextView textStatus;
            NetworkTask networktask;
    
    
            @Override
            public void onCreate(Bundle savedInstanceState) 
            {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.main);
                   
                
                    
                btnStart = (Button)findViewById(R.id.btnStart);                                //Nachricht-Senden Button initialisieren
                btnEnde = (Button)findViewById(R.id.btnEnde);                                //Nachricht-Senden Button initialisieren
                btnSend = (Button)findViewById(R.id.btnSend);                                //Nachricht-Senden Button initialisieren
                
                textStatus = (TextView)findViewById(R.id.textStatus);                        //Textfeld initialisieren
                
                btnStart.setOnClickListener(btnStartListener);                                //OnClick Listener für den Start Button zuweisen
                btnSend.setOnClickListener(btnSendListener);                                //OnClick Listener für den Senden Button zuweisen
                btnEnde.setOnClickListener(btnEndeListener);                                  //OnClick Listener für den Ende Button zuweisen
                
                networktask = new NetworkTask();                                             //Create initial instance so SendDataToNetwork doesn't throw an error.
            }
    
        //--------------------------OnClickListener . Aufgerufen beim Drücken des Ende Buttons------------------------------------------------    
            
                private OnClickListener btnEndeListener = new OnClickListener() 
                {
                    public void onClick(View v)
                    {
                        networktask.beenden();
                        btnStart.setVisibility(View.INVISIBLE);
                    }
                    
                };
            
        //--------------------------OnClickListener . Aufgerufen beim Drücken des START Buttons------------------------------------------------    
            
            private OnClickListener btnStartListener = new OnClickListener() 
            {
                public void onClick(View v)
                {
                    btnStart.setVisibility(View.INVISIBLE);
                    networktask = new NetworkTask();                                         //New instance of NetworkTask
                    networktask.execute();
                }
            };
    
        //-----------------------OnClickListener . Aufgerufen beim Drücken des Nachrichtenbuttons------------------------------------------------    
            
            private OnClickListener btnSendListener = new OnClickListener() 
            {
                public void onClick(View v)
                {
                    String test = "";
                    
                    try{
    
                        File f = new File(Environment.getExternalStorageDirectory()+"/txt.xml");
    
                        FileInputStream fileIS = new FileInputStream(f);
    
                        BufferedReader buf = new BufferedReader(new InputStreamReader(fileIS));
    
                        String readString = new String();
    
                        //just reading each line and pass it on the debugger
    
                        while((readString = buf.readLine())!= null)
                        {
    
                        Log.d("line: ", readString);
                        test = test + readString;
                        }
    
                        } catch (FileNotFoundException e) {
    
                        e.printStackTrace();
    
                        } catch (IOException e){
    
                        e.printStackTrace();
    
                        }
                    
                    textStatus.setText("Sending Message to AsyncTask.");
                    
                    //networktask.SendDataToNetwork("GET / HTTP/1.1\r\n\r\n");
                     networktask.SendDataToNetwork(test);
                }
            };
    
    
        //----------------------Socketverbindung aufbauen ----------------------------------------------------------------------------------    
    
            public class NetworkTask extends AsyncTask<Void, byte[], Boolean> 
            {
                Socket nsocket;                                                                 //Network Socket
                InputStream nis;                                                                 //Network Input Stream    
                OutputStream nos;                                                                 //Network Output Stream
            
                @Override                                                                        //    **    
                protected void onPreExecute()                                                     //    **
                {                                                                                // Unterklasse von AsyncTast
                    Log.i("AsyncTask", "onPreExecute");                                            //        
                }                                                                                //    **
    
                @Override
                protected Boolean doInBackground(Void... params)                                 //Unterklasse von AsynkTask 
                {                                                                                 // - Klasse in der die Socket Verbindung ausgeführt wird - 
                    boolean result = false;                                                        
                                                                                                
                    try                                                                         
                    {                                                                            
                        Log.i("AsyncTask", "doInBackground: Creating socket");                     //Logeinträge zur Dokumentation
                                                                                                
                        SocketAddress sockaddr = new InetSocketAddress("192.168.247.37", 4711); // Socketverbindung aufbauen
                        
                        nsocket = new Socket();                                    
                        nsocket.connect(sockaddr, 5000);                                         //10 second connection timeout
                        
                        if (nsocket.isConnected()) 
                        {   
                            nis = nsocket.getInputStream();                                 
                            nos = nsocket.getOutputStream();
                            
                            Log.i("AsyncTask", "doInBackgr                                                                                                                       ound: Waiting for inital data...");
                            
        //------------------Daten werden eingelesen-----------------------------------------------------------------------------------------------------------               
                            
                            byte[] buffer = new byte[4096];
                            int read = nis.read(buffer, 0, 4096);                                 //This is blocking
                                
                            while(read != -1)
                            {
                                byte[] tempdata = new byte[read];
                                
                                System.arraycopy(buffer, 0, tempdata, 0, read);
                                
                                publishProgress(tempdata);
                                
                                Log.i("AsyncTask", "doInBackground: Got some data");
                                read = nis.read(buffer, 0, 4096);                                 //This is blocking 
                            }
                        }
                    } 
                    catch (IOException e) 
                    {
                        e.printStackTrace();
                        Log.i("AsyncTask", "doInBackground: IOException");
                        result = true;
                    } 
                    catch (Exception e) 
                    {
                        e.printStackTrace();
                        Log.i("AsyncTask", "doInBackground: Exception");
                        result = true;
                    } 
                    finally 
                    {
                        try 
                        {
                            nis.close();
                            nos.close();
                            nsocket.close();
                        } 
                        catch (IOException e) 
                        {
                            e.printStackTrace();
                        } 
                        catch (Exception e) 
                        {
                            e.printStackTrace();
                        }
                        
                        Log.i("AsyncTask", "doInBackground: Finished");
                    }
                    return result;
                }
          
        // -------------------------------------Datei senden------------------------------------------------------------------------------        
              
                public void SendDataToNetwork(String cmd) 
                {                                                                                     //You run this from the main thread.
                    //cmd ="sss";
                    try 
                    {
                        if (nsocket.isConnected()) 
                        {               
                            Log.i("AsyncTask", "SendDataToNetwork: Writing received message to socket");
                            nos.write(cmd.getBytes());
                        } 
                        else 
                        {
                            Log.i("AsyncTask", "SendDataToNetwork: Cannot send message. Socket is closed");
                        }
                    } 
                    catch (Exception e) 
                    {
                        Log.i("AsyncTask", "SendDataToNetwork: Message send failed. Caught an exception");
                        String ErrorMessage = e.getMessage();
                    }
                }
                     
        //----------------------------------Unterklasse von asynkTask----------------------------------------------------------------------
               
                @Override
                protected void onProgressUpdate(byte[]... values) 
                {
                    if (values.length > 0) 
                    {
                        Log.i("AsyncTask", "onProgressUpdate: " + values[0].length + " bytes received.");
                        textStatus.setText(new String(values[0]));
                    }
                }
    
        //----------------------------------Bei Abruch der Verbindung Button wieder sichtbar machen--------------------------------------        
                
                @Override
                protected void onCancelled() 
                {
                    Log.i("AsyncTask", "Cancelled.");
                    btnStart.setVisibility(View.VISIBLE);
                }
    
        //----------------------------------Socket VErbindung beenden--------------------------------------               
                
                public void beenden() 
                {
                    try 
                    {
                        nsocket.close();
                    } 
                    catch (IOException e) 
                    {
                        e.printStackTrace();
                        Log.i("AsyncTask", "Socket Verbindung beenden gescheitert");
                    }
                    
                    btnStart.setVisibility(View.VISIBLE);
                }
                
        //-------------------------------Fehlermeldung------------------------------------------------------------------------------------        
                
                @Override
                protected void onPostExecute(Boolean result) 
                {
                    if (result) 
                    {
                        Log.i("AsyncTask", "onPostExecute: Completed with an Error.");
                        textStatus.setText("There was a connection error.");
                    } 
                    else 
                    {
                        Log.i("AsyncTask", "onPostExecute: Completed.");
                    }
                    
                    btnStart.setVisibility(View.VISIBLE);
                }
            }
    
        //-------------------------------Fehlermeldung------------------------------------------------------------------------------------        
            
            @Override
            protected void onDestroy() 
            {
                super.onDestroy();
                networktask.cancel(true);                                                     //In case the task is currently running
            }
        }
    
    
     
  2. Sentence, 23.03.2012 #2
    Sentence

    Sentence Erfahrener Benutzer

    Beiträge:
    242
    Erhaltene Danke:
    51
    Registriert seit:
    27.01.2011
    Phone:
    S3, S6 Edge
    Logcat?
     
  3. v Ralle v, 23.03.2012 #3
    v Ralle v

    v Ralle v Android-Lexikon

    Beiträge:
    913
    Erhaltene Danke:
    199
    Registriert seit:
    27.08.2010
    Du schickst Daten im GUI Thread, da gibt es eine Exception (NetworkOnMainThread). Schieb den Code in einen Backgroundthread, dann könnte es klappen. Noch als Anmerkung: Dateien auch in einem Background Thread lesen / schreiben. Schau dir weiterhin die StringBuilder Klasse an. string += string ist böse für die Performance ;)
     
    rotaugenbaumfrosch bedankt sich.
  4. rotaugenbaumfrosch, 26.03.2012 #4
    rotaugenbaumfrosch

    rotaugenbaumfrosch Threadstarter Neuer Benutzer

    Beiträge:
    6
    Erhaltene Danke:
    0
    Registriert seit:
    23.03.2012
    Vielen lieben Dank erst mal ! :)

    Ich bin leider noch ziemlicher Android Neuling :(
    Wie genau baue ich meinen Code denn in einen Backgroundthread?
    Wäre nett wenn du mir ein Beispiel oder so geben könntest. :)
     
  5. DieGoldeneMitte, 26.03.2012 #5
    DieGoldeneMitte

    DieGoldeneMitte Android-Lexikon

    Beiträge:
    1,230
    Erhaltene Danke:
    256
    Registriert seit:
    05.02.2010
    Phone:
    Nexus 5X
    Tablet:
    Nexus 7 (2013)
    Ansich hast du den Netzwerkzeugs schon ganz richtig gemacht. Aber:

    * Das Objekt networkTask im onCreate ist natürlich sinnlos, weil du es im onClick ohnehin (richtigerweise) neu erzeugst.
    * Du funktion beenden macht network IO im UI Thread.
     
    Zuletzt bearbeitet: 26.03.2012
    rotaugenbaumfrosch bedankt sich.
  6. rotaugenbaumfrosch, 26.03.2012 #6
    rotaugenbaumfrosch

    rotaugenbaumfrosch Threadstarter Neuer Benutzer

    Beiträge:
    6
    Erhaltene Danke:
    0
    Registriert seit:
    23.03.2012
    @DieGoldeneMitte
    Danke habe die Sachen geändert.

    Was ich aber noch icht ganz verstehe ist wieso ich keine Daten senden kann.
    Die Methode in der ich Daten senden will befindet sich doch in einer Klasse die AsynkTask verwendet.
    Eine Idee was ich ändern muss/kann damit ich keine NetworkOnMainThread Exception mehr bekomme? :(
     
  7. v Ralle v, 26.03.2012 #7
    v Ralle v

    v Ralle v Android-Lexikon

    Beiträge:
    913
    Erhaltene Danke:
    199
    Registriert seit:
    27.08.2010
    Du hast die Klasse AsyncTask falsch verstanden. Weiterhin glaube ich, dass du mit MultiThreading noch nicht erfahren bist. Recherchiere dazu mal im Internet.

    Nur weil die senden Methode in einer Klasse vom AsyncTask ist, heißt es nicht, dass das Senden in einem BackgroundThread passiert. Es kommt darauf an, wo die Methode aufgerufen wird. In deinem Fall im GUI Thread. Alles, was in doInBackground aufgerufen wird, wird auch im Hintergrund gemacht. Einen AsyncTask auszuführen, kann als asynchroner Methodenaufruf für doInBackground aufgefasst werden.

    Beispiel:

    onClick(..) {
    meineMethode(); // Im GUI Thread, egal wo die Methode steht
    }

    ...

    doInBackground(..) {
    meineMethode(); // In einem Background Thread, egal wo die Methode steht
    }


    Verstehst du, es spielt keine Rolle, wo die Methode definiert wird, sondern aus welchem Thread sie aufgerufen wird.
     
    rotaugenbaumfrosch bedankt sich.
  8. rotaugenbaumfrosch, 27.03.2012 #8
    rotaugenbaumfrosch

    rotaugenbaumfrosch Threadstarter Neuer Benutzer

    Beiträge:
    6
    Erhaltene Danke:
    0
    Registriert seit:
    23.03.2012
    Vielen lieben Dank jetzt funktioniert es :)
     

Diese Seite empfehlen