Android AsyncTask ist deprecated

[topi]

Hallo liebe Gemeinde,

Google sagt zu dieser AsyncTask Klasse
„This class was deprecated in API level 30. Use the standard java.util.concurrent or Kotlin concurrency utilities instead.“

Jetzt hab ich mich schon ein bisschen mit der concurrent-Klasse befasst, ist aber nicht wirklich was bei rausgekommen. ☹️
Hoffe jemand von euch kennt sich da näher aus, ich bräuchte da ein paar "Anstubser".

Danke Topi

 

[mrBrown]

Jetzt hab ich mich schon ein bisschen mit der concurrent-Klasse befasst

Welche meinst du mit "concurrent-Klasse"? java.util.concurrent enthält ja zig Klassen. Oder beziehst du dich auf irgendwas aus Kotlin?

 

[topi]

so in etwa:
Wir müssen einen Aufrufer erstellen, um die Executor-Instanz zu erstellen:

public class Invoker implements Executor {
    @Override
    public void execute(Runnable r) {
        r.run();
    }
}

Jetzt können wir diesen Aufrufer verwenden, um die Aufgabe auszuführen.

public void execute() {
    Executor executor = new Invoker();
    executor.execute( () -> {
       //task to be performed
    });
}

bin ich auf dem richtigen Weg?

 

[kneitzel]

Ja und nein. Du kannst diesen Weg gehen, aber dann musst Du den Executor erweitern, damit ein neuer Thread erstellt wird. Du hast da erst einmal absolut nichts, das asynchron, also in einem anderen Thread läuft.
Schau Dir dazu https://developer.android.com/reference/java/util/concurrent/Executor an! Und wirf einen Blick auf die Subklassen, die angeboten werden. Da ist ja vielleicht eine dabei, die Du nutzen möchtest

Eine mögliche Alternative könnte aber auch eine Library wie RxJava sein. Aber da folgst Du dann halt teilweise generell einem anderen Pattern... Das aber nur kurz am Rande.

 

[mrBrown]

Sinnvoll wäre auch ein Blick in die Executors-Klasse, die als Factory für Executor fungiert: https://developer.android.com/reference/java/util/concurrent/Executors

 

[topi]

ich habe durch die viele Recherche und Leserei einen Knoten im Kopf! 😫

das Chema in der Klasse android.os.AsyncTask war so:
Im UI-Thread, einer Activity, wird zunächst ein Objekt vom Typ AsyncTask deklariert und mittels Konstruktoraufruf initialisiert.

WeatherRequestTask task = new WeatherRequestTask();

class WeatherRequestTask extends AsyncTask<Void,Void,IWeatherAPI> {
  @Override
  protected IWeatherAPI doInBackground(Void... voids) {
  // Worker-Thread Methode
  IWeatherAPI api = null;
  try {
    // hier der Thread, der asynchron laufen muss!
  } catch (Exception ex) {
    Log.e("!!!"+getClass().getSimpleName(), ex.getCause().toString());
  } // ende try
  return api;
  } // ende doInBackground()
 
  @Override
  // Callback-Methode
  protected void onPostExecute(IWeatherAPI api) {
    if (api == null) {
      Log.e(getClass().getSimpleName(), "Rückgabe von doInBackground ist null");
      return;
    } // ende if
    try {
      // Result der Worker-Thread Methode auswerten
    } catch (Exception ex) {
      Log.e("!!!"+getClass().getSimpleName(), ex.toString());
    } // ende try
  } // ende onPostExecute()
} // ende Klasse WeatherRequestTask

task.execute();

startet den Worker-Thread und führt schließlich zum Aufruf der AsyncTask-Methode doInBackground.
doInBackground gibt sodann das Ergebbis zurück, dass im UI-Thread von der Methode onPostExecute empfangen und verarbeitet wird.

So ein ähnliches Chema für das Vorgehen bräuchte ich für die Klasse java.util.concurrent.

Danke topi !