Android: comment attendre que AsyncTask se termine dans MainThread?

Je sais que tu vas d'abord c'est... pourquoi diable sur le monde, vous utilisez ensuite AsyncTask.

Donc voici mon problème je suis en train de travailler sur certains Android application (API 7 pour android 2.1 ou supérieur) , et je suis en train de tester sur émulateur et que tout allait bien, alors j'ai testé sur HTC Sensation et il dit NetworkOnMainThreadExeption!

J'étais le téléchargement de quelques photos et ensuite dessiner sur la carte.

Donc pour résoudre ce problème, chaque (connexion internet) dans ce cas, le téléchargement de photos que je doit mettre sur AsyncTask pour travailler.

J'ai donc besoin d'une méthode comment savoir quand toutes les images sont prises afin que je puisse commencer à dessiner..

J'ai essayé tellement de choses et pas de résultat je n'ai aucune idée. J'en ai trouvé une solution avec le gestionnaire de mais si plus lent net-je obtenir nullpointer(parce que les images ne sont pas téléchargées).

De sorte s'il vous plaît aider moi.

EDIT:

voici l'idée:

Bitmap bubbleIcon ;
onCreate(){
...
//i am making call for Async
new ImgDown().execute(url);
//and then i calling functions and classes to draw with that picture bubbleIcon !
DrawOnMap(bubbleIcon);
}
//THIS IS ASYNC AND FOR EX. SUPPOSE I NEED TO DOWNLOAD THE PIC FIRST
class ImgDown extends AsyncTask<String, Void, Bitmap> {
private String url;
public ImgDown() {
}
@Override
protected Bitmap doInBackground(String... params) {
url = params[0];
try {
return getBitmapFromURL(url);
} catch (Exception err) {
}
return null;
}
@Override
protected void onPostExecute(Bitmap result) {
bubbleIcon = result;
bubbleIcon = Bitmap
.createScaledBitmap(bubbleIcon, 70, 70, true);
}
public Bitmap getBitmapFromURL(String src) {
try {
Log.e("src", src);
URL url = new URL(src);
HttpURLConnection connection = (HttpURLConnection) url
.openConnection();
connection.setDoInput(true);
connection.connect();
InputStream input = connection.getInputStream();
///tuka decode na slika vo pomalecuk kvalitet!
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 3;
Bitmap myBitmap = BitmapFactory
.decodeStream(new FlushedInputStream(input));
Log.e("Bitmap", "returned");
return myBitmap;
} catch (IOException e) {
e.printStackTrace();
Log.e("getBitmapFromURL", e.getMessage());
return null;
}
}
class FlushedInputStream extends FilterInputStream {
public FlushedInputStream(InputStream inputStream) {
super(inputStream);
}
public long skip(long n) throws IOException {
long totalBytesSkipped = 0L;
while (totalBytesSkipped < n) {
long bytesSkipped = in.skip(n - totalBytesSkipped);
if (bytesSkipped == 0L) {
int byteValue = read();
if (byteValue < 0) {
break; //we reached EOF
} else {
bytesSkipped = 1; //we read one byte
}
}
totalBytesSkipped += bytesSkipped;
}
return totalBytesSkipped;
}
}
}

j'espère que maintenant elle est plus claire.

source d'informationauteur user1730007

class OpenWorkTask extends AsyncTask {
@Override
protected Boolean doInBackground(String... params) {
//do something
return true;
}
@Override
protected void onPostExecute(Boolean result) {
//The results of the above method
//Processing the results here
myHandler.sendEmptyMessage(0);
}
}
Handler myHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 0:
//calling to this function from other pleaces
//The notice call method of doing things
break;
default:
break;
}
}
};

Vous pouvez écrire votre propre Délégué à délégué info quant à la finition de la tâche, à l'aide de la programmation orientée objet principes:

task_delegate.java

public interface TaskDelegate {
void TaskCompletionResult(String result);
}

main_activity.java

public class MainActivity extends Activity implements TaskDelegate {
//call this method when you need     
private void startAsynctask() {
myAsyncTask = new MyAsyncTask(this);
myAsyncTask.execute();
}
//your code
@Override
public void TaskCompletionResult(String result) {
GetSomethingByResult(result);
}
}

my_asynctask.java

public class MyAsyncTask extends AsyncTask<Void, Integer, String> {
private TaskDelegate delegate;
protected MyAsyncTask(TaskDelegate delegate) {
this.delegate = delegate;
}
//your code 
@Override
protected void onPostExecute(String result) {
delegate.TaskCompletionResult(result);
}
}

class openWorkTask extends AsyncTask<String, String, Boolean> {
@Override
protected Boolean doInBackground(String... params) {
//do something
return true;
}
@Override
protected void onPostExecute(Boolean result) {
//The results of the above method
//Processing the results here
}
}

Je voudrais utiliser une boîte de Dialogue de Progression, si j'étais vous. De cette façon, les utilisateurs peuvent voir que quelque chose se passe alors que le ASyncTask téléchargements de l'image. Sur PostExecute, appel à une méthode de votre principal de code qui vérifie si les photos sont nulles. Rappelez-vous que vous ne peut pas mettre à jour l'INTERFACE utilisateur dans la méthode doInBackground afin de ne pas l'INTERFACE utilisateur du travail dans onPreExecute ou onPostExecute

private class DownloadPictures extends AsyncTask<String, Void, String> 
{
ProgressDialog progressDialog;
@Override
protected String doInBackground(String... params) 
{
//Download your pictures
return null;
}
@Override
protected void onPostExecute(String result) 
{
progressDialog.cancel();
//Call your method that checks if the pictures were downloaded
}
@Override
protected void onPreExecute() {
progressDialog = new ProgressDialog(
YourActivity.this);
progressDialog.setMessage("Downloading...");
progressDialog.setCancelable(false);
progressDialog.show();
}
@Override
protected void onProgressUpdate(Void... values) {
//Do nothing
}
}

Vous devez vous connecter pour publier un commentaire.