Beiträge von Adreoid

Also scheinbar liegt es am setContentView.
Das scheint Speicher zu allokieren und nicht wieder freizugeben.
(logisch, denn das ist ja das Einzige, was ich in meinem letzten Beispiel noch gemacht habe!)

Ich habe es jetzt mit einem ViewFlipper probiert , und was soll ich sagen : Kein Speicher-Hochschaukeln mehr !

Nein, wie gesagt:
Um alles auszuschließen habe ich eine neue App geschrieben, die aus zwei Activities besteht, und die im Layout jeweils nur einen einzigen Button haben, um zwischen den Activities umzuschalten.
Der Code steht ja in meinem ersten Thread.

Ich habe jetzt mal was anderes versucht:
Eine einzige Activity und zwei Layouts.
Beide Layouts haben jeweils einen einzigen Button.

Und ich schalte jetzt nur die Layouts um.

Also klickt man auf den Button im Main Layyout, wird im onClickListener nur die Funktion setContentView (zweitesLayout) aufgerufen. Und beim Button des zweiten Layouts wieder setContentView vom MainLayout. Und wieder wird bei jedem Wechsel fleißig Speicher allokiert und nicht freigegeben.

Was soll denn da falsch sein???

Wieviel Speicher das Handy hat, ist unerheblich. Denn egal, wieviel es hat, irgendwann ist Ende, wenn dauernd neuer Speicher belegt wird.
Das hier dauernd Speicher allokiert wird, sehe ich im Emulator/Profiler.

Der Effekt, das mein Handy unbedienbar wird, passiert natürlich bei der richtigen App, die sehr viel mehr Speicher allokiert, als diese kleinen Beispiele.Die richtige App wäre zu groß und unübersichtlich, um sie hier anzugeben.

Aber das hier dauernd Speicher allokiert wird, passiert auch im Kleinen hier bei diesen kleinen Beispielen.

Hier der neue Code, bei dem ebenfalls bei jedem Button-Klick immer wieder neuer Speicher belegt wird.:
Ich habe hier zwar Unwichtiges weggelassen, aber die onClick Handler sind vollständig.

private Button buttonToMain;
private Button buttonToSecond;


onCreate()
{
// Hauptfenster anzeigen
setContentView ( R.layout.activity_main );


// der Button zum Anzeigen des zweiten Layouts
buttonToSecond = findViewById ( R.id.button_second );
}


// onClick-Handler für den Button Second layout


public void onClick_Second( View v )
{
// Zweites Layout anzeigen
setContentView ( R.layout.second );


// Button zum Zurueckschalten zu main
buttonToMain = findViewById(R.id.button_main);


return;
}




// onClick-Handler für den Button zurueck zum main Layout


public void onClick_Main( View v )
{
// Main Layout anzeigen
setContentView ( R.layout.main );


return;
}

So schnell wechsel ich auch nicht.
Der angegebene Code war nur als vereinfachtes Beispiel gedacht, bei dem das Problem aber auch real passiert.

Bei dem "richtigen" Projekt schalte ich etwa 5 Mal innerhalb von ca 20 Minuten hin und her und danach ist das System so blockiert, das noch ein Neustart hilft.

Was ich eigentlich erreichen will ist folgendes:
Ich habe eine Main-Activity mit einem Main Layout.
Und ich habe 3 "Neben"-Activities mit ihrem eigenen Layout ( zum Beispiel einen Texteditor ).
Wenn ich mal ein Textfile bearbeiten will, drücke ich auf einen Button der Main Activity, starte damit die Editor Activity
und nach dem Abspeichern des Textes wieder zurück zur Main Activity.
Und wenn ich das 3 Mal gemacht habe, ist das Handy aus Speichermangel nicht mehr bedienbar.

Das liegt aber nicht direkt am Editor, denn das Gleiche passiert auch mit einer einfachen Einstellungs-Activity mit ein paar Edit Feldern und Buttons.

