Scaricare un file con Android, e che mostra il progresso in un ProgressDialog

StackOverflow https://stackoverflow.com/questions/3028306

Domanda

Sto provando a scrivere un'applicazione semplice che viene aggiornato. Per questo ho bisogno di una funzione semplice che può scaricare un file e visualizza i progressi in corso in un ProgressDialog. So come fare la ProgressDialog, ma non sono sicuro di come visualizzare lo stato di avanzamento attuale e come scaricare il file in primo luogo.

È stato utile?

Soluzione

Ci sono molti modi per scaricare i file. A seguito di Io posto modi più comuni; spetta a voi decidere quale metodo è migliore per la vostra applicazione.

1. Usa AsyncTask e mostra l'avanzamento del download in una finestra di dialogo

Questo metodo permette di eseguire alcuni processi in background e aggiornare l'interfaccia utente, allo stesso tempo (in questo caso, aggiorneremo una barra di avanzamento).

Questo è un esempio di codice: 

// declare the dialog as a member field of your activity
ProgressDialog mProgressDialog;

// instantiate it within the onCreate method
mProgressDialog = new ProgressDialog(YourActivity.this);
mProgressDialog.setMessage("A message");
mProgressDialog.setIndeterminate(true);
mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
mProgressDialog.setCancelable(true);

// execute this when the downloader must be fired
final DownloadTask downloadTask = new DownloadTask(YourActivity.this);
downloadTask.execute("the url to the file you want to download");

mProgressDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {

    @Override
    public void onCancel(DialogInterface dialog) {
        downloadTask.cancel(true); //cancel the task
    }
});

Il AsyncTask sarà simile a questa: 

// usually, subclasses of AsyncTask are declared inside the activity class.
// that way, you can easily modify the UI thread from here
private class DownloadTask extends AsyncTask<String, Integer, String> {

    private Context context;
    private PowerManager.WakeLock mWakeLock;

    public DownloadTask(Context context) {
        this.context = context;
    }

    @Override
    protected String doInBackground(String... sUrl) {
        InputStream input = null;
        OutputStream output = null;
        HttpURLConnection connection = null;
        try {
            URL url = new URL(sUrl[0]);
            connection = (HttpURLConnection) url.openConnection();
            connection.connect();

            // expect HTTP 200 OK, so we don't mistakenly save error report
            // instead of the file
            if (connection.getResponseCode() != HttpURLConnection.HTTP_OK) {
                return "Server returned HTTP " + connection.getResponseCode()
                        + " " + connection.getResponseMessage();
            }

            // this will be useful to display download percentage
            // might be -1: server did not report the length
            int fileLength = connection.getContentLength();

            // download the file
            input = connection.getInputStream();
            output = new FileOutputStream("/sdcard/file_name.extension");

            byte data[] = new byte[4096];
            long total = 0;
            int count;
            while ((count = input.read(data)) != -1) {
                // allow canceling with back button
                if (isCancelled()) {
                    input.close();
                    return null;
                }
                total += count;
                // publishing the progress....
                if (fileLength > 0) // only if total length is known
                    publishProgress((int) (total * 100 / fileLength));
                output.write(data, 0, count);
            }
        } catch (Exception e) {
            return e.toString();
        } finally {
            try {
                if (output != null)
                    output.close();
                if (input != null)
                    input.close();
            } catch (IOException ignored) {
            }

            if (connection != null)
                connection.disconnect();
        }
        return null;
    }

Il metodo di cui sopra (doInBackground) viene eseguito sempre su un thread in background. Si consiglia di non effettuare alcuna attività di UI lì. D'altra parte, il onProgressUpdate e onPreExecute corsa sul thread dell'interfaccia utente, quindi non è possibile modificare la barra di avanzamento: 

    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        // take CPU lock to prevent CPU from going off if the user 
        // presses the power button during download
        PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
        mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
             getClass().getName());
        mWakeLock.acquire();
        mProgressDialog.show();
    }

    @Override
    protected void onProgressUpdate(Integer... progress) {
        super.onProgressUpdate(progress);
        // if we get here, length is known, now set indeterminate to false
        mProgressDialog.setIndeterminate(false);
        mProgressDialog.setMax(100);
        mProgressDialog.setProgress(progress[0]);
    }

    @Override
    protected void onPostExecute(String result) {
        mWakeLock.release();
        mProgressDialog.dismiss();
        if (result != null)
            Toast.makeText(context,"Download error: "+result, Toast.LENGTH_LONG).show();
        else
            Toast.makeText(context,"File downloaded", Toast.LENGTH_SHORT).show();
    }

