CODEWITHSUNDEEP
delphiamazon-web-servicesamazon-s3
noen
noen

Reputation: 33

Can I monitor the progress of an S3 download using the Cloud.AmazonAPI?

Is there a routine available in TAmazonStorageService to monitor the progress of a download of an object?

I read that it is possible using the AWS SDK hooking the WriteObjectProgressEvent, but I couldn't find anything related in the documentation of Embarcadero's AmazonAPI.

Upvotes: 3

Views: 1073

Answers (1)

EugeneK
EugeneK

Reputation: 2224

I don't think this is currently implemented in Delphi. What you can do is create a stream wrapper that will notify about progress of writing to it. So for example you can write following to monitor progress via ProgressBar

procedure TForm1.OnProgress(const ACount: Int64);
begin
  ProgressBar1.Value := ProgressBar1.Value + ACount;
  Application.ProcessMessages;
end;

procedure TForm1.DownloadFile(const ABucketName: string; const AFileName: TFileName);
var
  ResponseInfo: TCloudResponseInfo;
  StorageService: TAmazonStorageService;
  ObjectName: string;
  FileStream: TStream;
  ProgressStream: TProgressStream;
  MetaData: TStrings;
  Properties: TStrings;
  ContentLength: Int64;
begin
  StorageService := TAmazonStorageService.Create(AmazonConnectionInfo1);
  ResponseInfo := TCloudResponseInfo.Create;
  try
    ObjectName := ExtractFileName(AFileName);
    if StorageService.GetObjectProperties(ABucketName, ObjectName, Properties, MetaData) then
    begin
      try
        ContentLength := StrToInt(Properties.Values['Content-Length']);
      finally
        MetaData.Free;
        Properties.Free;
      end;
      FileStream := TFileStream.Create(AFileName, fmCreate or fmOpenWrite);
      ProgressStream := TProgressStream.Create(FileStream);
      ProgressStream.OnProgress := OnProgress;
      ProgressBar1.Max := ContentLength;
      ProgressBar1.Value := 0;
      try
        StorageService.GetObject(CBucketName, ObjectName, ProgressStream);
      finally
        ProgressStream.Free;
        FileStream.Free;
      end;
    end;
  finally
    StorageService.Free;
    ResponseInfo.Free;
  end;
end;

and TProgressStream implemented as following

type
  TOnProgressEvent = procedure(const ACount: Int64) of object;
  TProgressStream = class(TStream)
  strict private
    FStream: TStream;
  protected
    function GetSize: Int64; override;
    procedure SetSize(NewSize: Longint); overload; override;
    procedure SetSize(const NewSize: Int64); overload; override;
  public
    OnProgress: TOnProgressEvent;
    function Read(var Buffer; Count: Longint): Longint; overload; override;
    function Write(const Buffer; Count: Longint): Longint; overload; override;
    function Read(Buffer: TBytes; Offset, Count: Longint): Longint; overload; override;
    function Write(const Buffer: TBytes; Offset, Count: Longint): Longint; overload; override;
    function Seek(Offset: Longint; Origin: Word): Longint; overload; override;
    function Seek(const Offset: Int64; Origin: TSeekOrigin): Int64; overload; override;
    constructor Create(const AStream: TStream);
  end;

constructor TProgressStream.Create(const AStream: TStream);
begin
  FStream := AStream;
end;

function TProgressStream.GetSize: Int64;
begin
  Result := FStream.Size;
end;

procedure TProgressStream.SetSize(NewSize: Longint);
begin
  FStream.Size := NewSize;
end;

procedure TProgressStream.SetSize(const NewSize: Int64);
begin
  FStream.Size := NewSize;
end;

function TProgressStream.Read(var Buffer; Count: Longint): Longint;
begin
  Result := FStream.Read(Buffer, Count);
end;

function TProgressStream.Write(const Buffer; Count: Longint): Longint;
begin
  Result := FStream.Write(Buffer, Count);
end;

function TProgressStream.Read(Buffer: TBytes; Offset, Count: Longint): Longint;
begin
  Result := FStream.Read(Buffer, Offset, Count);
end;

function TProgressStream.Write(const Buffer: TBytes; Offset, Count: Longint): Longint;
begin
  Result := FStream.Write(Buffer, Offset, Count);
  if Assigned(OnProgress) then
  begin
    OnProgress(Count);
  end;
end;

function TProgressStream.Seek(Offset: Longint; Origin: Word): Longint;
begin
  Result := FStream.Seek(Offset, Origin);
end;

function TProgressStream.Seek(const Offset: Int64; Origin: TSeekOrigin): Int64;
begin
  Result := FStream.Seek(Offset, Origin);
end;

Upvotes: 4

Related Questions