Es wäre schön, wenn man einer einzigen Activity mehrere Layouts zuweisen und hin und herschalten könnte, aber genau davon raten viele Tutorials ab und empfehlen lieber mehrere Activities.

Nur: Irgendwas muss ich dabei falsch machen.

Ich habe schon wieder ein merkwürdiges Problem.

Ich habe zwei Activities mit jeweils einem einzigen einfachen Button.
Bei Click auf den Button der Activity A soll Activity B per Intent gestartet werden und A soll sich beenden.

Bei Klick auf den Button der von A gestarteten Activity B soll wieder A gestartet und B beendet werden.
( Also schalte ich mit den Buttons immer zwischen A und B hin und her.)

Das Problem: Bei jedem Wechsel zwischen den Activities wird wieder neuer Speicher belegt, der Verbrauch steigt also dauernd an bis kein Speicher mehr zur Verfügung steht.

Meine Frage : Wie bekommt man das richtig hin, dass eine beendet App ihren Speicher wieder freigibt.

Hier der Code:

public class MainActivity extends AppCompatActivity
{
private Button buttonStart_B;


@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);


buttonStart_B = findViewById ( R.id.buttonStartB );
}


public void onClick_StartB( View v )
{


Intent myIntent = new Intent ( this, ActivityB.class );


this.startActivity ( myIntent );


finish();


return;
}

public class ActivityB extends AppCompatActivity
{
private Button buttonStart_A;


@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activityB);


buttonStartA    = findViewById ( R.id.buttonSettings );
}


public void onClick_StartA( View v )
{


Intent myIntent = new Intent ( this, MainActivity.class );


this.startActivity ( myIntent );


finish();


return;
}

Das wäre schön, wenn es so gehen würde.
Genau das hätte ich gesucht.
Geht aber leider nicht.
Wenn ich die Klasse markiere und Alt+Enter drücke, dann kommt eine Dropdown-Liste ( "Make public, Make private, make protected" ).
Sonst kommt nix.

Hallo,
ich habe mal wieder ein Problem.
Ich verplempere immer unheimlich viel Zeit damit, herauszubekommen, welchen Import man für welche Symbole braucht.
Aktuelles Beispiel:

Ich brauche einen Task und deklariere :

Task myTask;

Beim Kompilieren kommt die Fehlermeldung, das Symbol Task sei nicht aufzulösen.

Klar: Weil ich einen Import brauche.

Nur welchen ????

Im Internet googelt man sich einen Wolf und manchmal hat man Glück und findet ein vollständiges Beispiel.
Beim Task leider nicht.

Hat jemand einen allgemeingültigen Tip? (also wie bekommt man generell raus, welcher Import wofür benötigt wird)

Hallo Gemeinde,
ich beiße mir mal wieder an einem Problem die Zähne aus.
Ich weiß, es ist schon tausendmal beschrieben und es gibt unzählige Tutorials.
Nur keines funktioniert und ich komme nicht dahinter, wie es richtig geht:

Das Problem:
Ich möchte verschiedene Textdateien erzeugen, falls sie noch nicht existieren.
Das funktioniert im Hauptverzeichnis meiner Applikation gut, nur nicht in einem Unterverzeichnis.
Also diese Datei kann ich erzeugen:
/storage/emulated/0/Android/data/com.example.myApp/files/Test.txt
Diese Datei geht nicht:
/storage/emulated/0/Android/data/com.example.myApp/files/task/blue/Test.txt
Ich bekomme hier eine Exception die besagt, der Pfad sei ein Directory, und keine Datei

Hat jemand vielleicht ein anderes funktionierendes Beispiel, wie man einen Text in eine Datei schreibt, die sich in einem Unterverzeichnis befindet, und wie man das Unterverzeichnis und/oder die Datei erzeugt, wenn sie nicht da sind?

Hier der Code:

String strTaskFilePath = getExternalFilesDir(null) + "/Task/Blue/Test.txt";