Per questo per funzionare, è necessario il permesso WAKE_LOCK. 

<uses-permission android:name="android.permission.WAKE_LOCK" />

2. Scarica dal servizio

La grande domanda è: come faccio aggiorno la mia attività da un servizio ?. Nel prossimo esempio ci accingiamo a utilizzare due classi si può non essere a conoscenza di: ResultReceiver e IntentService. ResultReceiver è quella che ci permetterà di aggiornare il nostro filo da un servizio; IntentService è una sottoclasse di Service che spawn un thread per fare il lavoro di fondo da lì (si dovrebbe sapere che un Service corre in realtà nello stesso thread della vostra applicazione, quando si estende Service, è necessario micelio manualmente nuovi thread per eseguire le operazioni di CPU blocco) .

servizio di download può assomigliare a questo: 

public class DownloadService extends IntentService {
    public static final int UPDATE_PROGRESS = 8344;

    public DownloadService() {
        super("DownloadService");
    }
    @Override
    protected void onHandleIntent(Intent intent) {

        String urlToDownload = intent.getStringExtra("url");
        ResultReceiver receiver = (ResultReceiver) intent.getParcelableExtra("receiver");
        try {

            //create url and connect
            URL url = new URL(urlToDownload);
            URLConnection connection = url.openConnection();
            connection.connect();

            // this will be useful so that you can show a typical 0-100% progress bar
            int fileLength = connection.getContentLength();

            // download the file
            InputStream input = new BufferedInputStream(connection.getInputStream());

            String path = "/sdcard/BarcodeScanner-debug.apk" ;
            OutputStream output = new FileOutputStream(path);

            byte data[] = new byte[1024];
            long total = 0;
            int count;
            while ((count = input.read(data)) != -1) {
                total += count;

                // publishing the progress....
                Bundle resultData = new Bundle();
                resultData.putInt("progress" ,(int) (total * 100 / fileLength));
                receiver.send(UPDATE_PROGRESS, resultData);
                output.write(data, 0, count);
            }

            // close streams 
            output.flush();
            output.close();
            input.close();

        } catch (IOException e) {
            e.printStackTrace();
        }

        Bundle resultData = new Bundle();
        resultData.putInt("progress" ,100);

        receiver.send(UPDATE_PROGRESS, resultData);
    }
}

Aggiungi il servizio per il vostro manifesto: 

<service android:name=".DownloadService"/>

E l'attività sarà simile a questa: 

// initialize the progress dialog like in the first example

// this is how you fire the downloader
mProgressDialog.show();
Intent intent = new Intent(this, DownloadService.class);
intent.putExtra("url", "url of the file to download");
intent.putExtra("receiver", new DownloadReceiver(new Handler()));
startService(intent);

Qui si erano ResultReceiver viene a giocare: 

private class DownloadReceiver extends ResultReceiver{

    public DownloadReceiver(Handler handler) {
        super(handler);
    }

    @Override
    protected void onReceiveResult(int resultCode, Bundle resultData) {

        super.onReceiveResult(resultCode, resultData);

        if (resultCode == DownloadService.UPDATE_PROGRESS) {

            int progress = resultData.getInt("progress"); //get the progress
            dialog.setProgress(progress);

            if (progress == 100) {
                dialog.dismiss();
            }
        }
    }
}

2.1 biblioteca Usa Groundy

Groundy è una libreria che, in fondo consente di eseguire pezzi di codice in un servizio in background, e si basa sul concetto ResultReceiver mostrato sopra. Questa libreria è deprecato in questo momento. Questo è come il tutto il codice sarà simile:

L'attività in cui si sta mostrando la finestra di ... 

public class MainActivity extends Activity {

    private ProgressDialog mProgressDialog;

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

