studio - Android DownloadManager Progress

download manager for android apk

Question

Estoy desarrollando una aplicación donde los usuarios pueden descargar diferentes paquetes de contenido. Para el proceso de descarga, estoy usando la clase DownloadManager. Eso está funcionando bien hasta ahora.

Mi pregunta es cómo puedo obtener el progreso actual de una descarga en ejecución que se inició con DownloadManager. Sé que existe la notificación de descarga Buildin y así sucesivamente. Pero para mí es necesario que obtenga el progreso de la descarga en ejecución, así puedo usarlo para mostrar el progreso en una barra de progreso personalizada en mi aplicación. Hasta ahora no he podido recuperar el progreso.

¿Es posible o simplemente estoy ciego y no puedo encontrar la solución?

Espero que alguien pueda ayudarme ...

Answer 1

Estoy buscando una mejor manera de hacer esto también, pero hasta ahora estoy planeando simplemente sondear para el progreso cada 1 segundo más o menos.

DownloadManager mgr = (DownloadManager) context.getSystemService(Context.DOWNLOAD_SERVICE);
long id = mgr.enqueue(request);

DownloadManager.Query q = new DownloadManager.Query();
q.setFilterById(id);
Cursor cursor = mgr.query(q);
cursor.moveToFirst();
int bytes_downloaded = cursor.getInt(cursor.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
cursor.close();

Editar:

Un FileObserver puede ayudar con esto. Este es el esqueleto de uno que he reunido para ayudar a mantener un registro de los archivos que nuestra aplicación ha descargado. Comience en una actividad o servicio onStart y deténgalo en onStop . Combinado con una sincronización manual del estado de cosas durante onStart , esto puede darle una onStart bastante completa de lo que está sucediendo.

Para el progreso en particular, mirar los eventos OPEN / CLOSE_WRITE puede ayudarlo a decidir cuándo iniciar / detener el sondeo de DownloadManager para las actualizaciones.

public class DownloadsObserver extends FileObserver {

    public static final String LOG_TAG = DownloadsObserver.class.getSimpleName();

    private static final int flags =
            FileObserver.CLOSE_WRITE
            | FileObserver.OPEN
            | FileObserver.MODIFY
            | FileObserver.DELETE
            | FileObserver.MOVED_FROM;
    // Received three of these after the delete event while deleting a video through a separate file manager app:
    // 01-16 15:52:27.627: D/APP(4316): DownloadsObserver: onEvent(1073741856, null)

    public DownloadsObserver(String path) {
        super(path, flags);
    }

    @Override
    public void onEvent(int event, String path) {
        Log.d(LOG_TAG, "onEvent(" + event + ", " + path + ")");

        if (path == null) {
            return;
        }

        switch (event) {
        case FileObserver.CLOSE_WRITE:
            // Download complete, or paused when wifi is disconnected. Possibly reported more than once in a row.
            // Useful for noticing when a download has been paused. For completions, register a receiver for 
            // DownloadManager.ACTION_DOWNLOAD_COMPLETE.
            break;
        case FileObserver.OPEN:
            // Called for both read and write modes.
            // Useful for noticing a download has been started or resumed.
            break;
        case FileObserver.DELETE:
        case FileObserver.MOVED_FROM:
            // These might come in handy for obvious reasons.
            break;
        case FileObserver.MODIFY:
            // Called very frequently while a download is ongoing (~1 per ms).
            // This could be used to trigger a progress update, but that should probably be done less often than this.
            break;
        }
    }
}

El uso sería algo como esto:

public class MyActivity extends Activity {

    private FileObserver fileObserver = new DownloadsObserver(
            getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS).getAbsolutePath());

    @Override
    protected void onStart() {
        super.onStart();
        fileObserver.startWatching();
        syncUpDatabaseWithFileSystem();
    }

    @Override
    protected void onStop() {
        fileObserver.stopWatching();
        super.onStop();
    }
}

Answer 2

Resulta que la implementación de FileObserver en Marshmallow tiene un error. Como resultado, FileObserver no informará ninguna modificación de un archivo descargado por el administrador de descargas. (Las versiones anteriores de Android no tienen este problema, funciona bien en KitKat). Source

Para mí, el siguiente código (basado en esta respuesta ) funciona bien. Yo sondeé cada segundo. He intentado reducir a la mitad ese intervalo, pero sin ningún efecto visible.

private static final int PROGRESS_DELAY = 1000;
Handler handler = new Handler();
private boolean isProgressCheckerRunning = false;

// when the first download starts
startProgressChecker();

// when the last download finishes or the Activity is destroyed
stopProgressChecker();

/**
 * Checks download progress.
 */
private void checkProgress() {
    DownloadManager.Query query = new DownloadManager.Query();
    query.setFilterByStatus(~(DownloadManager.STATUS_FAILED | DownloadManager.STATUS_SUCCESSFUL));
    Cursor cursor = downloadManager.query(query);
    if (!cursor.moveToFirst()) {
        cursor.close();
        return;
    }
    do {
        long reference = cursor.getLong(cursor.getColumnIndex(DownloadManager.COLUMN_ID));
        long progress = ursor.getLong(cursor.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR));
        // do whatever you need with the progress
    } while (cursor.moveToNext());
    cursor.close();
}

/**
 * Starts watching download progress.
 * 
 * This method is safe to call multiple times. Starting an already running progress checker is a no-op.
 */
private void startProgressChecker() {
    if (!isProgressCheckerRunning) {
        progressChecker.run();
    isProgressCheckerRunning = true;
    }
}

/**
 * Stops watching download progress.
 */
private void stopProgressChecker() {
    handler.removeCallbacks(progressChecker);
    isProgressCheckerRunning = false;
}

/**
 * Checks download progress and updates status, then re-schedules itself.
 */
private Runnable progressChecker = new Runnable() {
    @Override
    public void run() {
        try {
            checkProgress();
            manager.refresh();
        } finally {
            handler.postDelayed(progressChecker, PROGRESS_DELAY);
        }
    }
};