try {
  File   myFile = new File (strTaskFilePath);
  myFile.getParentFile().mkdirs();


  myFile.createNewFile(); 


  FileOutputStream fOut = new FileOutputStream(myFile);


  OutputStreamWriter myOutWriter = new OutputStreamWriter(fOut);


  myOutWriter.append(editTextTask.getText());
  myOutWriter.close();
  fOut.close();
  }
catch (Exception e)
  {
  Log.i("Test", "TaskEditActivity: create path exception=" + e.getMessage());
  }

OK, hab's doch hinbekommen.
War nur etwas umständlich.
Man kommt vom Handler aus an die Variablen des Threads nur indirerkt über den Looper.

Looper parentLooper = getLooper();
ClassComThread parentThread = parentLooper.getThread();
parentThread.writer .......

Ich glaube, mein Problem ist eher Java.
Ich tue mich damit echt schwer, ich finde diese Sprache sehr verworren und umständlich.

Ich bin in der Zwischenzeit schon weiter gekommen, und bin im Prinzip auf die gleiche Idee gekommen, wie in deinem Vorschlag:

Ich hab's jetzt so:

public class ClassComHandler extends Handler
  {
  @Override
  public void handleMessage(Message msg)
    {
    // Nachricht verarbeiten
    Log.i("Test","Message from UI Thread" );
    }
  }

Also der UI-Thread erzeugt einen TCP-IP Thread, dieser erzeugt den Handler. UI-Thread,
TCP-Thread und Handler stehen jetzt in einem separaten File.
Die Aufrufe vom UI-Thread kommen jetzt auch im Handler an.

Nur habe ich jetzt wieder das gleiche Problem wie vorher nur in Grün:

Der Handler kann nicht auf Variablen im TCP-Thread zugreifen.

Wenn ich also im TCP-Thread die Verbindung aufbaue, habe ich ja einen Socket.
Und wenn der Sendebefehl vom UI-Thread im Handler ankommt, will ich den Befehl über diesen Socket versenden.
Nur komme da wieder nicht dran.

Irgendwie drehe ich mich ständig im Kreis.

Es ist einfach nicht möglich, Daten von einem Thread in den anderen zu bekommen.
Immer geht irgendwas nicht.

Hier nochmal alles zusammen:

// Auszug aus onCreate in der MainApplication


comThread = new ClassComThread( serverHost, serverPort, msgHandlerApp );
comThread.start();


// in einem onClick-Handler in der MainApplication:


msgToComThread = comThread.msgHandlerCom.obtainMessage(0);
comThread.msgHandlerCom.sendMessage(msgToComThread);


// Die run methode des TCP/IP threads:
 @Override
 public void run()
   {
   Looper.prepare();


   msgHandlerCom = new ClassComHandler();
   try
     {
     socket = new Socket(strHostName, intPortNumber);


     writer = new BufferedWriter( new OutputStreamWriter( socket.getOutputStream() ) );
     reader = new BufferedReader( new InputStreamReader(  socket.getInputStream() ) );
     }
   catch(Exception ex)
     {
//:TODO Handle exceptions
     }


   Looper.loop();
   }
 }


// Und im Com-Handler:
public class ClassComHandler extends Handler
  {
  @Override
  public void handleMessage(Message msg)
    {
    // Nachricht verarbeiten
    // Wie sendet man jetzt hier etwas über den writer des TCP-Treads?????
    // Auf die Variablen des TCP-Threads habe ich hier keinen Zugriff.
    // der Handler bringt mir also gar nichts, ich kann trotzdem nichts senden.


    Log.i("Test","Message from UI Thread" );
    }
  }

Nochmal die Frage etwas genauer beschrieben:

Ich möchte einen TCP/IP Client schreiben.

Alle Beispiele, die ich im Netz finde, funktionieren nicht, sind extrem kompliziert und nicht nachvollziehbar,

Wenn es ein einfaches Beispiel gibt, dann funktioniert es IMMER nach folgendem Schema:

