[JAVA] Programmation à partir de 51 ans Remarque Android Rappel de communication asynchrone Traitement après la fin d'AsyncTask Généralisation et standardisation supplémentaires

Rappel de communication asynchrone

Il est utilisé lorsque vous souhaitez faire quelque chose une fois le traitement d'AsyncTask terminé.

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){
            //Décrivez le processus que vous souhaitez effectuer après la fin d'AsyncTask
            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 qui généralise / standardise AnsycTask

Il serait très difficile d'écrire du code AsyncTask à chaque fois qu'une communication asynchrone est effectuée.

De l'appelant

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

Je veux pouvoir l'appeler de n'importe où.

Avec la méthode "Call Back for asynchronous communication" ci-dessus, dans le constructeur d'AsyncTask J'ai reçu un argument avec \ <MainActivity.AsyncCallBack asyncCallBack>, mais je ne peux pas généraliser avec cela. Donc, en utilisant Interface pour pouvoir déclarer le type AsyncCallBack Généraliser pour que les arguments puissent être reçus avec \ .

J'utiliserai également HashMap pour rendre les paramètres portables.
Puis l'interface!

CallBack.interface

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

Vous pouvez maintenant utiliser des arguments de type CallBack!

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{ //Prolonger le rappel

   @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{ //Prolonger le rappel

   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");
   }
}