AsyncTask Android-Beispiel

Meine vollständige Antwort ist hier , aber hier ist ein erläuterndes Bild, um die anderen Antworten auf dieser Seite zu ergänzen. Für mich war es am Anfang am verwirrendsten, zu wissen, wo alle Variablen hingingen.

Ich bin sicher, dass es ordnungsgemäß ausgeführt wird, aber Sie versuchen, die Benutzeroberflächenelemente im Hintergrund-Thread zu ändern.

Überarbeiten Sie Ihren Anruf und Ihre AsyncTask wie folgt:

Klasse aufrufen

Hinweis: Ich persönlich empfehle die Verwendung von onPostExecute() überall dort, wo Sie Ihren AsyncTask-Thread ausführen, und nicht in der Klasse, die AsyncTask selbst erweitert. Ich denke, es macht den Code leichter zu lesen, besonders wenn Sie die AsyncTask an mehreren Stellen benötigen, um die Ergebnisse etwas anders zu behandeln.

new LongThread()
{
    @Override public void onPostExecute(String result)
    {
        TextView txt = (TextView) findViewById(R.id.output);
        txt.setText(result);
    }
}.execute("");

LongThread-Klasse (erweitert AsyncTask):

@Override
protected String doInBackground(String... params) {
    for(int i = 0; i < 5; i++) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    return "Executed";
}      

Konzept und Code hier

Ich habe ein einfaches Beispiel für die Verwendung von AsyncTask von Android erstellt. Es beginnt mit onPreExecute(), doInBackground(), publishProgress() und schließlich onProgressUpdate().

In diesem Fall arbeitet doInBackground () als Hintergrund-Thread, während andere im UI-Thread arbeiten. Sie können in doInBackground () nicht auf ein Oberflächenelement zugreifen. Die Reihenfolge ist dieselbe wie ich erwähnt habe.

Wenn Sie jedoch ein Widget von doInBackground aus aktualisieren müssen, können Sie publishProgress von doInBackground aus aufrufen, wodurch onProgressUpdate aufgerufen wird, um Ihr UI-Widget zu aktualisieren.

class TestAsync extends AsyncTask<Void, Integer, String>
{
    String TAG = getClass().getSimpleName();

    protected void onPreExecute (){
        super.onPreExecute();
        Log.d(TAG + " PreExceute","On pre Exceute......");
    }

    protected String doInBackground(Void...arg0) {
        Log.d(TAG + " DoINBackGround","On doInBackground...");

        for(int i=0; i<10; i++){
            Integer in = new Integer(i);
            publishProgress(i);
        }
        return "You are at PostExecute";
    }

    protected void onProgressUpdate(Integer...a){
        super.onProgressUpdate(a);
        Log.d(TAG + " onProgressUpdate", "You are in progress update ... " + a[0]);
    }

    protected void onPostExecute(String result) {
        super.onPostExecute(result);
        Log.d(TAG + " onPostExecute", "" + result);
    }
}

Nenne es in deiner Aktivität so:

new TestAsync().execute();

Entwicklerreferenz hier

Verschieben Sie diese beiden Zeilen:

TextView txt = (TextView) findViewById(R.id.output);
txt.setText("Executed");

aus der AsyncTask-Methode doInBackground und fügen Sie sie in die Methode onPostExecute ein. Ihre AsyncTask sollte ungefähr so ​​aussehen:

private class LongOperation extends AsyncTask<String, Void, String> {

    @Override
    protected String doInBackground(String... params) {
        try {
            Thread.sleep(5000); // no need for a loop
        } catch (InterruptedException e) {
            Log.e("LongOperation", "Interrupted", e);
            return "Interrupted";
        }
        return "Executed";
    }      

    @Override
    protected void onPostExecute(String result) {               
        TextView txt = (TextView) findViewById(R.id.output);
        txt.setText(result);
    }
}

Hintergrund/Theorie

AsyncTask ermöglicht das Ausführen einer Aufgabe in einem Hintergrundthread, während die Ergebnisse im UI-Thread veröffentlicht werden.

Der Benutzer sollte immer in der Lage sein, mit der App zu interagieren, damit wichtigm das Blockieren des Hauptthreads (UI) zu vermeiden mit Aufgaben wie dem Herunterladen von Inhalten aus dem Web.

