unit uROIndySuperHttpChannel;

{----------------------------------------------------------------------------}
{ RemObjects SDK Library - Indy Components                                   }
{                                                                            }
{ compiler: Delphi 5 and up, Kylix 2 and up                                  }
{ platform: Win32, Linux                                                     }
{                                                                            }
{ (c)opyright RemObjects Software. all rights reserved.                      }
{                                                                            }
{ Using this code requires a valid license of the RemObjects SDK             }
{ which can be obtained at http://www.remobjects.com.                        }
{----------------------------------------------------------------------------}

{$I RemObjects.inc}

interface

uses
  {$IFDEF REMOBJECTS_TRIAL}uROTrial,{$ENDIF}
  Classes, SysUtils, uROClient, uROClientIntf, uROAsync, uROClasses, SyncObjs,
  {$IFDEF RemObjects_UseEncryption} uRoEncryption, {$ENDIF}uROThreadPool,
  uROIndyTCPChannel, IdTCPCLient, IdHTTP, uROBaseSuperHttpChannel;

type
  TROIndySuperHttpChannel = class(TROBaseSuperHttpChannel)
  private
    fClientWait,
    fClientRequest: TIdHTTP;
    fTargetUrl: String;
  protected
    procedure CancelRequest(aWaitingThread: Boolean); override;
    procedure DispatchHttpRequest(aWaitingThread: Boolean;
      aRequest: TDynByteArray; out aResponse: TDynByteArray); override;
  public
    constructor Create(aOwner: TCOmponent); override;
    destructor Destroy; override;
    {$IFDEF FPC}
    property SessionId;
    {$ENDIF}
  published
    {$IFNDEF FPC}
    property SessionId;
    {$ENDIF}    
    property Active;
    property MaxPackageSize;
    property TargetUrl: String read fTargetUrl write fTargetUrl;
    property ClientWait: TIdHTTP read fClientWait;
    property ClientRequest: TIdHTTP read fClientRequest;
    property RequestTimeout;
    property ConnectTimeout;
    property HttpRequestTimeout;
  end;

implementation
uses
  uRORes;

{ TROIndySuperHttpChannel }

procedure TROIndySuperHttpChannel.CancelRequest(aWaitingThread: Boolean);
var
  lSock: TIdHTTP;
begin
  try
    if aWaitingThread then lSock := fClientWait else lSock := fClientRequest;
      {$IFDEF RemOBjects_INDY8}
    lSock.Binding.CloseSocket();
    {$ELSE}
      {$IFDEF RemObjects_INDY10}
      if assigned(lSock.Socket) and (lSock.Socket.Connected) then
        lSock.Socket.Close;
      {$ELSE}
      lSock.DisconnectSocket;
      {$ENDIF}
    {$ENDIF}
  except
    // indy will release an exception when closing
  end;
end;

constructor TROIndySuperHttpChannel.Create(aOwner: TCOmponent);
begin
  inherited Create(aOwner);
  fClientWait := TIdHTTP.Create(nil);
  fClientWait.Request.UserAgent := str_ProductName;

  fClientRequest := TIdHTTP.Create(nil);
  fClientRequest.Request.UserAgent := str_ProductName;

  {$IFDEF DELPHI6UP}
  fClientWait.SetSubComponent(TRUE);
  {$ENDIF}
    {$IFDEF DELPHI6UP}
  fClientRequest.SetSubComponent(TRUE);
  {$ENDIF}
end;

destructor TROIndySuperHttpChannel.Destroy;
begin
  Active := false;
  fClientWait.Free;
  fClientRequest.Free;
  inherited Destroy;
end;

procedure TROIndySuperHttpChannel.DispatchHttpRequest(
  aWaitingThread: Boolean; aRequest: TDynByteArray;
  out aResponse: TDynByteArray);
var
  lClient: TIdHTTP;
  lRequest, lResponse: TMemoryStream;
begin
  if aWaitingThread then lClient := fClientWait else lClient := fClientRequest;
  lRequest:= TMemoryStream.Create;
  lResponse := TMemoryStream.Create;
  try
    lRequest.Write(aRequest[0], Length(aRequest));
    lRequest.Position := 0;
    {$IFNDEF REMOBJECTS_INDY8}
    lClient.ReadTimeout := HttpRequestTimeout;
    {$ENDIF}
    {$IFDEF RemObjects_INDY10}
    lClient.ConnectTimeout := ConnectTimeout;
    {$ENDIF}
    lClient.Post(fTargetUrl, lRequest, lResponse);
    SetLength(aResponse, lResponse.Size);
    lResponse.Position := 0;
    lResponse.Read(aResponse[0], Length(aResponse));
  finally
    lRequest.Free;
    lResponse.Free;
  end;
end;

end.