Frage Laden Sie eine Datei mit Android herunter und zeigen Sie den Fortschritt in einem ProgressDialog an


Ich versuche eine einfache Anwendung zu schreiben, die aktualisiert wird. Dazu brauche ich eine einfache Funktion, die eine Datei herunterladen kann und zeige den aktuellen Fortschritt in einem ProgressDialog. Ich weiß, wie man das macht ProgressDialog, aber ich bin mir nicht sicher, wie ich den aktuellen Fortschritt anzeigen und wie ich die Datei herunterladen kann.


914
2018-06-12 10:22


Ursprung


Antworten:


Es gibt viele Möglichkeiten, Dateien herunterzuladen. Folgend werde ich die häufigsten Wege posten; Es liegt an Ihnen zu entscheiden, welche Methode für Ihre App besser ist.

1. Verwenden AsyncTask und zeigen den Download-Fortschritt in einem Dialog an

Mit dieser Methode können Sie einige Hintergrundprozesse ausführen und die Benutzeroberfläche gleichzeitig aktualisieren (in diesem Fall aktualisieren wir eine Fortschrittsanzeige).

Dies ist ein Beispielcode:

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

Das AsyncTask wird so 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 obige Methode (doInBackground) läuft immer auf einem Hintergrundthread. Sie sollten dort keine UI-Aufgaben ausführen. Auf der anderen Seite, die onProgressUpdate und onPreExecute Führen Sie den UI-Thread aus, damit Sie die Fortschrittsanzeige ändern können:

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

Damit dies ausgeführt werden kann, benötigen Sie die WAKE_LOCK-Berechtigung.

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

2. Herunterladen vom Dienst

Die große Frage ist hier: Wie aktualisiere ich meine Aktivität von einem Dienst?. Im nächsten Beispiel verwenden wir zwei Klassen, die Ihnen vielleicht nicht bekannt sind: ResultReceiver und IntentService. ResultReceiver ist diejenige, die es uns erlaubt, unseren Thread von einem Dienst zu aktualisieren; IntentService ist eine Unterklasse von Service die einen Thread hervorbringt, um von dort aus Hintergrundarbeit zu leisten (du solltest wissen, dass a Service läuft eigentlich im selben Thread deiner App; wenn du dich ausstreckst Service, müssen Sie manuell neue Threads erzeugen, um CPU-Blockierungsoperationen auszuführen.

Der Download-Service kann folgendermaßen 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 Dienst Ihrem Manifest hinzu:

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

Und die Aktivität wird so 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 ist was ResultReceiver kommt zum 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 Sie die Groundy-Bibliothek

Grob ist eine Bibliothek, die im Grunde hilft, Code in einem Hintergrunddienst auszuführen, und basiert auf dem ResultReceiver Konzept oben gezeigt. Diese Bibliothek ist veraltet im Augenblick. So ist das ganze Code würde wie folgt aussehen:

Die Aktivität, in der Sie den Dialog 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;
            }
        }
    };
}

EIN GroundyTask Implementierung von Grob um die Datei herunterzuladen und den Fortschritt anzuzeigen:

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üg das einfach dem Manifest hinzu:

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

Es könnte nicht einfacher sein, denke ich. Nimm einfach das neueste Glas von Github und du bist bereit zu gehen. Denk daran, dass GrobDer Hauptzweck besteht darin, Aufrufe an externe REST-APIs in einem Hintergrunddienst zu tätigen und Ergebnisse auf einfache Weise an die Benutzeroberfläche zu senden. Wenn Sie so etwas in Ihrer App tun, könnte es wirklich nützlich sein.

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

3. Verwenden DownloadManager Klasse (GingerBread und neuer nur)

GingerBread brachte ein neues Feature, DownloadManager, die es Ihnen ermöglicht, Dateien einfach herunterzuladen und die harte Arbeit beim Umgang mit Threads, Streams usw. an das System zu delegieren.

Sehen wir uns zunächst eine Hilfsmethode an:

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

Der Name der Methode erklärt alles. Sobald Sie sicher sind DownloadManager verfügbar ist, können Sie Folgendes 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);

Der Download-Fortschritt wird in der Benachrichtigungsleiste angezeigt.

Abschließende Gedanken

Erste und zweite Methode sind nur die Spitze des Eisbergs. Es gibt viele Dinge, die Sie beachten müssen, wenn Sie möchten, dass Ihre App robust ist. Hier ist eine kurze Liste:

  • Sie müssen prüfen, ob dem Benutzer eine Internetverbindung zur Verfügung steht
  • Stellen Sie sicher, dass Sie die richtigen Berechtigungen haben (INTERNET und WRITE_EXTERNAL_STORAGE); ebenfalls ACCESS_NETWORK_STATE wenn Sie die Internetverfügbarkeit prüfen möchten.
  • Stellen Sie sicher, dass das Verzeichnis, in dem Sie Dateien herunterladen möchten, vorhanden ist und über Schreibberechtigungen verfügt.
  • Wenn der Download zu groß ist, möchten Sie möglicherweise eine Möglichkeit implementieren, den Download fortzusetzen, wenn vorherige Versuche fehlgeschlagen sind.
  • Benutzer werden dankbar sein, wenn Sie ihnen erlauben, den Download zu unterbrechen.