Deshalb verwenden wir ein AsyncTask.

Es bietet eine unkomplizierte Oberfläche, indem die Nachrichtenwarteschlange und den Handler des UI-Threads umbrochen werden, mit denen Sie ausführbare Objekte und Nachrichten von anderen Threads senden und verarbeiten können.

Implementierung

AsyncTask ist eine generische Klasse. (Es braucht parametrisierte Typen in seinem Konstruktor.)

Es verwendet diese drei generische Typen:

Params - Der Typ der Parameter, die bei der Ausführung an die Task gesendet werden.

Progress - Der Typ der während der Hintergrundberechnung veröffentlichten Fortschrittseinheiten.

Result - Der Typ des Ergebnisses der Hintergrundberechnung.

Nicht alle Typen werden immer von einer asynchronen Task verwendet. Um einen Typ als unbenutzt zu markieren, verwenden Sie einfach den Typ Void:

private class MyTask extends AsyncTask<Void, Void, Void> { ... }

Diese drei Parameter entsprechen drei Hauptfunktionen Sie können AsyncTask überschreiben:

• doInBackground(Params...)
• onProgressUpdate(Progress...)
• onPostExecute(Result)

m AsyncTask auszuführen

• Rufen Sie execute() mit Parametern auf, die an die Hintergrundaufgabe gesendet werden sollen.

Was passiert

1. On Haupt-/UI-Thread, onPreExecute() wird aufgerufen.

   • Um etwas in diesem Thread zu initialisieren. (ZB einen Fortschrittsbalken auf der Benutzeroberfläche anzeigen.)

2. Auf einem Hintergrund-Thread wird doInBackground(Params...) aufgerufen.

   • (Params wurden über execute übergeben.)
   • Wo die langwierige Aufgabe stattfinden soll.

   • Muss mindestens doInBackground() überschreiben, um AsyncTask verwenden zu können.

   • Rufen Sie publishProgress(Progress...) auf, um die Benutzeroberfläche mit einer Fortschrittsanzeige (z. B. UI-Animation oder gedruckter Protokolltext) zu aktualisieren, während die Hintergrundberechnung noch ausgeführt wird.

     • Bewirkt, dass onProgressUpdate() aufgerufen wird.

3. Am Hintergrund-Thread wird ein Ergebnis von doInBackground() zurückgegeben.

   • (Dies löst den nächsten Schritt aus.)

4. On main/UI thread, onPostExecute() wird mit dem zurückgegebenen Ergebnis aufgerufen.

Beispiele

In beiden Beispielen ist die "Blockierungsaufgabe" ein Download aus dem Internet.

• Beispiel A lädt ein Bild herunter und zeigt es in einer ImageView an, während
• Beispiel B downloads einige Dateien.

Beispiel A

Die Methode doInBackground() lädt das Bild herunter und speichert es in einem Objekt vom Typ BitMap. Die onPostExecute() -Methode nimmt die Bitmap und platziert sie in der ImageView.

class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
    ImageView bitImage;

    public DownloadImageTask(ImageView bitImage) {
        this.bitImage = bitImage;
    }

    protected Bitmap doInBackground(String... urls) {
        String urldisplay = urls[0];
        Bitmap mBmp = null;
        try {
            InputStream in = new Java.net.URL(urldisplay).openStream();
            mBmp = BitmapFactory.decodeStream(in);
        } catch (Exception e) {
            Log.e("Error", e.getMessage());
            e.printStackTrace();
        }
        return mBmp;
    }

    protected void onPostExecute(Bitmap result) {
        bitImage.setImageBitmap(result);
    }
}

Beispiel B

 private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
     protected Long doInBackground(URL... urls) {
         int count = urls.length;
         long totalSize = 0;
         for (int i = 0; i < count; i++) {
             totalSize += Downloader.downloadFile(urls[i]);
             publishProgress((int) ((i / (float) count) * 100));
             // Escape early if cancel() is called
             if (isCancelled()) break;
         }
         return totalSize;
     }

     protected void onProgressUpdate(Integer... progress) {
         setProgressPercent(progress[0]);
     }

     protected void onPostExecute(Long result) {
         showDialog("Downloaded " + result + " bytes");
     }
 }

