delphi - Descargar archivo progresivamente con TIdHttp

download indy

Question

Quiero implementar un descargador de http simple usando TIdHttp (Indy10). Encontré dos tipos de ejemplos de código de internet. Lamentablemente, ninguno de ellos me satisface al 100%. Aquí está el código y quiero un consejo.

Variante 1

var
Buffer: TFileStream;
HttpClient: TIdHttp;
begin
Buffer := TFileStream.Create(''somefile.exe'', fmCreate or fmShareDenyWrite);
try
HttpClient := TIdHttp.Create(nil);
try
HttpClient.Get(''http://somewhere.com/somefile.exe'', Buffer); // wait until it is done
finally
HttpClient.Free;
end;
finally
Buffer.Free;
end;
end;

El código es compacto y muy fácil de entender. El problema es que asigna espacio en disco cuando comienza la descarga. Otro problema es que no podemos mostrar el progreso de la descarga en GUI directamente, a menos que el código se ejecute en un hilo de fondo (alternativamente, podemos enlazar el evento HttpClient.OnWork).

Variante 2:

const
RECV_BUFFER_SIZE = 32768;
var
HttpClient: TIdHttp;
FileSize: Int64;
Buffer: TMemoryStream;
begin
HttpClient := TIdHttp.Create(nil);
try
HttpClient.Head(''http://somewhere.com/somefile.exe'');
FileSize := HttpClient.Response.ContentLength;
Buffer := TMemoryStream.Create;
try
while Buffer.Size < FileSize do
begin
HttpClient.Request.ContentRangeStart := Buffer.Size;
if Buffer.Size + RECV_BUFFER_SIZE < FileSize then
HttpClient.Request.ContentRangeEnd := Buffer.Size + RECV_BUFFER_SIZE - 1
else
HttpClient.Request.ContentRangeEnd := FileSize;
HttpClient.Get(HttpClient.URL.URI, Buffer); // wait until it is done
Buffer.SaveToFile(''somefile.exe'');
end;
finally
Buffer.Free;
end;
finally
HttpClient.Free;
end;
end;

Primero consultamos el tamaño del archivo desde el servidor y luego descargamos el contenido del archivo en pedazos. El contenido del archivo recuperado se guardará en el disco cuando se reciban por completo. El problema potencial es que tenemos que enviar múltiples solicitudes GET al servidor. No estoy seguro de si algunos servidores (como megaupload) pueden limitar el número de solicitudes dentro de un período de tiempo determinado.

Mis expectativas

1. El descargador debe enviar solo una solicitud GET al servidor.
2. El espacio en disco no debe asignarse cuando comienza la descarga.

Cualquier sugerencia es apreciada.

Answer 1

La variante n. ° 1 es la más sencilla, y es la forma en que Indy debe usarse.

En cuanto al problema de asignación de disco, puede derivar una nueva clase de TFileStream y anular su método SetSize() para no hacer nada. TIdHTTP aún intentará asignar previamente el archivo cuando corresponda, pero en realidad no asignará ningún espacio de disco. Escribir en TFileStream hará crecer el archivo según sea necesario.

Con respecto al informe de estado, TIdHTTP tiene eventos OnWork... para ese propósito. El parámetro AWorkCountMax de OnWorkBegin será el tamaño real del archivo si se conoce (la respuesta no se fragmenta), o 0 si no se conoce. El parámetro AWorkCount del evento OnWork será el número acumulado de bytes que se han transferido hasta el momento. Si se conoce el tamaño del archivo, puede mostrar el porcentaje total simplemente dividiendo el AWorkCount por el AWorkCountMax y multiplicando por 100, de lo contrario solo muestre el valor de AWorkCount por sí mismo. Si desea visualizar la velocidad de la transferencia, puede calcularlo a partir de la diferencia de los valores de AWorkCount y los intervalos de tiempo entre múltiples eventos de OnWork .

Prueba esto:

type
TNoPresizeFileStream = class(TFileStream)
procedure
procedure SetSize(const NewSize: Int64); override;
end;
procedure TNoPresizeFileStream.SetSize(const NewSize: Int64);
begin
end;

.

type
TSomeClass = class(TSomething)
...
TotalBytes: In64;
LastWorkCount: Int64;
LastTicks: LongWord;
procedure Download;
procedure HttpWorkBegin(ASender: TObject; AWorkMode: TWorkMode; AWorkCountMax: Int64);
procedure HttpWork(ASender: TObject; AWorkMode: TWorkMode; AWorkCount: Int64);
procedure HttpWorkEnd(ASender: TObject; AWorkMode: TWorkMode);
...
end;
procedure TSomeClass.Download;
var
Buffer: TNoPresizeFileStream;
HttpClient: TIdHttp;
begin
Buffer := TNoPresizeFileStream.Create(''somefile.exe'', fmCreate or fmShareDenyWrite);
try
HttpClient := TIdHttp.Create(nil);
try
HttpClient.OnWorkBegin := HttpWorkBegin;
HttpClient.OnWork := HttpWork;
HttpClient.OnWorkEnd := HttpWorkEnd;
HttpClient.Get(''http://somewhere.com/somefile.exe'', Buffer); // wait until it is done
finally
HttpClient.Free;
end;
finally
Buffer.Free;
end;
end;
procedure TSomeClass.HttpWorkBegin(ASender: TObject; AWorkMode: TWorkMode; AWorkCountMax: Int64);
begin
if AWorkMode <> wmRead then Exit;
// initialize the status UI as needed...
//
// If TIdHTTP is running in the main thread, update your UI
// components directly as needed and then call the Form''s
// Update() method to perform a repaint, or Application.ProcessMessages()
// to process other UI operations, like button presses (for
// cancelling the download, for instance).
//
// If TIdHTTP is running in a worker thread, use the TIdNotify
// or TIdSync class to update the UI components as needed, and
// let the OS dispatch repaints and other messages normally...
TotalBytes := AWorkCountMax;
LastWorkCount := 0;
LastTicks := Ticks;
end;
procedure TSomeClass.HttpWork(ASender: TObject; AWorkMode: TWorkMode; AWorkCount: Int64);
var
PercentDone: Integer;
ElapsedMS: LongWord;
BytesTransferred: Int64;
BytesPerSec: Int64;
begin
if AWorkMode <> wmRead then Exit;
ElapsedMS := GetTickDiff(LastTicks, Ticks);
if ElapsedMS = 0 then ElapsedMS := 1; // avoid EDivByZero error
if TotalBytes > 0 then
PercentDone := (Double(AWorkCount) / TotalBytes) * 100.0;
else
PercentDone := 0.0;
BytesTransferred := AWorkCount - LastWorkCount;
// using just BytesTransferred and ElapsedMS, you can calculate
// all kinds of speed stats - b/kb/mb/gm per sec/min/hr/day ...
BytesPerSec := (Double(BytesTransferred) * 1000) / ElapsedMS;
// update the status UI as needed...
LastWorkCount := AWorkCount;
LastTicks := Ticks;
end;
procedure TSomeClass.HttpWorkEnd(ASender: TObject; AWorkMode: TWorkMode);
begin
if AWorkMode <> wmRead then Exit;
// finalize the status UI as needed...
end;

Answer 2

No olvides agregar esto para la Variante 2

 : Else HttpClient.Request.ContentRangeEnd := FileSize;

Reemplazar

 if Buffer.Size + RECV_BUFFER_SIZE < FileSize then
HttpClient.Request.ContentRangeEnd := Buffer.Size + RECV_BUFFER_SIZE - 1;

Por

 if Buffer.Size + RECV_BUFFER_SIZE < FileSize then
HttpClient.Request.ContentRangeEnd := Buffer.Size + RECV_BUFFER_SIZE - 1;
Else HttpClient.Request.ContentRangeEnd := FileSize;

Answer 3

Aquí hay un ejemplo que muestra cómo usar los componentes OnWork para mostrar una barra de progreso:

Descargue un archivo de Internet programáticamente con un evento Progress usando Delphi e Indy

No debe preocuparse por la asignación del disco. El espacio en disco que se asigna no está realmente escrito, por lo que no dañará sus discos. ¡Sea feliz de que esté asignado para que no sea posible que otro proceso reclame el espacio en disco y le permita quedarse sin espacio!