[JAVA] Programmierung ab 51 Jahren Hinweis Android Asynchroner Kommunikationsrückruf Verarbeitung nach Beendigung von AsyncTask Weitere Verallgemeinerung und Standardisierung

Rückruf für asynchrone Kommunikation

Es wird verwendet, wenn Sie nach Abschluss der Verarbeitung von AsyncTask etwas tun möchten.

MainActivity

public class MainActivity extends AppCompatActivity{

    TextView tv;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = findViewById(R.id.tv);

        AsyncCallBack asyncCallBack = new AsyncCallBack();
        MyAsyncTask myAsyncTask = new MyAsyncTask(asyncCallBack);
        myAsyncTask.execute();
    }

    public class AsyncCallBack{
        public void callBack(String s){
            //Beschreiben Sie den Vorgang, den Sie nach dem Ende der AsyncTask ausführen möchten
            tv.setText(s);
        }
    }
}

MyAsyncTask

public class MyAsyncTask extends AsyncTask<Void,Void,String> {

    private MainActivity.AsyncCallBack callBack = null;

    public MyAsyncTask(MainActivity.AsyncCallBack callBack){
        this.callBack = callBack;
    }

    @Override
    protected String doInBackground(Void... aVoid) {
        return "success";
    }

    @Override
    protected void onPostExecute(String s) {
        super.onPostExecute(s);
        callBack.callBack(s);
    }
}

SampleCode, der AnsycTask verallgemeinert / standardisiert

Es wäre sehr schwierig, jedes Mal, wenn eine asynchrone Kommunikation durchgeführt wird, AsyncTask-Code zu schreiben.

Vom Anrufer

AsyncCallBack callBack  = new AsyncCallBack();
AsyncTask     asyncTask = new AsyncTask(callback);

Ich möchte es von überall aus anrufen können.

Mit der obigen Methode "Rückruf für asynchrone Kommunikation" im Konstruktor von AsyncTask Ich habe ein Argument mit \ <MainActivity.AsyncCallBack asyncCallBack> erhalten, kann es aber nicht verallgemeinern. Verwenden Sie also die Schnittstelle, um den AsyncCallBack-Typ deklarieren zu können Verallgemeinern Sie, damit Argumente mit \ empfangen werden können.

Ich werde auch HashMap verwenden, um die Parameter portabel zu machen.
Dann die Schnittstelle!

CallBack.interface

interface CallBack{
   public void Receiver(Map<String,String> map);
}

Jetzt können Sie Argumente vom Typ CallBack verwenden!

AsyncTaskSample.java

public class AsyncTaskSample extends AsyncTask<Map<String,String>,Void,Map<String,String>{

   AsyncTaskCallBack callback;

   public AsyncTaskSample(AsyncTaskCallBack callBack){
      this.callback = callBack;
   }
   
   @Override 
   protected Map<String,String> doInBackground(Map<String,String>... map){
      return map[0];
   }

   @Override 
   protected void onPostExecute(Map<String,String> map){
      super.onPostExecute(map);
      callback.Receiver(map);
   }
}

MainActivity.java

public class MainActivity extends AppCompatActivity implements CallBack{ //Erweitern Sie CallBack

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

      AsyncTaskSample  async = new AsyncTaskSample(this);
      Map<String,String> map = new HashMap<String,String>();
         map.put("key","MainActivity");
      async.execute(map);

      new SampleClass.SampleClass();
   }

   @Override 
   public void Receiver(Map<String,String> map) {
      Log.d("=====>",map.get("key");
   }

SampleClass.java

public class SampleClass implemants CallBack{ //Erweitern Sie CallBack

   void SampleClass(){
      AsyncTaskSample  async = new AsyncTaskSample(this);
      Map<String,String> map = new HashMap<String,String>();
         map.put("key","SampleClass");
      async.execute(map); 
   }
   
   @Override 
   public void Receiver(Map<String,String> map){
      Log.d("=====>",map.get("key");
   }
}