Ausführung von Beispiel B

new DownloadFilesTask().execute(url1, url2, url3);

Wenn eine asynchrone Task ausgeführt wird, durchläuft die Task 4 Schritte:

1. onPreExecute ()
2. doInBackground (Params ...)
3. onProgressUpdate (Fortschritt ...)
4. onPostExecute (Ergebnis)

Unten ist ein Demo-Beispiel

private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
     protected Long doInBackground(URL... urls) {
         int count = urls.length;
         long totalSize = 0;
         for (int i = 0; i < count; i++) {
             totalSize += Downloader.downloadFile(urls[i]);
             publishProgress((int) ((i / (float) count) * 100));
             // Escape early if cancel() is called
             if (isCancelled()) break;
         }
         return totalSize;
     }

     protected void onProgressUpdate(Integer... progress) {
         setProgressPercent(progress[0]);
     }

     protected void onPostExecute(Long result) {
         showDialog("Downloaded " + result + " bytes");
     }
 }

und wenn Sie einmal erstellt haben, wird eine Aufgabe sehr einfach ausgeführt:

 new DownloadFilesTask().execute(url1, url2, url3);

Ich hoffe, dies wird dir helfen...

Das kürzeste Beispiel, um etwas asynchron zu machen:

class MyAsyncTask extends Android.os.AsyncTask {
    @Override
    protected Object doInBackground(Object[] objects) {
        //do something asynchronously
        return null;
    }
}

Um es auszuführen:

(new MyAsyncTask()).execute();

Wenn Sie sich im Arbeitsthread befinden, können Sie die Benutzeroberflächenelemente auf Android nicht direkt bearbeiten.

Wenn Sie AsyncTask verwenden, verstehen Sie die Callback-Methoden.

Zum Beispiel:

public class MyAyncTask extends AsyncTask<Void, Void, Void>{

    @Override
    protected void onPreExecute() {
        // Here you can show progress bar or something on the similar lines.
        // Since you are in a UI thread here.
        super.onPreExecute();
    }

    @Override
    protected void onPostExecute(Void aVoid) {
        super.onPostExecute(aVoid);
        // After completing execution of given task, control will return here.
        // Hence if you want to populate UI elements with fetched data, do it here.
    }

    @Override
    protected void onProgressUpdate(Void... values) {
        super.onProgressUpdate(values);
        // You can track you progress update here
    }

    @Override
    protected Void doInBackground(Void... params) {
        // Here you are in the worker thread and you are not allowed to access UI thread from here.
        // Here you can perform network operations or any heavy operations you want.
        return null;
    }
}

FYI: Um von einem Arbeitsthread auf den UI-Thread zuzugreifen, verwenden Sie entweder die runOnUiThread () - Methode oder die post-Methode für Ihre Ansicht.

Zum Beispiel:

runOnUiThread(new Runnable() {
    textView.setText("something.");
});

or
    yourview.post(new Runnable() {
    yourview.setText("something");
});

Dies hilft Ihnen, die Dinge besser zu kennen. In Ihrem Fall müssen Sie daher Ihre Textansicht in der onPostExecute () -Methode festlegen.

Wie werden die in AsyncTask verwendeten Parameter gespeichert?

Nicht 

Wenn Sie mit AsyncTask noch nicht vertraut sind, werden Sie beim Schreiben einer AsyncTask häufig verwirrt. Haupttäter sind die in der AsyncTask verwendeten Parameter, dh AsyncTask<A,B,C>. Basierend auf der A unterscheidet sich die Signatur der Methoden B, C (Argumente), was die Sache noch verwirrender macht. 

Halte es einfach!

Der Schlüssel ist Nicht merken. Wenn Sie sich vorstellen können, was Ihre Aufgabe wirklich tun muss, dann wäre das Schreiben der AsyncTask mit der richtigen Signatur beim ersten Versuch ein Kinderspiel. Finden Sie einfach heraus, was Ihre Eingabe, Ihr Fortschritt und Ihre Ausgabe sind, und Sie werden gut sein. 

Was ist also eine AsyncTask?