1. Main-Activity erzeugt einen Thread und übergibt das zu sendende Kommando im Konstruktor des Threads.
2. Der Thread wird gestartet,
3. der Thread baut eine Verbindung zum Server auf, sendet das im Konstruktor übergebene Kommando, schließt die Verbindung und beendet sich sofort wieder.

Mit anderen Worten :

1. Ich kann immer nur EIN EINZIGES KOMMANDO an den Server senden, nämlich das, was im Konstruktor des Threads übergeben wurde.
2. Für jedes Kommando, was ich senden möchte, wird eine TCP/IP Verbindung auf-und abgebaut .

Was ich jetzt möchte ist folgendes:
Ich möchte die Verbindung halten.
Ich möchte im Thread Konstruktor NUR die Verbindungsdaten übergeben ( Ip-Adresse des Servers, Port)
Ich möchte, das die Run-Methode des Threads NICHT als Sequenz läuft ( Verbinden, Senden; Verbindung trennen, Thread-Ende !)
Ich möchte, das die Run Methode des Threads in einer Schleife läuft, die erst dann beendet wird, wenn ein "Disconnect" Befehl vom UI-Thread gesendet wird.
Und ich möchte vom UI-Thread aus jederzeit und nacheinander Kommandos an den Thread senden, die dieser dann an den Server weitersendet und die Antwort an den UI-Thread zurückgibt.

Und das bekomme ich nicht hin.
Es ist aber kein Kompilierproblem, kein Absturz oder so, sondern eher ein Verständnisproblem, wie man das im Code formuliert.

Meine erste Idee war:
Ich verpasse dem TCP-Client Thread einfach eine neue Methode:
thread.SendData( String Data )
Das habe ich nicht hinbekommen, ich glaube, das es daran liegt, das man einem eigenen Thread, der von einer Android-Thread Klasse abgeleitet wird, keine Extra Funktionen verpassen kann. Man kann nur die vorhandenen überschreiben ( Was man z.B. mit der Run-Methode macht )

Meine zweite Idee war:
Man verpasst dem Thread eine Message-Queue und sendet einfach Messages vom UI-Thread an den TCP-Thread.
Der Empfänger einer Message ist dann ein Handler.

In den Beispielen im Netz steht immer folgendes:
1. Looper hinzufügen
2. Handler definieren/erzeugen
3. Handler mit dem Loopper verbinden.

Also so:

class MyThread extends Thread
    {
    public Handler mHandler;


    @Override
    public void run()
      {
      Looper.prepare();


      mHandler = new Handler()
        {
        public void handleMessage(Message msg)
          {
          // Nachricht verarbeiten
          }
        };
      Looper.loop();
      }
    }

Was mir daran nicht gefällt ist die "eingeschobene" Definition des Handlers.
Wenn man so programmiert, hat man hinterher den kompletten Code einer Applikation in einer Funktion stehen und das finde ich Mist.

Wie bekomme ich den Handler "aus der Run-Methode raus"?

Ich möchte es so haben :

class MyThread extends Thread
 {
 public Handler mHandler;


 @Override
 public void run()
   {
   Looper.prepare();


   mHandler = new Handler();


   Looper.loop();
   }


 public void handleMessage(Message msg)
   {
   // Nachricht verarbeiten
   }
}

So geht es aber nicht.
Der Code lässt sich kompilieren.
An den Imports kann es also nicht liegen.
Nur : Wenn ich im UI-Thread etwas sende, kommt es im Handler des TCP-Threads nicht an.

Mir ist auch nicht klar, wie ich beim Erzeugen des Handlers mit new Handler die Verbindung mit meinem Handler herstellen muss.
Und genau das ist die eigentliche Frage

Hallo,
ich hätte da mal wieder ein Problem:

Ich versuche immer noch, Messages vom UI-Thread an einen anderen Thread zu senden.