Sofern Sie keine detaillierte Kontrolle über den Download-Prozess benötigen, sollten Sie die Anwendung in Erwägung ziehen DownloadManager (3) weil es bereits die meisten der oben aufgeführten Punkte handhabt.

Bedenken Sie aber auch, dass sich Ihre Bedürfnisse ändern können. Beispielsweise, DownloadManager  Keine Antwort zwischenspeichern. Es wird blind die gleiche große Datei mehrmals herunterladen. Es gibt keine einfache Möglichkeit, es nachträglich zu beheben. Wo, wenn Sie mit einem Grundkurs beginnen HttpURLConnection (1, 2), dann brauchst du nur noch ein hinzufügen HttpResponseCache. Daher kann die anfängliche Anstrengung, die grundlegenden Standardwerkzeuge zu erlernen, eine gute Investition sein.

Diese Klasse wurde in API-Ebene 26 nicht weiter unterstützt. ProgressDialog ist ein Modal   Dialog, der verhindert, dass der Benutzer mit der App interagieren kann. Stattdessen   Um diese Klasse zu verwenden, sollten Sie einen Fortschrittsindikator wie verwenden   Fortschrittsbalken, der in die Benutzeroberfläche Ihrer App eingebettet werden kann. Alternative,   Sie können eine Benachrichtigung verwenden, um den Benutzer über den Fortschritt der Aufgabe zu informieren. Für mehr Details Verknüpfung


1726
2017-08-29 14:34



Vergiss nicht, deiner Manifest-Datei Berechtigungen hinzuzufügen, wenn du Sachen aus dem Internet herunterlädst!

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

98
2018-06-12 14:21



Ja, der obige Code funktioniert. Aber wenn Sie Ihre aktualisieren progressbar im onProgressUpdate von Asynctask  und drücken Sie die Zurück-Taste oder beenden Sie Ihre Aktivität AsyncTask verliert seine Spur mit Ihrer Benutzeroberfläche. Und wenn Sie zu Ihrer Aktivität zurückkehren, wird selbst wenn der Download im Hintergrund ausgeführt wird, keine Aktualisierung der Fortschrittsleiste angezeigt. Bald OnResume() versuche einen Thread wie zu starten runOnUIThread mit einer Timer-Task, die ur aktualisiert progressbar mit Werten, die von aktualisieren AsyncTask Hintergrund läuft.

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

Vergiss nicht zu Zerstören Der Thread, wenn deine Aktivität nicht sichtbar ist.

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

27
2018-05-20 23:29



Ich habe geändert AsyncTask Klasse für die Erstellung von progressDialog im gleichen Kontext. Ich denke, folgender Code wird mehr wiederverwendbar sein. (es kann von jeder Aktivität aufgerufen werden, übergeben Sie einfach Kontext, Zieldatei, Dialognachricht)

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

15
2018-05-07 15:56



Ich würde dir empfehlen, mein Projekt zu verwenden NetroidEs basiert auf Volley. Ich habe einige Funktionen wie Multi-Events Callback, Datei-Download-Management hinzugefügt. Dies könnte hilfreich sein.


14
2018-02-10 00:17



Vergessen Sie nicht, "/ sdcard ..." durch zu ersetzen neue Datei("/ mnt / sdcard / ...") Andernfalls erhalten Sie eine FileNotFoundException


8
2017-08-01 14:55



ich fand Dies Blog-Post sehr hilfreich, Es verwendet loopJ, um Datei herunterzuladen, es hat nur eine einfache Funktion, wird hilfreich sein, um einige neue Android-Kerle.


8
2017-09-19 13:41



Während ich begann, Android-Entwicklung zu lernen, hatte ich das gelernt ProgressDialog ist der Weg zu gehen. Dort ist der setProgress Methode von ProgressDialog Dies kann aufgerufen werden, um die Fortschrittsstufe beim Herunterladen der Datei zu aktualisieren.

Das Beste, was ich in vielen Apps gesehen habe, ist, dass sie die Attribute dieses Fortschrittsdialogs anpassen, um dem Fortschrittsdialog ein besseres Aussehen und Gefühl zu geben als die Aktienversion. Gut, um den Benutzer mit etwas Animation von wie Frosch, Elefant oder niedlichen Katzen / Welpen beschäftigt zu halten. Jede Animation im Fortschrittsdialog zieht Nutzer an und sie haben nicht das Gefühl, lange auf sich warten zu lassen.

Ich werde einen Blogbeitrag schreiben ProgressDialog und teile es bald hier.

Bearbeiten: Fortschrittsanzeige beim Herunterladen einer Datei in Android anzeigen


6
2017-07-02 17:11



Mein persönlicher Rat ist zu verwenden Fortschrittsdialog und baue vor der Ausführung auf oder initiiere bei OnPreExecute() , veröffentlichen Sie häufig den Fortschritt, wenn Sie die Fortschrittsanzeige für den horizontalen Verlauf des Fortschrittsdialogs verwenden. Der verbleibende Teil soll den Algorithmus von optimieren doInBackground.


5
2018-05-06 19:27



Verwenden Sie Android Query-Bibliothek, sehr cool in der Tat. Sie können es ändern, um zu verwenden ProgressDialog Wie Sie in anderen Beispielen sehen, zeigt dieser die Fortschrittsansicht von Ihrem Layout und versteckt es nach Abschluss.

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

5
2017-10-03 11:06



Berechtigungen

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

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

2
2017-08-28 18:34