il y a plusieurs façons de télécharger des fichiers. La suite, je vais poster plus souvent; c'est à vous de décider quelle méthode est la meilleure pour votre application.

1. Utilisez AsyncTask et afficher la progression du téléchargement dans un dialogue

cette méthode vous permettra d'exécuter certains processus de fond et de mettre à jour L'interface en même temps (dans ce cas, nous mettrons à jour une barre de progression).

Ceci est un exemple de code:

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

le AsyncTask ressemblera à ceci:

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

la méthode ci-dessus ( doInBackground ) fonctionne toujours sur un filetage d'arrière-plan. Vous ne devriez pas faire de tâches D'assurance-chômage là-bas. D'un autre côté ,le onProgressUpdate et le onPreExecute fonctionnent sur le fil UI, de sorte que vous pouvez changer la barre de progression:

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

pour cela, vous avez besoin de la permission WAKE_LOCK.

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

2. Télécharger à partir de Service

la grande question ici est: comment mettre à jour mon activité d'un service? . Dans l'exemple suivant, nous allons utiliser deux classes, vous ne pouvez pas être au courant: ResultReceiver et IntentService . ResultReceiver est celui qui nous permettra de mettre à jour notre thread à partir d'un service; IntentService est une sous-classe de Service qui produit un thread pour faire du travail de fond à partir de là (vous devriez savoir qu'un Service court en fait dans le même thread de votre application; lorsque vous prolongez Service , vous devez lancer manuellement de nouveaux threads pour exécuter les opérations de blocage CPU).

le service de téléchargement peut ressembler à ceci:

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

ajoutez le service à votre manifeste:

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

et l'activité ressemblera à ceci:

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

c'est Là que les ResultReceiver vient de jouer:

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 Utiliser Groundy bibliothèque

Groundy est une bibliothèque qui vous aide essentiellement à exécuter des morceaux de code dans un service de fond, et il est basé sur le concept ResultReceiver ci-dessus. Cette bibliothèque est dépréciée en ce moment. Voici à quoi ressemblerait le code entier :

l'activité où vous montrez le dialogue...

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 GroundyTask la mise en œuvre utilisée par les Groundy pour télécharger le fichier et de montrer les progrès accomplis:

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

et ajoutez ceci au manifeste:

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

ça ne peut pas être plus facile. Il suffit de prendre le dernier pot de Github et vous êtes prêt à aller. Gardez à l'esprit que Groundy ' s principal objectif est de faire des appels à des API de repos externes dans un contexte afficher facilement les résultats du service à L'IU. Si vous faites quelque chose comme cela dans votre application, il pourrait être vraiment utile.

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

3. Utiliser DownloadManager classe ( GingerBread et versions plus récentes uniquement)

GingerBread apporté une nouvelle fonctionnalité, DownloadManager , qui vous permet de télécharger des fichiers facilement et de déléguer le travail difficile de la manipulation des threads, flux, etc. pour le système.

tout d'abord, voyons une méthode d'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;
}

le nom de la méthode explique tout. Une fois que vous êtes sûr que DownloadManager est disponible, vous pouvez faire quelque chose comme ceci:

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

télécharger le progrès sera affiché dans la barre de notification.

dernières pensées

les première et deuxième méthodes ne sont que la pointe de l'iceberg. Il y a beaucoup de choses vous devez garder à l'esprit si vous voulez que votre application d'être robuste. Voici une brève liste:

• , Vous devez vérifier si l'utilisateur a une connexion internet est disponible
• assurez-vous d'avoir les bonnes permissions ( INTERNET et WRITE_EXTERNAL_STORAGE ); aussi ACCESS_NETWORK_STATE si vous voulez vérifier la disponibilité sur Internet.
• assurez-vous que le répertoire où vous allez télécharger des fichiers existent et a les permissions d'écriture.
• si le téléchargement est trop important, vous pouvez mettre en œuvre un moyen de reprendre le téléchargement si les tentatives précédentes ont échoué.
• les utilisateurs seront reconnaissants si vous leur permettez d'interrompre le téléchargement.

sauf si vous avez besoin d'un contrôle détaillé du processus de téléchargement, alors envisagez d'utiliser DownloadManager (3) parce qu'il traite déjà la plupart des éléments énumérés ci-dessus.

mais aussi considérer que vos besoins peut changer. Par exemple, DownloadManager ne répond pas à la mise en cache . Il téléchargera aveuglément le même Gros Fichier plusieurs fois. Il n'y a pas de moyen facile de le réparer après les faits. Où si vous commencez par un HttpURLConnection (1, 2), alors tout ce dont vous avez besoin est d'ajouter un HttpResponseCache . Ainsi, l'effort initial d'apprentissage des outils standards de base peut être un bon investissement.

cette classe a été dépréciée au niveau API 26. ProgressDialog est un modal dialogue, qui évite à l'utilisateur d'interagir avec l'application. Plutôt de l'utilisation de cette classe, vous devez utiliser un indicateur de progression comme ProgressBar, qui peut être intégré dans L'interface utilisateur de votre application. Alternativement, vous pouvez utiliser une notification pour informer l'utilisateur de la tâche en cours. Pour plus de détails Lien