Ci sono molti modi per scaricare i file. Di seguito pubblicherò i modi più comuni; spetta a te decidere quale metodo è migliore per la tua app.

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

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

Questo è un codice di esempio:

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

Il {[13] } sarà simile a questo:

// 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 sopra (doInBackground) viene eseguito sempre su un thread in background. Non dovresti fare alcuna attività dell'interfaccia utente lì. D'altra parte, onProgressUpdate e onPreExecute vengono eseguiti sul thread dell'interfaccia utente, quindi è 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 farlo funzionare, è necessario il permesso WAKE_LOCK.

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

2. Scarica dal servizio

La grande domanda qui è: come posso aggiornare la mia attività da un servizio?. Nel prossimo esempio useremo due classi di cui potresti non essere a conoscenza: ResultReceiver e IntentService. ResultReceiver è quella che ci permetterà di aggiornare il nostro thread da un servizio; IntentService ' e una sottoclasse di Service che genera un thread di sfondo per il proprio lavoro (si dovrebbe sapere che un Service viene eseguito effettivamente nello stesso thread della tua app; quando si estende Service, manualmente, è necessario generare il nuovo thread per eseguire le operazioni di blocco CPU).

Il servizio di download può essere simile 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 {
            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());
            OutputStream output = new FileOutputStream("/sdcard/BarcodeScanner-debug.apk");

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

            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 al manifest:

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

E l'attività sarà simile a questo:

// 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 è stato 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");
            mProgressDialog.setProgress(progress);
            if (progress == 100) {
                mProgressDialog.dismiss();
            }
        }
    }
}

2.1 Utilizzare la libreria Groundy

Groundy è una libreria che fondamentalmente ti aiuta a eseguire pezzi di codice in un servizio in background e si basa sul concetto ResultReceiver mostrato sopra. Questa libreria è deprecata al momento. Questo è il modo in cui l'intero codice sarà simile a:

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

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

A GroundyTask implementazione utilizzata 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 al manifesto:

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

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

3. UsaDownloadManager class (GingerBread e solo versioni successive)

GingerBread ha portato una nuova funzionalità, DownloadManager, che consente di scaricare facilmente i file e delegare il duro lavoro di gestione di thread, flussi, ecc. al 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;
}

Spiega tutto. Una volta che sei sicuro che DownloadManager è disponibile, puoi fare qualcosa del genere:

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

Lo stato di avanzamento del download sarà mostrando nella barra di notifica.

Considerazioni finali

Primo e secondo metodo sono solo la punta dell'iceberg. Ci sono molte cose che devi tenere a mente se vuoi che la tua app sia robusta. Ecco un breve elenco:

• È necessario verificare se l'utente dispone di una connessione Internet disponibile
• Assicurarsi di avere le autorizzazioni giuste (INTERNET e WRITE_EXTERNAL_STORAGE); anche ACCESS_NETWORK_STATE se si desidera verificare la disponibilità di Internet.
• Assicurarsi che la directory erano che si sta per scaricare i file esistono e ha le autorizzazioni di scrittura.
• Se il download è troppo grande, potresti voler implementare un modo per riprendere il download se i tentativi precedenti non sono riusciti.
• Gli utenti saranno grati se si consente loro di interrompere il download.

A meno che non sia necessario un controllo dettagliato del processo di download, considerare l'utilizzo di DownloadManager (3) perché gestisce già la maggior parte degli elementi sopra elencati.

Ma considera anche che le tue esigenze possono cambiare. Ad esempio, DownloadManager non fa cache di risposta . Scaricherà ciecamente lo stesso grande file più volte. Non c'è un modo semplice per risolverlo dopo il fatto. Dove se si inizia con una base HttpURLConnection (1, 2), quindi tutto ciò che serve è aggiungere un HttpResponseCache. Quindi lo sforzo iniziale di imparare gli strumenti standard di base può essere un buon investimento.

Questa classe è stata deprecata nel livello API 26. ProgressDialog è un modale finestra di dialogo, che impedisce all'utente di interagire con app. Invece di usare questa classe, dovresti usare un indicatore di avanzamento come ProgressBar, che può essere incorporato nell'interfaccia utente della tua app. Alternativamente, è possibile utilizzare una notifica per informare l'utente dello stato di avanzamento dell'attività. Per maggiori dettagli Link