AsyncTask sind Hintergrundaufgaben, die im Hintergrundthread ausgeführt werden. Es nimmt einen Input, führt Progress aus und gibt Output.

dhAsyncTask<Input,Progress,Output>.

Zum Beispiel: 

Wie ist die Beziehung zu Methoden?

Zwischen AsyncTask und doInBackground()

doInBackground() und onPostExecute(),onProgressUpdate () `sind auch verbunden

Wie schreibe ich das in den Code?

DownloadTask extends AsyncTask<String,Integer,String>{

  // Always same signature
  @Override
  public void onPreExecute()
  {}

  @Override
  public String doInbackGround(String... params)
  {
           // Download code
           int downloadPerc = // calculate that
           publish(downloadPerc);

           return "Download Success";
  }

  @Override
  public void onPostExecute(String result)
  {
      super.onPostExecute(result);
  }

  @Override
  public void onProgressUpdate(Integer... params)
  {
         // show in spinner, access UI elements
  }

}

Wie werden Sie diese Aufgabe ausführen?

new DownLoadTask().execute("Paradise.mp3");

Ich würde empfehlen, Ihr Leben zu erleichtern, indem Sie diese Bibliothek für Hintergrundarbeiten verwenden https://github.com/Arasthel/AsyncJobLibrary

es ist so einfach ..

AsyncJob.doInBackground(new AsyncJob.OnBackgroundJob() {

    @Override
    public void doOnBackground() {
        startRecording();
    }
});

Detaillierte Anleitung zur AsyncTask-Erklärung

Was ist AsyncTask?

AsyncTask ist eine Android-Klasse, mit der wir komplexe Vorgänge wie z

1. Netzwerkbetrieb.
2. Datenbankoperationen.
3. Speichern und Lesen von Daten aus großen Textdateien.

Es lindert die Spannung der Entwickler

1. Thread-Erstellung und Beendigung.
2. Synchronisation und Verwaltung von UI-Threads.

Wenn du

1. ich weiß nicht, wie viel Zeit für Ihre Aufgabe benötigt wird oder wie lange es dauert
2. Willst du eine Endlosschleifenarbeit durchführen.

AsyncTask ist keine bessere Option für Sie. AsyncTask wird hauptsächlich für kurze Operationen verwendet (höchstens einige Sekunden)

Wie verwende ich AsyncTask in deiner App?

1. Erstellen Sie eine Unterklasse von AsyncTask.
2. Überschreiben Sie doInBackground () und andere Methoden.
3. Erstellen Sie eine Instanz der AsyncTask-Unterklasse und rufen Sie execute () auf.

AsyncTask verwendet Generics-Datentypen

1. Parameter - Daten, mit denen die Ausführung des Hintergrundthreads gestartet wird.
2. Fortschritt - Daten, mit denen der Fortschritt der Aufgabe gemeldet wurde.
3. Ergebnis - Daten, die nach der Ausführung von doInBackground () zurückgegeben werden.

AsyncTask hilft uns, die Benutzeroberfläche innerhalb ihrer Methoden zu aktualisieren.

1. onPreExecute ()
2. onProgressUpdate ()
3. onPostExecute ()
4. onCancelled ()

Diese Methoden werden auf dem Hauptthread ausgeführt. Deshalb können Sie UI-Elemente aktualisieren.

Füge deine schwierige Aufgabe in doInBackgrund () hinzu

und rufen Sie AsyncTask mit execute () method auf.

Vollständiger ausführlicher Tutorial-Link unten

• Wie AsyncTask seriell und parallel ausführen?
• Wie AsyncTask abzubrechen?
• Erklärung zum AsyncTask-Status?

Beispiel für eine asynchrone Aufgabe mit der Anforderung POST:

List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("key1", "value1"));
params.add(new BasicNameValuePair("key1", "value2"));
new WEBSERVICEREQUESTOR(URL, params).execute();

class WEBSERVICEREQUESTOR extends AsyncTask<String, Integer, String>
{
    String URL;
    List<NameValuePair> parameters;

    private ProgressDialog pDialog;

    public WEBSERVICEREQUESTOR(String url, List<NameValuePair> params)
    {
        this.URL = url;
        this.parameters = params;
    }

    @Override
    protected void onPreExecute()
    {
        pDialog = new ProgressDialog(LoginActivity.this);
        pDialog.setMessage("Processing Request...");
        pDialog.setIndeterminate(false);
        pDialog.setCancelable(false);
        pDialog.show();
        super.onPreExecute();
    }

    @Override
    protected String doInBackground(String... params)
    {
        try
        {
            DefaultHttpClient httpClient = new DefaultHttpClient();
            HttpEntity httpEntity = null;
            HttpResponse httpResponse = null;

            HttpPost httpPost = new HttpPost(URL);

            if (parameters != null)
            {
                httpPost.setEntity(new UrlEncodedFormEntity(parameters));
            }
            httpResponse = httpClient.execute(httpPost);

            httpEntity = httpResponse.getEntity();
            return EntityUtils.toString(httpEntity);

        }  catch (Exception e)
        {

        }
        return "";
    }

    @Override
    protected void onPostExecute(String result)
    {
        pDialog.dismiss();

        try
        {

        }
        catch (Exception e)
        {

        }
        super.onPostExecute(result);
    }
}

Einfach:

LongOperation MyTask = new LongOperation();
MyTask.execute();

 private class AsyncTaskDemo extends AsyncTask<Void, Void, Void> {

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        // Showing progress dialog
        progressDialog = new ProgressDialog(this);
        progressDialog.setMessage("Loading...");
        progressDialog.setCancelable(false);
        progressDialog.show();

    }

    @Override
    protected Void doInBackground(Void... arg0) {

        //do code here 

        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        super.onPostExecute(result);
        // Dismiss the progress dialog
        if (progressDialog.isShowing()) {
            progressDialog.dismiss();
        }

    }

    @Override
    protected void onCancelled() {

        super.onCancelled();
        progressDialog.dismiss();
        Toast toast = Toast.makeText(getActivity(),
                "Error is occured due to some probelm", Toast.LENGTH_LONG);
        toast.setGravity(Gravity.TOP, 25, 400);
        toast.show();

    }

}

Sie müssen die Schaltfläche onclicklistener deklarieren. Sobald Sie die AsyncTask-Klasse DownloadJson aufgerufen haben, wird der Vorgang unten angezeigt:

@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        btn = (Button) findViewById(R.id.button1);

        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
             new DownloadJson().execute();
            }
        });

    }

     // DownloadJSON AsyncTask
    private class DownloadJson extends AsyncTask<Void, Void, Void> {
        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        @Override
        protected  Void doInBackground(Void... params) {
            newlist = new ArrayList<HashMap<String, String>>();
             json = jsonParser.makeHttpRequest(json, "POST");
            try {
                newarray = new JSONArray(json);
                    for (int i = 0; i < countdisplay; i++) {
                        HashMap<String, String> eachnew = new HashMap<String, String>();
                        newobject = newarray.getJSONObject(i);
                        eachnew.put("id", newobject.getString("ID"));
                        eachnew.put("name", newobject.getString("Name"));
                        newlist.add(eachnew);
                    }
                }
            } catch (JSONException e) {
                Log.e("Error", e.getMessage());
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void args) {
            newlisttemp.addAll(newlist);
            NewAdapterpager newadapterpager = new NewAdapterpager(ProcesssActivitypager.this,newlisttemp);
            newpager.setAdapter(newadapterpager);
        }
    }

Ändern Sie Ihren Code wie folgt:

@Override
protected void onPostExecute(String result) {

    runOnUiThread(new Runnable() {
        public void run() {
            TextView txt = (TextView) findViewById(R.id.output);
            txt.setText("Executed");
        }
    });
}

Während der Arbeit mit AsyncTask ist es notwendig, einen Klassennachfolger anzulegen und darin die Implementierung der für uns notwendigen Methoden zu registrieren. In dieser Lektion werden drei Methoden behandelt:

doInBackground - wird in einem neuen Thread ausgeführt, hier lösen wir alle unsere schwierigen Aufgaben. Da nicht-primärer Thread - hat keinen Zugriff auf die Benutzeroberfläche.

onPreExecute - Wird vor doInBackground ausgeführt und hat Zugriff auf die Benutzeroberfläche

onPostExecute - wird nach doInBackground ausgeführt (funktioniert nicht, wenn AsyncTask abgebrochen wurde - dazu in den nächsten Lektionen), hat Zugriff auf die Benutzeroberfläche

Diese MyAsyncTask-Klasse

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

@Override
protected void onPreExecute() {
  super.onPreExecute();
  tvInfo.setText("Start");
}

@Override
protected Void doInBackground(Void... params) {
  //your background method
  return null;
}

@Override
protected void onPostExecute(Void result) {
  super.onPostExecute(result);
  tvInfo.setText("Finish");
}

}

Und so rufen Sie Ihre Aktivität oder Ihr Fragment auf

MyAsyncTask  myAsyncTask = new MyAsyncTask ();
myAsyncTask.execute();

Beispiel für AsyncTask-Beispiel mit Fortschritt

import Android.animation.ObjectAnimator;
import Android.os.AsyncTask;
import Android.support.v7.app.AppCompatActivity;
import Android.os.Bundle;
import Android.util.Log;
import Android.view.View;
import Android.view.animation.AccelerateDecelerateInterpolator;
import Android.view.animation.DecelerateInterpolator;
import Android.view.animation.LinearInterpolator;
import Android.widget.Button;
import Android.widget.ProgressBar;
import Android.widget.TextView;

public class AsyncTaskActivity extends AppCompatActivity implements View.OnClickListener {

    Button btn;
    ProgressBar progressBar;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn = (Button) findViewById(R.id.button1);
        btn.setOnClickListener(this);
        progressBar = (ProgressBar)findViewById(R.id.pbar);
    }

    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.button1:
                new LongOperation().execute("");
                break;
        }
    }

    private class LongOperation extends AsyncTask<String, Integer, String> {

        @Override
        protected String doInBackground(String... params) {
            Log.d("AsyncTask", "doInBackground");
            for (int i = 0; i < 5; i++) {
                try {
                    Log.d("AsyncTask", "task "+(i + 1));
                    publishProgress(i + 1);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.interrupted();
                }
            }
            return "Completed";
        }

        @Override
        protected void onPostExecute(String result) {
            Log.d("AsyncTask", "onPostExecute");
            TextView txt = (TextView) findViewById(R.id.output);
            txt.setText(result);
            progressBar.setProgress(0);
        }

        @Override
        protected void onPreExecute() {
            Log.d("AsyncTask", "onPreExecute");
            TextView txt = (TextView) findViewById(R.id.output);
            txt.setText("onPreExecute");
            progressBar.setMax(500);
            progressBar.setProgress(0);
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            Log.d("AsyncTask", "onProgressUpdate "+values[0]);
            TextView txt = (TextView) findViewById(R.id.output);
            txt.setText("onProgressUpdate "+values[0]);

            ObjectAnimator animation = ObjectAnimator.ofInt(progressBar, "progress", 100 * values[0]);
            animation.setDuration(1000);
            animation.setInterpolator(new LinearInterpolator());
            animation.start();
        }
    }
}

ASync-Aufgabe; 

public class MainActivity extends AppCompatActivity {

 private String ApiUrl="your_api";

   @Override
   protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main);
     MyTask myTask=new MyTask();
     try {
         String result=myTask.execute(ApiUrl).get();
         Toast.makeText(getApplicationContext(),result,Toast.LENGTH_SHORT).show();
     } catch (ExecutionException e) {
         e.printStackTrace();
     } catch (InterruptedException e) {
        e.printStackTrace();
     }

  }


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


    @Override
    protected String doInBackground(String... strings) {
        String result="";
        HttpURLConnection httpURLConnection=null;
        URL url;

        try {
            url=new URL(strings[0]);
            httpURLConnection=(HttpURLConnection) url.openConnection();
            InputStream inputStream=httpURLConnection.getInputStream();
            InputStreamReader reader=new InputStreamReader(inputStream);
            result=getData(reader);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return result;
    }

    public String getData(InputStreamReader reader) throws IOException{
        String result="";
        int data=reader.read();
        while (data!=-1){
            char now=(char) data;
            result+=data;
            data=reader.read();
        }
        return result;
    }
  }
}