Wie kann eine Schnittstelle für verschiedene Hintergrund-Android-Aufgaben verwendet werden?

Nun, ich habe eine Aktivitätsklasse mit zwei Hintergrundaufgaben (Async-Task), die in zwei separaten Klassen wie definiert wurden

public class GettingBeaconsList extends AsyncTask<String, String, String> public class GettingAirports extends AsyncTask<String, String, String> 

Die in MainClass initialisiert und ausgeführt werden

  • Deinstallieren Sie Android Wear App aus Real Device
  • Nächster Button in der Tastatur wird nicht angezeigt
  • Erstellen eines Spray-Effekts auf Berührung in Android
  • Wie man ein Element in einem Android Spinner versteckt
  • Android SMS-Empfänger funktioniert nicht
  • Gibt es eine Google Transit API?
  •  public class MainClass extends Activity implements DelegateTaskCompleted { int ServiceBoolean = 0; public OnClickListener LoadingBeaconList = new OnClickListener() { public void onClick(View v) { ServiceBoolean =1; new GettingBeaconsList (context,MainClass.this).execute(); } } public OnClickListener LoadingAirportList= new OnClickListener() { public void onClick(View v) { ServiceBoolean =2; new GettingAirports(context,MainClass.this).execute(); } } @Override public void JsonArrayLoaded(JSONArray result) { // bla bla or whatever here i write, does not matter if(ServiceBoolean == 1) { // Load activity 5 } else if( ServiceBoolean == 2) { // Load activity 6 } else if( ServiceBoolean==3 ) { // display Toast or Alert Box or load Activity number 8 } } } 

    Jetzt in oben Code MainClass.this ist als Interface Reference in AsynTask SubClasses wie diese gespeichert

     private Context context = null; private DelegateTaskCompleted delegate = null; public GettingBeaconsList (Context context,DelegateTaskCompleted delegate) { this.context = context; this.delegate = delegate; } // And constructor of second AsynTask is same as of First AsynTask Class private Context context = null; private DelegateTaskCompleted delegate = null; public GettingAirports (Context context,DelegateTaskCompleted delegate) { this.context = context; this.delegate = delegate; } 

    OnPostExecute jeder AsynTask-Klasse oder Unterklasse wird JSONArray zurückgegeben oder an die aufrufende Klasse zurückgesendet, die unten gezeigt wird. In diesem Fall ist die Aufrufklasse MainKlass, aber es gibt andere Aktivitätsklassen, die dieselben AsynTask-Klassen ( GettingBeaconsList und GettingAirports ) verwenden,

     protected void onPostExecute(String file_url) { pDialog.dismiss(); delegate.JsonArrayLoaded(gotNearestbeacons); } 

    Jetzt habe ich eine Methode (JsonArrayLoaded) in MainClass , um zwei Antworten aus zwei verschiedenen Hintergrundaufgaben oder -diensten zu bekämpfen. Ich benutze die Bedingung, um herauszufinden, welcher Dienst / Klasse oder AsynTask ausgeführt wird.

    Aber ich frage nach dem besten Weg, um ein solches Szenario anzupacken, als ob wir in Zukunft 5 oder mehr Hintergrunddienste haben und sie auch nur ein JSON Array zurückgeben, also muss ich für jeden Service separate Schnittstellen machen?

    Was sollte objektorientierter Weg zu diesem Fall sein?

  • Robolectric und Google Analytics Fehler bei Tests
  • Wie gefüllte Dreieck auf Android Canvas zu zeichnen
  • Cordova Konnte nicht genügend Platz für 2097152KB Objekthaufen reservieren
  • Verwenden von Android SlidingPaneLayout mit ViewPager
  • Android gemeinsame Elementübergang: Heldenansicht wird vor anderen gezeichnet
  • Gradle Error - Kann IncrementalTask.taskAction () auf Task 'nicht aufrufen': project: mergeDebugResources '
  • 6 Solutions collect form web for “Wie kann eine Schnittstelle für verschiedene Hintergrund-Android-Aufgaben verwendet werden?”

    Die einfachste Lösung, die ich mir vorstellen kann, ist, deine DelegateTaskCompleted Schnittstelle zu ändern, so wie es so aussieht:

     public interface DelegateTaskCompleted{ public void JsonArrayLoaded(AsyncTask<String, String, String> task, JSONArray result); } 

    Dann schickt sich dein onPostExecute folgt zurück:

     protected void onPostExecute(String file_url) { pDialog.dismiss(); delegate.JsonArrayLoaded(this, gotNearestbeacons); } 

    Schließlich können Sie in Ihrer MainClass eine bedingte Überprüfung auf der Art der AsyncTask :

      @Override public void JsonArrayLoaded(AsyncTask<String, String, String> task, JSONArray result) { if(task instanceof GettingBeaconsList) { // do stuff related to the beacon list } else if(task instanceof GettingAirports) { // do airport list stuff } } 

    Auf diese Weise können Sie leicht identifizieren die AsyncTask , die durch die Antwort sendet, ohne zu verfolgen, was es ist, wenn man länger dauert als die anderen etc.


    Alternativ haben Sie eine andere Klasse, die AsyncTask aber fügt eine abstrakte Variable zur Identifikation hinzu.

     public class TrackableAsyncTask extends AsyncTask<String, String, String>{ public abstract int getId(); public static final int ID_AIRPORT = 1; public static final int ID_BEACONS = 2; ... etc } 

    Dann haben Sie Ihren Flughafen und Beacon AsycTasks verlängern stattdessen. Dies erfordert, dass sie die getId Methode implementieren.

     public class GettingAirports extends AsyncTask<String, String, String> { public int getId(){ return ID_AIRPORT; } } 

    Und dann statt einer bedingten, if (task instanceof GettingAirports) können Sie eine switch Anweisung wie unten:

     switch(task.getId()){ case TrackableAsyncTask.ID_AIRPORT: // run airport code } 

    Hoffe das hilft.

    Hallo dieser Code wird dir helfen

    Dies ist die Schnittstelle zum Rückruf

     public interface CallbackReceiver { public void receiveData(Object result); } 

    Verwenden Sie Asynctask-Klasse als Abstract-Klasse

     public abstract class JsonDataCallback extends AsyncTask<String, String, String> implements CallbackReceiver { private ProgressDialog mProgressDialog; Handler handler; Runnable callback; Activity activity; public JsonDataCallback(Activity activity) { this.activity=activity; mProgressDialog = new ProgressDialog(activity); mProgressDialog.setMessage("Loading Please Wait."); mProgressDialog.setIndeterminate(false); mProgressDialog.setMax(100); mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL); mProgressDialog.setCancelable(true); } public abstract void receiveData(Object object); @Override protected void onPreExecute() { mProgressDialog =ProgressDialog.show(activity, "", "Please Wait",true,false); super.onPreExecute(); } @Override protected String doInBackground(String... aurl) { String results=""; // do stuff return results; } @Override protected void onPostExecute(String jsonData) { if (mProgressDialog != null || mProgressDialog.isShowing()){ mProgressDialog.dismiss(); } if(jsonData!=null) { receiveData(jsonData); } } } 

    Und in deinem Code nimm es so

     String url = ipaddress + "/GrantAdvanceList; JsonDataCallback callbackservice = new JsonDataCallback(yourActivity.this) { @Override public void receiveData(Object object) { jsonRecordsData = (String)object; //do stuff with call back data } }; callbackservice.execute(url, null, null); 

    Du kannst den Code auf diese Weise wiederverwenden, ich hoffe das wird dir helfen. Danke im Voraus.

    Sie können auch Handler betrachten, um dies zu erreichen. Erstellen Sie Handler in Activity, übergeben Sie dieses Handler-Objekt an jede AsyncTask. In onPost call handler.sendEmptyMessage (CONSTANT_INT); In Handler handleMessage check msg.what in if oder switch Auf diese Weise wird nur ein Objekt des Handlers erstellt und in mehreren Anrufen für async aus einer Aktivität verwendet

    Wenn ich dein Problem richtig verstehe, hast du AsyncTask einige Male verlängert. Das Ziel jeder dieser Unterklassen ist es, ein JSONArray an eine Aktivität weiterzugeben, die DelegateTaskCompleted implementiert, wo du etwas dazu machen wirst. Die Herausforderung ist, dass das "etwas", das Sie mit diesem JSONArray machen wollen, unterschiedlich ist, je nachdem, welche AsyncTask es erzeugt hat.

    Abgesehen von diesen Annahmen, gibt es viele verschiedene Möglichkeiten, wie Sie unterscheiden können, welche AsyncTask der JSONArray kam aus:

    1. Erstellen Sie eine statische Variable, z. B. eine int, in Ihrer DelegateTaskCompleted-Klassendatei für jede Art von JSONArray, die sie behandeln muss. Fügen Sie einen Parameter zu JsonArrayLoaded des gleichen Typs dieser Variablen hinzu. Verwenden Sie dann Ihre if-else-Anweisungen oder eine switch-Anweisung, die diese Variable auf den Satz überprüft und die Aktionen für Ihr JSONArray ausführen.
    2. Wenn Sie Zugang zu dem haben, was das JSONArray erzeugt, machen Sie den 0-Index des Array Informationen, wie man es analysiert. (Vielleicht etwas, das man mit if-else oder einem Schalter vergleichen kann)
    3. Wie Sie vorgeschlagen haben, erstellen Sie eine separate Schnittstelle für jede AsyncTask, oder alternativ eine einzige Schnittstelle mit mehreren Methoden.

    Nur Option 3 ist eine objektorientierte Lösung, und wie in den Kommentaren darauf hingewiesen wurde, ist es nicht so groß, dass es sich um Skalierbarkeit handelt. Das ist keineswegs eine komplette Liste, nur einige meiner Ideen.

    Ich frage mich aber, ob es sich lohnt, Schnittstellen überhaupt zu benutzen, oder zumindest in der vorgestellten Weise. Da Sie bereits verschiedene Unterklassen von AsyncTask haben, um die Erstellung der JSONArrays zu behandeln, warum nicht alles tun, was Sie tun, um sie innerhalb der doInBackground() -Methode aus dem Haupt-Thread zu machen oder zumindest diese Logik irgendwo in diesen Klassen zu platzieren, Und geben Sie einfach die Ergebnisse (oder möglicherweise stopfen sie in einer Datenbank und bekommen sie, wenn nötig). Ich denke, dass es einen besseren Weg, um Ihre AsyncTask Vererbung, die Interfaces alle zusammen vermeidet, oder zumindest verwendet sie anders, wie eine einzelne Schnittstelle von allen Ihre AsyncTasks implementiert werden.

    Es wäre sehr hilfreich, wenn Sie Ihre Frage klären und die Art der Operationen erklären können, die sowohl die AsyncTasks als auch Ihre JSONArrayLoaded Methode durchführen, und vielleicht Ihre Argumentation für die Verwendung von Interfaces, wie Sie sind. Es ist schwer, eine konkrete OO-Antwort oder Ratschläge zu OO Best Practices mit so wenig Informationen zu geben, was Ihr Code tatsächlich tut und hofft, zu erreichen.

    Füge eine Member-Variable zu beiden AsyncTask-Klassen hinzu, dh,

     public class GettingBeaconsList extends AsyncTask<String, String, String> public class GettingAirports extends AsyncTask<String, String, String> 

    wie

     private int flag; 

    Und schreibe Setter für das als

     public void setFlag(int flag) { this.flag = flag; } 

    In MainClass:

     GettingBeaconsList beaconsList = new GettingBeaconsList(context,MainClass.this); beaconsList.setFlag(100); //Declare this flag in integer constant. beaconsList.execute(); GettingAirports airports = new GettingAirports(context, MainClass.this); airports.setFlag(200); airports.execute(); 

    In beiden die AsyncTask-Klassen passieren Flag mit der Delegate-Methode: –

     protected void onPostExecute(String file_url) { pDialog.dismiss(); delegate.JsonArrayLoaded(gotNearestbeacons, flag); //Change the signature of this method } 

    Wieder in MainClass, um Antwort zu behandeln: –

     @Override public void JsonArrayLoaded(JSONArray result, int flag) { // Here check which Background task has been completed if(flag == 100) // GettingBeaconsList is executed if(flag == 200) // GettingAirport is executed. // bla bla or whatever here i write, does not matter if(ServiceBoolean == 1) { // Load activity 5 } else if( ServiceBoolean == 2) { // Load activity 6 } else if( ServiceBoolean==3 ) { // display Toast or Alert Box or load Activity number 8 } } 

    Ich schlage vor, Sie verwenden einfach n innere Klassen für Ihre Aktivität, die DelegateTaskCompleted implementieren. Es ist einfach, effizient, klar und leicht verständlich (denken Sie die Instandhaltung) – und Sie übergeben den Delegierten bereits, wenn Sie Ihre AsyncTasks konstruieren, also könnte es sein, dass Sie bereits diesen Ansatz in Ihrem Kopf haben?

     public class MainClass extends Activity { // probabnly not static ;) private final class BeaconsDelegate implements DelegateTaskCompleted ... private final class AirportsDelegate implements DelegateTaskCompleted ... } 
    Das Android ist ein Google Android Fan-Website, Alles ├╝ber Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.