Mesure de la vitesse de téléchargement Java

Question

Je travaille sur le téléchargement d'un fichier sur un logiciel, ce que je suis arrivé, il sucesfully télécharger, et aussi je peux obtenir des progrès, mais encore 1 chose qui reste que je ne sais pas comment faire. Mesurer la vitesse de téléchargement. J'apprécierais votre aide. Merci. Ceci est le code actuel de la méthode de téléchargement

    public void run()
    {
        OutputStream out = null;
        URLConnection conn = null;
        InputStream in = null;
        try
        {
            URL url1 = new URL(url);
            out = new BufferedOutputStream(
            new FileOutputStream(sysDir+"\\"+where));
            conn = url1.openConnection();
            in = conn.getInputStream();
            byte[] buffer = new byte[1024];
            int numRead;
            long numWritten = 0;
            double progress1;
            while ((numRead = in.read(buffer)) != -1)
            {
                out.write(buffer, 0, numRead);
                numWritten += numRead;
                this.speed= (int) (((double)
                buffer.length)/8);
                progress1 = (double) numWritten;
                this.progress=(int) progress1;
            }
        }
        catch (Exception ex)
        {
            echo("Unknown Error: " + ex);
        }
        finally
        {
            try
            {
                if (in != null)
                {
                    in.close();
                }
                if (out != null)
                {
                    out.close();
                }
            }
            catch (IOException ex)
            {
                echo("Unknown Error: " + ex);
            }
        }
    }

Answer 1

De la même façon vous mesurer quoi que ce soit.

System.nanoTime() retourne un Long vous pouvez utiliser pour mesurer combien de temps quelque chose prend:

Long start = System.nanoTime();
// do your read
Long end = System.nanoTime();

Vous avez maintenant le nombre de nanosecondes qu'il a fallu pour lire des octets X. Faites le calcul et vous avez votre taux de téléchargement.

Plus que probable que vous êtes à la recherche d'octets par seconde. Gardez une trace du nombre total d'octets que vous avez lu, vérifier si une seconde s'est écoulé. Une fois une seconde s'est passé figure le taux basé sur le nombre d'octets que vous avez lu dans ce laps de temps. Réinitialiser le total, répéter.

Answer 2

Voici mon implémentation

while (mStatus == DownloadStatus.DOWNLOADING) {
            /*
             * Size buffer according to how much of the file is left to
             * download.
             */
            byte buffer[];
            // handled resume case.
            if ((mSize < mDownloaded ? mSize : mSize - mDownloaded <= 0 ? mSize : mSize - mDownloaded) > MAX_BUFFER_SIZE) {
                buffer = new byte[MAX_BUFFER_SIZE];
            } else {
                buffer = new byte[(int) (mSize - mDownloaded)];
            }

            // Read from server into buffer.
            int read = stream.read(buffer);
            if (read == -1)
                break;// EOF, break while loop

            // Write buffer to file.
            file.write(buffer, 0, read);
            mDownloaded += read;
            double speedInKBps = 0.0D;
            try {
                long timeInSecs = (System.currentTimeMillis() - startTime) / 1000; //converting millis to seconds as 1000m in 1 second
                speedInKBps = (mDownloaded / timeInSecs) / 1024D;
            } catch (ArithmeticException ae) {

            }
            this.mListener.publishProgress(this.getProgress(), this.getTotalSize(), speedInKBps);
        }

Answer 3

Je peux vous donner une idée générale. Démarrer une minuterie au début du téléchargement. Maintenant, multipliez le (percentage downloaded) par le download size, et le diviser par le time elapsed. Cela vous donne le temps moyen de téléchargement. J'espère que vous êtes sur la bonne voie!

Vous pouvez utiliser System.nanoTime(); comme suggéré par Brian.

Mettre long startTime = System.nanoTime(); en dehors de votre boucle while. et

long estimatedTime = System.nanoTime() - startTime; vous donnera le temps écoulé au sein de votre boucle.