Wie man eine pdf-Datei herunterladen in Android?

Herunterladen einer PDF-Datei funktioniert genauso wie der Download von einem anderen binären Datei.

1. Öffnen Sie eine HttpUrlConnection
2. Verwenden Sie die Verbindung getInputStream() Methode, die Datei zu Lesen.
3. Erstellen Sie eine FileOutputStream und schreiben Sie den inputstream.

Überprüfen dieser Beitrag zum Beispiel-source-code.

InformationsquelleAutor der Antwort THelper

Gibt es viele Möglichkeiten, um download-Dateien. Folgenden werde ich die meisten gemeinsamen Wege; es ist bis zu Sie zu entscheiden, welche Methode ist besser für die app.

1. Verwenden AsyncTask und zeigen Sie den download-Fortschritt in einem dialog

Diese Methode ermöglicht es Ihnen, führen einige Prozesse im hintergrund und die Aktualisierung der Benutzeroberfläche in der gleichen Zeit (in diesem Fall aktualisieren wir eine progress-bar).

Dies ist ein Beispiel-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);
    }
});

Den AsyncTask wird wie folgt Aussehen:

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

Die oben genannte Methode (doInBackground) läuft immer auf einem hintergrund-thread. Man sollte nicht jede UI-Aufgaben gibt. Auf der anderen Seite, die onProgressUpdate und onPreExecute laufen auf dem UI-thread, also dort können Sie die Statusanzeige:

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

Für diese auszuführen, müssen Sie die WAKE_LOCK Erlaubnis.

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

2. Download von Service

Ist die große Frage hier ist: wie aktualisiere ich meine Aktivität von einem service?. Im nächsten Beispiel werden wir verwenden, zwei Klassen, die Sie möglicherweise nicht bewusst sein: ResultReceiver und IntentService. ResultReceiver ist die eine, die es uns ermöglichen, aktualisieren unseren thread von einem service; IntentService ist eine Unterklasse von Service die spawns einen thread für die hintergrund-Arbeit von dort aus (Sie sollten wissen, dass ein Service läuft tatsächlich in dem gleichen thread der app; wenn Sie erweitert Service manuell müssen Sie laichen neue threads ausgeführt werden CPU-blockierenden Operationen).

Download-service kann wie folgt Aussehen:

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

Fügen Sie den service, um Ihre manifest:

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

Und die Aktivität wird wie folgt Aussehen:

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

Hier ResultReceiver kommt zu spielen:

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 Verwenden Groundy Bibliothek

Groundy ist eine Bibliothek, die im Grunde hilft Sie führen code-Stücken, die in einem hintergrund-Dienst, und es basiert auf der ResultReceiver Konzept oben gezeigt. Diese Bibliothek ist veraltet im moment. Dies ist, wie die ganze code würde wie folgt Aussehen:

Die Aktivität, bei der Sie das Dialogfeld anzeigen...

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

Einen GroundyTask Implementierung von Groundy um die Datei herunterzuladen, und zeigen Sie den Fortschritt:

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

Und fügen Sie einfach diese zu dem manifest:

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

Es könnte nicht einfacher sein, denke ich. Schnapp dir einfach den aktuellen jar - von Github und Sie sind bereit zu gehen. Beachten Sie, dass Groundy's Hauptzweck ist es, Anrufe zu externen REST-apis in einem hintergrund-service und post-Ergebnisse der Benutzeroberfläche mit einfach. Wenn Sie etwas tun möchten, in Ihrer app, es könnte wirklich sinnvoll sein.

2.2 die Nutzung https://github.com/koush/ion

3. Verwenden DownloadManager Klasse (GingerBread und höher nur)

Lebkuchen brachte eine neue Funktion, die DownloadManagerdie es Ihnen ermöglicht das herunterladen von Dateien einfach und delegieren Sie die harte Arbeit der Umgang mit threads, streams, etc. um das system.

Erste, mal sehen, eine utility-Methode:

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

Methode der name erklärt alles. Sobald Sie sicher sind, dass DownloadManager verfügbar ist, können Sie etwas wie das hier tun:

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

Download wird die Fortschritte zeigen sich in der notification bar.

Abschließende Gedanken

Ersten und zweiten Methoden sind nur die Spitze des Eisbergs. Es gibt viele Dinge, die Sie müssen im Hinterkopf behalten, wenn Sie möchten, dass Ihre app zu robust sein. Hier ist eine kurze Liste:

• Müssen Sie überprüfen, ob Benutzer eine internet-Verbindung verfügbar
• Stellen Sie sicher, dass Sie die richtigen Berechtigungen (INTERNET und WRITE_EXTERNAL_STORAGE); auch ACCESS_NETWORK_STATE wenn Sie möchten, überprüfen Sie die internet-Verfügbarkeit.
• Stellen Sie sicher, dass das Verzeichnis wurden Sie gehen, um download-Dateien existieren und Schreibrechte.
• Wenn der download zu groß ist möchten Sie vielleicht zu implementieren sind ein Weg, um den download fortzusetzen, wenn der Vorherige Versuch fehlgeschlagen ist.
• Anwender werden Ihnen dankbar sein, wenn Sie es Ihnen ermöglichen, zu unterbrechen, die download.

Es sei denn, Sie benötigen detaillierte Kontrolle der download-Prozess ist, dann erwägen Sie die Verwendung DownloadManager (3), weil es bereits behandelt die meisten der oben aufgeführten Gegenstände.

Aber auch der Meinung, dass Ihre Bedürfnisse können sich ändern. Zum Beispiel DownloadManager keine Antwort-caching. Es wird blind den download der gleichen großen Datei mehrere Male. Es gibt keine einfache Möglichkeit, es zu beheben und nach der Tat. Wo, wenn Sie beginnen mit einer grundlegenden HttpURLConnection (1, 2), dann alles, was Sie brauchen, ist zum hinzufügen eines HttpResponseCache. So ist die anfängliche Anstrengung des Lernens, die basic -, standard-tools können eine gute Investition.

InformationsquelleAutor der Antwort Arpit Patel

public static class Downloader {

 public static void DownloadFile(String fileURL, File directory) {
    try {
         FileOutputStream file = new FileOutputStream(directory);
         URL url = new URL(fileURL);
        HttpURLConnection connection = (HttpURLConnection) url .openConnection();
         connection .setRequestMethod("GET");
         connection .setDoOutput(true);
         connection .connect();
         InputStream input = connection .getInputStream();
         byte[] buffer = new byte[1024];
         int len = 0;
          while ((len = input .read(buffer)) > 0) {
           file .write(buffer, 0, len );
         }
        file .close();
  } catch (Exception e) {
          e.printStackTrace();
   }
}

Weitere Infos hier klicken http://androiddhina.blogspot.in/2015/09/how-to-download-pdf-from-url-in-android.html

InformationsquelleAutor der Antwort Dhina k