        findViewById(R.id.btn_download).setOnClickListener(new View.OnClickListener() {
            public void onClick(View view) {
                String url = ((EditText) findViewById(R.id.edit_url)).getText().toString().trim();
                Bundle extras = new Bundler().add(DownloadTask.PARAM_URL, url).build();
                Groundy.create(DownloadExample.this, DownloadTask.class)
                        .receiver(mReceiver)
                        .params(extras)
                        .queue();

                mProgressDialog = new ProgressDialog(MainActivity.this);
                mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
                mProgressDialog.setCancelable(false);
                mProgressDialog.show();
            }
        });
    }

    private ResultReceiver mReceiver = new ResultReceiver(new Handler()) {
        @Override
        protected void onReceiveResult(int resultCode, Bundle resultData) {
            super.onReceiveResult(resultCode, resultData);
            switch (resultCode) {
                case Groundy.STATUS_PROGRESS:
                    mProgressDialog.setProgress(resultData.getInt(Groundy.KEY_PROGRESS));
                    break;
                case Groundy.STATUS_FINISHED:
                    Toast.makeText(DownloadExample.this, R.string.file_downloaded, Toast.LENGTH_LONG);
                    mProgressDialog.dismiss();
                    break;
                case Groundy.STATUS_ERROR:
                    Toast.makeText(DownloadExample.this, resultData.getString(Groundy.KEY_ERROR), Toast.LENGTH_LONG).show();
                    mProgressDialog.dismiss();
                    break;
            }
        }
    };
}

Un'implementazione GroundyTask usato da Groundy per scaricare il file e mostrare lo stato di avanzamento: 

public class DownloadTask extends GroundyTask {    
    public static final String PARAM_URL = "com.groundy.sample.param.url";

    @Override
    protected boolean doInBackground() {
        try {
            String url = getParameters().getString(PARAM_URL);
            File dest = new File(getContext().getFilesDir(), new File(url).getName());
            DownloadUtils.downloadFile(getContext(), url, dest, DownloadUtils.getDownloadListenerForTask(this));
            return true;
        } catch (Exception pokemon) {
            return false;
        }
    }
}

E basta aggiungere questo per il manifesto: 

<service android:name="com.codeslap.groundy.GroundyService"/>

Non potrebbe essere più facile, credo. Basta prendere l'ultimo barattolo da Github e si è pronti ad andare. Tenete a mente che Groundy 's scopo principale è quello di rendere le chiamate alle API REST esterni in un servizio in background e risultati pubblicare per l'interfaccia utente con facilità. Se stai facendo qualcosa di simile nella vostra applicazione, potrebbe essere davvero utile.

2.2 Utilizzo https://github.com/koush/ion

3. Utilizzare la classe DownloadManager (GingerBread e successivi solo)

GingerBread ha portato una nuova funzionalità, DownloadManager, che consente di scaricare file in modo semplice e delegare il duro lavoro di gestire le discussioni, corsi d'acqua, ecc per il sistema.

Per prima cosa, vediamo un metodo di utilità: 

/**
 * @param context used to check the device version and DownloadManager information
 * @return true if the download manager is available
 */
public static boolean isDownloadManagerAvailable(Context context) {

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
        return true;
    }
    return false;
}

Il nome di Metodo spiega tutto. Una volta che si è sicuri DownloadManager è disponibile, si può fare qualcosa di simile: 

String url = "url you want to download";
DownloadManager.Request request = new DownloadManager.Request(Uri.parse(url));
request.setDescription("Some descrition");
request.setTitle("Some title");
// in order for this if to run, you must use the android 3.2 to compile your app
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    request.allowScanningByMediaScanner();
    request.setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
}
request.setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, "name-of-the-file.ext");

// get download service and enqueue file
DownloadManager manager = (DownloadManager) getSystemService(Context.DOWNLOAD_SERVICE);
manager.enqueue(request);

Scarica il progresso sarà in mostra nella barra di notifica.

Considerazioni finali

Primo e secondo metodi sono solo la punta di un iceberg. Ci sono un sacco di cose che devi tenere a mente se si desidera che la vostra applicazione per essere robusta. Ecco un elenco breve:

  • È necessario verificare se l'utente ha una connessione internet disponibile
  • Assicurati di avere i permessi giusti (INTERNET e WRITE_EXTERNAL_STORAGE); anche ACCESS_NETWORK_STATE se si desidera controllare la disponibilità di Internet.
  • Assicurarsi che la directory sono stati che si sta per scaricare file esiste e ha i permessi di scrittura.
  • Se download è troppo grande si consiglia di implementare un modo per riprendere il download se i precedenti tentativi falliti.
  • Gli utenti sarà grato se si consente loro di interrompere il download.

A meno che non è necessario un controllo dettagliato del processo di download, quindi prendere in considerazione utilizzando DownloadManager (3) perché già gestisce la maggior parte degli elementi di cui sopra.