Momentan habe ich den neuen Thread mit einem Looper und einem Handler versehen.
Dazu gibt es eine Menge Beispiele im Netz, aber:
1. Die wenigsten funktionieren wirklich (Absturz)
2. Der Handler wird immer "innerhalb des Threads erzeugt. Das finde ich erstens unschön und unübersichtlich, zweitens blickt man nicht mehr durch, wenn der Handler bzw. der Thread größer wird ( bei mir der Fall):

Also wollte ich den Handler als "separate Methode" definieren, also etwa so:

public class ClassComThread extends Thread 
  {
  public Handler mHandler;


  @Override
  public void run()
    {
    Looper.prepare();


    mHandler = new Handler(Looper.getMainLooper());
    
    Looper.loop();
    }


  public void handleMessage(Message msg)
    {
    Log.i("ComThread","Message from Application");
    }
}

Leider bekomme ich das so nicht kompiliert. Kann mir jemand sagen, wie es richtig gemacht wird????

Hallo,
bin auch Anfänger und habe wenig Ahnung.
Also nicht lachen, wenn's Blödsinn ist.

Aber hast du mal folgendes versucht:

if ( 0 == editTextName.getText().length() )
{
// Fehlermeldung
}

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:

Message msg = new Message();
msg.what = 1;
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.

public class NetworkThread extends HandlerThread
    {
    public Handler handlerNetwork;


    public NetworkThread(String name)
        {
        super(name);
        }


    @Override
    protected void onLooperPrepared()
        {
        handlerNetwork = new Handler(getLooper())
            {
        @Override
            public void handleMessage(Message msg)
                {
    // process incoming messages here
    // this will run in non-ui/background thread
                }
            };
         }
     }

public class MainActivity extends AppCompatActivity implements View.OnClickListener
    {
    Button        button;
    TextView      textview;


    HandlerThread threadNetwork;
    @Override
    protected void onCreate(Bundle savedInstanceState)
        {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        textview = findViewById(R.id.textview);


        button = findViewById(R.id.button);
        button.setOnClickListener(this);


        threadNetwork = new HandlerThread("Network Handler");
        threadNetwork.start();
        }


    @Override
    protected void onDestroy ()
        {
        super.onDestroy();
        threadNetwork.quit();
        }


    public void onClick(View v)
        {
        if ( v == button )
            {
            Message msg = new Message();
            msg.what = 1;
            threadNetwork.handlerNetwork.sendMessage(msg);
            }
        return;
        }
    }

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.

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:

public class MainActivity extends AppCompatActivity implements View.OnClickListener
    {
    private Thread networkThread = null;


    @Override
    protected void onCreate(Bundle savedInstanceState)
        {
        super.onCreate(savedInstanceState);


// Hier wird das Kommando übergeben
// Das möchte ich hier aber nicht, sondern später per Buttonklick
        networkThread = NetworkThread(mHandler, "GETSTATE");
        networkThread.start();
        }


    final Handler mHandler = new Handler()
        {
        public void handleMessage(Message msg)
            {
            Bundle bundle;
            if(msg.what==1)
                {
                bundle = msg.getData();


                Toast.makeText(getApplicationContext(),
                               String.valueOf(bundle.getInt("key1")),
                               Toast.LENGTH_LONG).show();
                }
            super.handleMessage(msg);
            }
        };


    public void onClick(View v)
        {
        if ( v == buttonSend )
            {
// hier sollen andere Kommandos gesendet werden
            }
        }
   }




