Medición de la velocidad de descarga Java

Question

Estoy trabajando en descargar un archivo en un software, esto es lo que obtuve, descarga con éxito, y también puedo obtener progreso, pero aún me queda 1 cosa que no sé cómo hacer. Medir la velocidad de descarga. Apreciaría tu ayuda. Gracias. Este es el código de método de descarga actual

    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 misma manera que medirías cualquier cosa.

System.nanoTime() Devuelve un Long Puedes usar para medir cuánto tiempo lleva algo:

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

Ahora tiene la cantidad de nanosegundos que se necesitó para leer X bytes. Haz los cálculos y tendrás tu tasa de descarga.

Lo más probable es que esté buscando bytes por segundo. Realice un seguimiento del número total de bytes que ha leído, verificando si ha transcurrido un segundo. Una vez que un segundo ha pasado, descubra la tasa en función de cuántos bytes ha leído en ese tiempo. Restablecer el total, repetir.

Answer 2

Aquí está mi implementación

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

Puedo darte una idea general. Comience un temporizador al comienzo de la descarga. Ahora, multiplique el (percentage downloaded) por el download size, y divídalo por el time elapsed. Eso te da tiempo de descarga promedio. ¡Espero que te ponga en el camino correcto!

Puedes usar System.nanoTime(); Según lo sugerido por Brian.

Poner long startTime = System.nanoTime(); Fuera de tu bucle mientras. y

long estimatedTime = System.nanoTime() - startTime; Te dará el tiempo transcurrido dentro de tu bucle.