ma anche considerare che le vostre esigenze possono cambiare. Ad esempio, DownloadManager fa alcuna risposta caching . Si scaricherà ciecamente gli stessi grandi file più volte. Non c'è modo semplice per risolvere il problema dopo il fatto. Dove se si inizia con un HttpURLConnection di base (1, 2), quindi tutto ciò che serve è quello di aggiungere un HttpResponseCache. Così lo sforzo iniziale di imparare gli strumenti standard, di base può essere un buon investimento.

  

Questa classe è stata sconsigliata a livello di API 26. ProgressDialog è un modale   finestra, che impedisce all'utente di interagire con l'applicazione. Anziché   di utilizzo di questa classe, è necessario utilizzare un indicatore di progresso come   ProgressBar, che può essere incorporato nell'interfaccia utente della tua app. In alternativa,   è possibile utilizzare una notifica per informare l'utente del progresso del compito. Per maggiori dettagli link

Altri suggerimenti

Non dimenticate di aggiungere le autorizzazioni al file manifesto, se hai intenzione di essere a scaricare roba da internet! 

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.helloandroid"
    android:versionCode="1"
    android:versionName="1.0">

        <uses-sdk android:minSdkVersion="10" />

        <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"></uses-permission>
        <uses-permission android:name="android.permission.INTERNET"></uses-permission>
        <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>
        <uses-permission android:name="android.permission.READ_PHONE_STATE"></uses-permission>

        <application 
            android:icon="@drawable/icon" 
            android:label="@string/app_name" 
            android:debuggable="true">

        </application>

</manifest>

Sì, il codice di cui sopra funzionerà Ma se si sta aggiornando il vostro progressbar in onProgressUpdate di Asynctask e si preme il tasto indietro o finire la vostra attività AsyncTask perde la sua pista con la vostra interfaccia utente .E quando si torna alla tua attività, anche se scaricare è in esecuzione in background si vedrà alcun aggiornamento su progressbar. Così il OnResume() tenta di eseguire un filo come runOnUIThread con un compito timer che aggiorna ur progressbar con i valori di aggiornamento dal AsyncTask in esecuzione di sfondo. 

private void updateProgressBar(){
    Runnable runnable = new updateProgress();
    background = new Thread(runnable);
    background.start();
}

public class updateProgress implements Runnable {
    public void run() {
        while(Thread.currentThread()==background)
            //while (!Thread.currentThread().isInterrupted()) {
            try {
                Thread.sleep(1000); 
                Message msg = new Message();
                progress = getProgressPercentage();        
                handler.sendMessage(msg);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } catch (Exception e) {
        }
    }
}

private Handler handler = new Handler(){
    @Override
    public void handleMessage(Message msg) {
        progress.setProgress(msg.what);
    }
};

Non dimenticare di Destroy il filo quando ur attività non è visibile. 

private void destroyRunningThreads() {
    if (background != null) {
        background.interrupt();
        background=null;
    }
}

Mi consiglia di utilizzare il mio progetto Netroid , Si basa su Volley . Ho aggiunto alcune caratteristiche ad esso come il multi-eventi di callback, Gestione dei file scaricare. Questo potrebbe essere di qualche aiuto.

Ho modificato classe AsyncTask alla creazione del manico progressDialog allo stesso contesto .I pensare seguente codice sarà più riutilizzabile. (Può essere chiamato da qualsiasi attività semplicemente passare contesto, file di destinazione, messaggio di dialogo) 