// der Netztwerk.Thread:




    public class NetworkThread extends Thread
        {
        private static final String  SERVER_URL  = "Server";
        private static final int     SERVER_PORT = 8007;
        private Handler messageHandler;
        private String  messageSend;
        private String  messageReceive;
        public NetworkThread( Handler msgHandler, String msg )
            {
            this.messageHandler = msgHandler;
            this.messageSend    = msg;
            }
        // runnable
        public void run()
            {
        //create the bundle
            Bundle bundle = new Bundle(4);
            try
                {
                Socket socket = new Socket( SERVER_URL, SERVER_PORT );
                BufferedWriter out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                BufferedReader in  = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    // Write request to server
                out.write(this.messageSend);
                out.flush();
    // read request response from server
                this.messageReceive = in.readLine();
    // Close the output stream
                out.close();
                in.close();
    // Close the socket connection
                socket.close();
                }
            catch(Exception ex)
                {
    //:TODO Handle exceptions
                }
        //create a message from the message handler to send it back to the main UI
            Message msg = this.messageHandler.obtainMessage();
        //specify the type of message
            msg.what = 1;
        //attach the bundle to the message
            msg.setData(bundle);
    //send the message back to main UI thread
            this.messageHandler.sendMessage(msg);
            }
        }

Danke für die Antworten, hab's selber gefunden ( PEINLICH !!! ).
Beim Zusammenkopieren aus beiden Projekten habe ich versehentlich die Internet-Permission
in der falschen Manifest-Datei editiert.