public static class DownloadTask extends AsyncTask<String, Integer, String> {
    private ProgressDialog mPDialog;
    private Context mContext;
    private PowerManager.WakeLock mWakeLock;
    private File mTargetFile;
    //Constructor parameters :
    // @context (current Activity)
    // @targetFile (File object to write,it will be overwritten if exist)
    // @dialogMessage (message of the ProgresDialog)
    public DownloadTask(Context context,File targetFile,String dialogMessage) {
        this.mContext = context;
        this.mTargetFile = targetFile;
        mPDialog = new ProgressDialog(context);

        mPDialog.setMessage(dialogMessage);
        mPDialog.setIndeterminate(true);
        mPDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        mPDialog.setCancelable(true);
        // reference to instance to use inside listener
        final DownloadTask me = this;
        mPDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
            @Override
            public void onCancel(DialogInterface dialog) {
                me.cancel(true);
            }
        });
        Log.i("DownloadTask","Constructor done");
    }

    @Override
    protected String doInBackground(String... sUrl) {
        InputStream input = null;
        OutputStream output = null;
        HttpURLConnection connection = null;
        try {
            URL url = new URL(sUrl[0]);
            connection = (HttpURLConnection) url.openConnection();
            connection.connect();

            // expect HTTP 200 OK, so we don't mistakenly save error report
            // instead of the file
            if (connection.getResponseCode() != HttpURLConnection.HTTP_OK) {
                return "Server returned HTTP " + connection.getResponseCode()
                        + " " + connection.getResponseMessage();
            }
            Log.i("DownloadTask","Response " + connection.getResponseCode());

            // this will be useful to display download percentage
            // might be -1: server did not report the length
            int fileLength = connection.getContentLength();

            // download the file
            input = connection.getInputStream();
            output = new FileOutputStream(mTargetFile,false);

            byte data[] = new byte[4096];
            long total = 0;
            int count;
            while ((count = input.read(data)) != -1) {
                // allow canceling with back button
                if (isCancelled()) {
                    Log.i("DownloadTask","Cancelled");
                    input.close();
                    return null;
                }
                total += count;
                // publishing the progress....
                if (fileLength > 0) // only if total length is known
                    publishProgress((int) (total * 100 / fileLength));
                output.write(data, 0, count);
            }
        } catch (Exception e) {
            return e.toString();
        } finally {
            try {
                if (output != null)
                    output.close();
                if (input != null)
                    input.close();
            } catch (IOException ignored) {
            }

            if (connection != null)
                connection.disconnect();
        }
        return null;
    }
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        // take CPU lock to prevent CPU from going off if the user
        // presses the power button during download
        PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
        mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
                getClass().getName());
        mWakeLock.acquire();

        mPDialog.show();

    }

    @Override
    protected void onProgressUpdate(Integer... progress) {
        super.onProgressUpdate(progress);
        // if we get here, length is known, now set indeterminate to false
        mPDialog.setIndeterminate(false);
        mPDialog.setMax(100);
        mPDialog.setProgress(progress[0]);

    }

    @Override
    protected void onPostExecute(String result) {
        Log.i("DownloadTask", "Work Done! PostExecute");
        mWakeLock.release();
        mPDialog.dismiss();
        if (result != null)
            Toast.makeText(mContext,"Download error: "+result, Toast.LENGTH_LONG).show();
        else
            Toast.makeText(mContext,"File Downloaded", Toast.LENGTH_SHORT).show();
    }
}

Non dimenticare di sostituire "/ sdcard ..." di nuovo file ( "/ mnt / sdcard / ..."), altrimenti si otterrà un < strong> FileNotFoundException

questo post del blog molto utile , Il suo utilizzano loopJ al download di file, esso ha solo una funzione semplice, sarà utile ad alcuni nuovi ragazzi Android.

Mentre stavo iniziando a imparare lo sviluppo di Android, avevo imparato che ProgressDialog è la strada da percorrere. C'è il metodo di setProgress ProgressDialog che può essere invocato per aggiornare il livello di progresso come il file viene scaricato.

Il migliore che ho visto in molte applicazioni è che essi personalizzare gli attributi di questa finestra di avanzamento per dare un aspetto migliore e si sentono alla finestra di avanzamento rispetto alla versione magazzino. Buono a mantenere l'utente impegnato con qualche animazione di come rana, elefante o gatti carino / cuccioli. Ogni animazione con nella finestra di avanzamento attira utenti e non si sentono come essere tenuti in attesa per lungo tempo.

Il mio consiglio personale è quello di utilizzare Progress Dialog e costruire prima dell'esecuzione, o iniziare a OnPreExecute(), pubblici i progressi compiuti spesso se si utilizza lo stile orizzontale della barra di avanzamento della finestra di avanzamento. La restante parte è quello di ottimizzare l'algoritmo di doInBackground.

biblioteca Usa Query Android, molto cool indeed.You può cambiare in modo da utilizzare ProgressDialog come si vede in altri esempi, questo mostrerà il progresso vista dal layout e nasconderla dopo il completamento. 

File target = new File(new File(Environment.getExternalStorageDirectory(), "ApplicationName"), "tmp.pdf");
new AQuery(this).progress(R.id.progress_view).download(_competition.qualificationScoreCardsPdf(), target, new AjaxCallback<File>() {
    public void callback(String url, File file, AjaxStatus status) {
        if (file != null) {
            // do something with file  
        } 
    }
});

Permessi 

  <uses-permission android:name="android.permission.INTERNET" />
  <uses-permission 
   android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

Utilizzando HttpURLConnection 

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