Jetzt habe ich nur noch das Problem, das die Anwendung abstürzt, wenn ich die Location Updates
deaktiviere ( removeLocationUpdates(getPendingIntent() )

Zum Thema "selber programmieren lohnt nicht": Lohnt doch. Wenn man was lernen will !

Hallo,
ich bin noch ziemlich Android-unerfahren und grüble schon seit vielen Tagen über ein Problem.
Ich bin nicht sicher, ob das mit meinem Konzept überhaupt machbar ist, und benötige dringend eure Hilfe:

Ich möchte eine App schreiben, die zyklisch die Position des Handys per Fused Location Provider Client abfragt.
Wenn ich in die Nähe meiner Heimatkoordinaten komme, soll per TCP/IP ein Kommando an meinen Server zuhause gesendet werden.

Zunächst habe ich zum Test 2 getrennte Apps verwendet:
1. Senden von beliebigen TCP/IP Daten an meinen Server zuhause.
Die Main Activity erzeugt einfach einen Thread, übergibt im Konstruktor des Threads die Sendedaten, und der Thread beendet sich einfach wieder selbst,
wenn er das Kommando verschickt hat.
Das funktioniert soweit.

2. Zyklisches feststellen der Position.
Da das auch dann funktionieren soll, wenn die App im Hintergrund oder gar beendet worden ist, stoße ich in der App einfach zyklische Location Updates an,
und diese landen in der onReceive-Methode eines Broadcast-Receivers.
Das funktioniert auch (auch wenn die App beendet wurde ).

Jetzt mein Problem:
Wenn ich versuche, beide Apps zu einer zusammenzufügen, (den funktionierenden TCP/IP-Thread aus der ersten App
in die zweite einbauen) stürzt meine App ab.

Meine Frage:
Geht das überhaupt, aus der onReceive-Methode eines Broadcast-Receivers TCP-IP Daten übers Netzwerk zu schicken?
Wenn ja, muss man da was Spezielles beachten?

Ich habe mal den Code des TCT/IP Threads hinzugefügt.
Diesen Thread erzeuge und starte ich aus der onReceive-Methode des Broadcast Receivers
Kommentiert man alles aus, was direkt mit dem Netzwerk zu tun hat, läuft die App.
Sobald ich einen Socket erstelle beendet sich die App.

public class NetworkThread implements Runnable
    {
    public static final String SERVER_HOST = "Meinhost.de"; // server Hostname
    public static final int    SERVER_PORT = Meinport;      // server Port
    private Socket             clientSocket;
    private PrintWriter        out;
    private String             strToSend;


    public NetworkThread( String strParam )
        {
// sendestring im konstruktor merken
        strToSend = strParam;
        }




    @Override
    public void run()
        {
// dieser beep kommt noch
        ToneGenerator toneGen = new ToneGenerator(AudioManager.STREAM_ALARM, 100);
        toneGen.startTone(ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD, 400);


// UND DER FOLGENDE TEIL BEENDET DIE APP (crash)
        try
            {
            clientSocket = new Socket(SERVER_HOST, SERVER_PORT);
            out          = new PrintWriter(clientSocket.getOutputStream(),true);
            out.println(strToSend);


            clientSocket.close();
            }


        catch(IOException e)
            {
            System.out.println("Unknown host:");
            }
        }


    }

Das ist schon so gedacht.
Wenn ich eine Router Verbindung habe, dann ist es entweder der Heimnetz-Router oder der Router eines Bekannten oder so, der aber weit weg von meinem Zuhause ist.
Wenn ich also mit einem anderen Router verbunden bin, bin ich auf keinem Fall zuhause und dann werden die Buttons einfach ignoriert.
Wenn ich mit keinem Router verbunden bin, bin ich auf dem Weg von oder nach hause. Dann werden die Buttons auch einfach ignoriert.
Wenn ich mit meinem Router verbunden bin, bin ich zuhause und die Button-Befehle werden ausgeführt.

Warum soll ich dann die Verbindung trennen, wenn ich bei einem Freund bin und in dessen Netz ?????
Ich will ja gerade sein Netz verwenden, nur eben die Befehle zum öffnen des Carports nicht senden, und genau das mache ich.

Mein eigentliches Problem ist, das ich nicht genau weiß, was die einzelnen Funktionen genau bewirken und wann welche Funktion schon vom Handy selbst ausgeführt wird oder nicht.
Wenn zum Beispiel das Handy schon selbst beim Einschalten des Displays nach Netzwerken sucht, bringt es nichts, wenn ich das auch nochmal in meiner App mache.

Ich habe mir gedacht, das Handy verbindet sich ja automatisch mit meinem Netzwerk, ohne das ich irgendwas auswählen oder anstossen muss, Es dauert eben nur relativ lange.
Dann müsste es auch eine API Funktion geben, die einfach nach Netzwerken in der Nähe sucht und sich mit dem stärksten Router verbindet.
Und genau nach so einer Funktion suche ich.
Ich bin aber nicht sicher, ob es sinnvoll ist, diese Funktion aufzurufen ( wenn es sie gibt ), denn es könnte ja sein, das sie schon zu einem frühen Zeitpunkt ( z.B. Display einschalten ) "vom Display" aufgerufen wird und einfach nur so lange braucht.

WLAN aus und einschalten ginge schon, dann verbindet es sich auch sofort. Das ist aber nicht praktikabel.
Ich müsste erst das Display über den Power Button einschalten, dann in die WLAN-Einstellungen, WLAN aus, WLAN ein, dann meine App öffnen und dann den Button für das Tor drücken. Das dauert dann im Endeffekt genauso lange, als wenn ich gleich warten würde, nur das ich dann mehr zu klicken habe.
Mir wäre eine Lösung per Software lieber, so was ähnliches versuche ich ja schon, indem ich die Reconnect-Funktion des Wifi-Managers aufrufe.
Die Frage ist nur, ob die auch das macht, was ich will, nämlich nach Routern suchen und sich verbinden, und wenn ja, ob es Sinn machen würde, diese Funktion schon bei Aktivierung des Displays aufzurufen, damit das Handy schon mal nach Routern scannt, während ich die App starte.
Ich bin nicht sicher, ob Reconnect die richtige Funktion ist, weil sie vermutlich die Verbindung erstmal trennen wird, wenn sie schon besteht.

VPN würde gehen, das habe ich aber bisher vermieden, weil man dann auch aus der Ferne versehentlich das Tor öffnen kann und man sieht nicht, wenn es sich öffnet.

Das Problem ist, das sobald ich in Reichweite komme, der automatische Verbindungsaufbau zu lange dauert.
Ich stehe eine Minute vor der Garage und warte, bis mein Handy die Verbindung aufgebaut hat.
Erst dann kann ich etwas senden.
Ich vermute, das das Handy zyklisch ( zum Beispiel jede Minute) prüft, ob Router in Reichweite sind.
Ich möchte mein Handy dazu bringen, jetzt sofort die Verbindung herzustellen.