import android.app.Activity;
import android.app.Dialog;
import android.os.Bundle;
import android.os.Environment;
import android.view.View;
import android.view.Window;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.ProgressBar;
import android.widget.TextView;
import android.widget.Toast;

public class DownloadFileUseHttpURLConnection extends Activity {

ProgressBar pb;
Dialog dialog;
int downloadedSize = 0;
int totalSize = 0;
TextView cur_val;
String dwnload_file_path =  
"http://coderzheaven.com/sample_folder/sample_file.png";
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    Button b = (Button) findViewById(R.id.b1);
    b.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View v) {
             showProgress(dwnload_file_path);

                new Thread(new Runnable() {
                    public void run() {
                         downloadFile();
                    }
                  }).start();
        }
    });
}

void downloadFile(){

    try {
        URL url = new URL(dwnload_file_path);
        HttpURLConnection urlConnection = (HttpURLConnection)   
 url.openConnection();

        urlConnection.setRequestMethod("GET");
        urlConnection.setDoOutput(true);

        //connect
        urlConnection.connect();

        //set the path where we want to save the file           
        File SDCardRoot = Environment.getExternalStorageDirectory(); 
        //create a new file, to save the downloaded file 
        File file = new File(SDCardRoot,"downloaded_file.png");

        FileOutputStream fileOutput = new FileOutputStream(file);

        //Stream used for reading the data from the internet
        InputStream inputStream = urlConnection.getInputStream();

        //this is the total size of the file which we are downloading
        totalSize = urlConnection.getContentLength();

        runOnUiThread(new Runnable() {
            public void run() {
                pb.setMax(totalSize);
            }               
        });

        //create a buffer...
        byte[] buffer = new byte[1024];
        int bufferLength = 0;

        while ( (bufferLength = inputStream.read(buffer)) > 0 ) {
            fileOutput.write(buffer, 0, bufferLength);
            downloadedSize += bufferLength;
            // update the progressbar //
            runOnUiThread(new Runnable() {
                public void run() {
                    pb.setProgress(downloadedSize);
                    float per = ((float)downloadedSize/totalSize) *     
                    100;
                    cur_val.setText("Downloaded " + downloadedSize +  

                    "KB / " + totalSize + "KB (" + (int)per + "%)" );
                }
            });
        }
        //close the output stream when complete //
        fileOutput.close();
        runOnUiThread(new Runnable() {
            public void run() {
                // pb.dismiss(); // if you want close it..
            }
        });         

    } catch (final MalformedURLException e) {
        showError("Error : MalformedURLException " + e);        
        e.printStackTrace();
    } catch (final IOException e) {
        showError("Error : IOException " + e);          
        e.printStackTrace();
    }
    catch (final Exception e) {
        showError("Error : Please check your internet connection " +  
e);
    }       
}

void showError(final String err){
    runOnUiThread(new Runnable() {
        public void run() {
            Toast.makeText(DownloadFileDemo1.this, err,  
      Toast.LENGTH_LONG).show();
        }
    });
}

void showProgress(String file_path){
    dialog = new Dialog(DownloadFileDemo1.this);
    dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);
    dialog.setContentView(R.layout.myprogressdialog);
    dialog.setTitle("Download Progress");

    TextView text = (TextView) dialog.findViewById(R.id.tv1);
    text.setText("Downloading file from ... " + file_path);
    cur_val = (TextView) dialog.findViewById(R.id.cur_pg_tv);
    cur_val.setText("Starting download...");
    dialog.show();

     pb = (ProgressBar)dialog.findViewById(R.id.progress_bar);
     pb.setProgress(0);
            pb.setProgressDrawable(
      getResources().getDrawable(R.drawable.green_progress));  
  }
}

Io sono l'aggiunta un'altra risposta per altra soluzione che sto usando ora, perché Android Query è così grande e non mantenuto per rimanere in buona salute. Così mi sono trasferito a questo https://github.com/amitshekhariitbhu/Fast-Android-Networking. 

    AndroidNetworking.download(url,dirPath,fileName).build()
      .setDownloadProgressListener(new DownloadProgressListener() {
        public void onProgress(long bytesDownloaded, long totalBytes) {
            bar.setMax((int) totalBytes);
            bar.setProgress((int) bytesDownloaded);
        }
    }).startDownload(new DownloadListener() {
        public void onDownloadComplete() {
            ...
        }

        public void onError(ANError error) {
            ...
        }
    });
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top