rtcconnprov.pas

Delphi快速开发Web Server

  begin
  Result:=FAddr;
  end;

function TRtcConnectionProvider.GetPort: string;
  begin
  Result:=FPort;
  end;

procedure TRtcConnectionProvider.SetAddr(val: string);
  begin
  FAddr:=val;
  end;

procedure TRtcConnectionProvider.SetError(Event: TRtcErrEvent);
  begin
  FError:=Event;
  end;

procedure TRtcConnectionProvider.SetPort(val: string);
  begin
  FPort:=val;
  end;

procedure TRtcConnectionProvider.SetTriggerAfterDestroy(Event: TrtcEvent);
  begin
  FOnAfterDestroy:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerBeforeCreate(Event: TrtcEvent);
  begin
  FOnBeforeCreate:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerConnect(Event: TrtcEvent);
  begin
  FOnConnect:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerConnecting(Event: TrtcEvent);
  begin
  FOnConnecting:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerDisconnecting(Event: TrtcEvent);
  begin
  FOnDisconnecting:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerDataReceived(Event: TrtcEvent);
  begin
  FOnDataReceived:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerDataLost(Event: TrtcEvent);
  begin
  FOnDataLost:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerDataSent(Event: TrtcEvent);
  begin
  FOnDataSent:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerDataOut(Event: TrtcEvent);
  begin
  FOnDataOut:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerDataIn(Event: TrtcEvent);
  begin
  FOnDataIn:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerLastWrite(Event: TrtcEvent);
  begin
  FOnLastWrite:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerDisconnect(Event: TrtcEvent);
  begin
  FOnDisconnect:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerException(Event: TrtcExceptEvent);
  begin
  FOnException:=Event;
  end;

procedure TRtcConnectionProvider.SetTriggerReadyToRelease(Event: TrtcEvent);
  begin
  FOnReadyToRelease:=Event;
  end;

procedure TRtcConnectionProvider.TriggerAfterDestroy;
  begin
  if assigned(FOnAfterDestroy) then
    FOnAfterDestroy;
  end;

procedure TRtcConnectionProvider.TriggerBeforeCreate;
  begin
  if assigned(FOnBeforeCreate) then
    FOnBeforeCreate;
  end;

procedure TRtcConnectionProvider.TriggerConnect;
  begin
  if assigned(FOnConnect) then
    FOnConnect;
  end;

procedure TRtcConnectionProvider.TriggerConnecting;
  begin
  if assigned(FOnConnecting) then
    FOnConnecting;
  end;

procedure TRtcConnectionProvider.TriggerDisconnecting;
  begin
  if assigned(FOnDisconnecting) then
    FOnDisconnecting;
  end;

procedure TRtcConnectionProvider.TriggerDataReceived;
  begin
  if assigned(FOnDataReceived) then
    FOnDataReceived;
  end;

procedure TRtcConnectionProvider.TriggerDataLost;
  begin
  if assigned(FOnDataLost) then
    FOnDataLost;
  end;

procedure TRtcConnectionProvider.TriggerDataSent;
  begin
  if assigned(FOnDataSent) then
    FOnDataSent;
  end;

procedure TRtcConnectionProvider.TriggerDataOut;
  begin
  if assigned(FOnDataOut) then
    FOnDataOut;
  end;

procedure TRtcConnectionProvider.TriggerDataIn;
  begin
  if assigned(FOnDataIn) then
    FOnDataIn;
  end;

procedure TRtcConnectionProvider.TriggerLastWrite;
  begin
  if assigned(FOnLastWrite) then
    FOnLastWrite;
  end;

procedure TRtcConnectionProvider.TriggerDisconnect;
  begin
  if assigned(FOnDisconnect) then
    FOnDisconnect;
  end;

procedure TRtcConnectionProvider.TriggerException(E: Exception);
  begin
  if assigned(FOnException) then
    FOnException(E);
  end;

procedure TRtcConnectionProvider.TriggerReadyToRelease;
  begin
  if assigned(FOnReadyToRelease) then
    FOnReadyToRelease;
  end;

function TRtcConnectionProvider.GetMultiThreaded: boolean;
  begin
  Result:=FMultiThreaded;
  end;

procedure TRtcConnectionProvider.SetMultiThreaded(val: boolean);
  begin
  FMultiThreaded:=val;
  end;

{ TRtcServerProvider }

procedure TRtcServerProvider.SetTriggerConnectionAccepting(Event: TrtcEvent);
  begin
  FOnConnectionAccepting:=Event;
  end;

procedure TRtcServerProvider.SetTriggerConnectionAccepted(Event: TrtcEvent);
  begin
  FOnConnectionAccepted:=Event;
  end;

procedure TRtcServerProvider.SetTriggerListenStart(Event: TrtcEvent);
  begin
  FOnListenStart:=Event;
  end;

procedure TRtcServerProvider.SetTriggerListenStop(Event: TrtcEvent);
  begin
  FOnListenStop:=Event;
  end;

procedure TRtcServerProvider.SetTriggerListenLost(Event: TrtcEvent);
  begin
  FOnListenLost:=Event;
  end;

procedure TRtcServerProvider.SetTriggerNewProvider(Event: TrtcProviderEvent);
  begin
  FOnNewProvider:=Event;
  end;

procedure TRtcServerProvider.TriggerConnectionAccepting;
  begin
  if assigned(FOnConnectionAccepting) then
    FOnConnectionAccepting;
  end;

procedure TRtcServerProvider.TriggerConnectionAccepted;
  begin
  if assigned(FOnConnectionAccepted) then
    FOnConnectionAccepted;
  end;

procedure TRtcServerProvider.TriggerListenStart;
  begin
  if assigned(FOnListenStart) then
    FOnListenStart;
  end;

procedure TRtcServerProvider.TriggerListenStop;
  begin
  if assigned(FOnListenStop) then
    FOnListenStop;
  end;

procedure TRtcServerProvider.TriggerListenLost;
  begin
  if assigned(FOnListenLost) then
    FOnListenLost;
  end;

procedure TRtcServerProvider.SetTriggerConnectionLost(Event: TrtcEvent);
  begin
  FOnConnectionLost:=Event;
  end;

procedure TRtcServerProvider.TriggerConnectionLost;
  begin
  if assigned(FOnConnectionLost) then
    FOnConnectionLost;
  end;

procedure TRtcServerProvider.TriggerListenError(E: Exception);
  begin
  if assigned(FOnListenError) then
    FOnListenError(E);
  end;

procedure TRtcServerProvider.SetTriggerListenError(Event: TrtcExceptEvent);
  begin
  FOnListenError:=Event;
  end;

procedure TRtcServerProvider.TriggerNewProvider(var Provider: TObject);
  begin
  if assigned(FOnNewProvider) then
    FOnNewProvider(Provider);
  end;

{ TRtcClientProvider }

procedure TRtcClientProvider.SetTriggerConnectError(Event: TrtcExceptEvent);
  begin
  FOnConnectError:=Event;
  end;

procedure TRtcClientProvider.SetTriggerConnectFail(Event: TrtcEvent);
  begin
  FOnConnectFail:=Event;
  end;

procedure TRtcClientProvider.SetTriggerConnectLost(Event: TrtcEvent);
  begin
  FOnConnectLost:=Event;
  end;

procedure TRtcClientProvider.SetTriggerConnectionOpening(Event: TrtcBoolEvent);
  begin
  FOnConnectionOpening:=Event;
  end;

procedure TRtcClientProvider.SetTriggerConnectionClosing(Event: TrtcEvent);
  begin
  FOnConnectionClosing:=Event;
  end;

procedure TRtcClientProvider.TriggerConnectionClosing;
  begin
  if assigned(FOnConnectionClosing) then
    FOnConnectionClosing;
  end;

procedure TRtcClientProvider.TriggerConnectError(E: Exception);
  begin
  if assigned(FOnConnectError) then
    FOnConnectError(E);
  end;

procedure TRtcClientProvider.TriggerConnectFail;
  begin
  if assigned(FOnConnectFail) then
    FOnConnectFail;
  end;

procedure TRtcClientProvider.TriggerConnectLost;
  begin
  if assigned(FOnConnectLost) then
    FOnConnectLost;
  end;

procedure TRtcClientProvider.TriggerConnectionOpening(Force: boolean);
  begin
  if assigned(FOnConnectionOpening) then
    FOnConnectionOpening(Force);
  end;

{ TRtcBasicClientProvider }

constructor TRtcBasicClientProvider.Create;
  begin
  inherited;
  FState:=conInactive;

  FLocalAddr:='0.0.0.0';
  FLocalPort:='';
  FPeerAddr:='0.0.0.0';
  FPeerPort:='';
  end;

procedure TRtcBasicClientProvider.Release;
  begin
  Destroy;
  end;

procedure TRtcBasicClientProvider.Check;
  begin
  // do nothing
  end;

function TRtcBasicClientProvider.GetParent: TRtcConnectionProvider;
  begin
  Result:=nil;
  end;

function TRtcBasicClientProvider.GetLocalAddr: string;
  begin
  Result:=FLocalAddr;
  end;

function TRtcBasicClientProvider.GetLocalPort: string;
  begin
  Result:=FLocalPort;
  end;

function TRtcBasicClientProvider.GetPeerAddr: string;
  begin
  Result:=FPeerAddr;
  end;

function TRtcBasicClientProvider.GetPeerPort: string;
  begin
  Result:=FPeerPort;
  end;

function TRtcBasicClientProvider.GetState: TRtcConnectionState;
  begin
  Enter;
  try
    Result:=FState;
  finally
    Leave;
    end;
  end;

procedure TRtcBasicClientProvider.SetLocalAddr(const Value: string);
  begin
  FLocalAddr:=Value;
  end;

procedure TRtcBasicClientProvider.SetLocalPort(const Value: string);
  begin
  FLocalPort:=Value;
  end;

procedure TRtcBasicClientProvider.SetPeerAddr(const Value: string);
  begin
  FPeerAddr:=Value;
  end;

procedure TRtcBasicClientProvider.SetPeerPort(const Value: string);
  begin
  FPeerPort:=Value;
  end;

procedure TRtcBasicClientProvider.SetState(value: TRtcConnectionState);
  begin
  Enter;
  try
    FState:=Value;
  finally
    Leave;
    end;
  end;

{ TRtcBasicServerProvider }

constructor TRtcBasicServerProvider.Create;
  begin
  inherited;
  FState:=conInactive;

  FLocalAddr:='0.0.0.0';
  FLocalPort:='';
  FPeerAddr:='0.0.0.0';
  FPeerPort:='';
  end;

procedure TRtcBasicServerProvider.Release;
  begin
  Destroy;
  end;

procedure TRtcBasicServerProvider.Check;
  begin
  // do nothing
  end;

function TRtcBasicServerProvider.GetLocalAddr: string;
  begin
  Result:=FLocalAddr;
  end;

function TRtcBasicServerProvider.GetLocalPort: string;
  begin
  Result:=FLocalPort;
  end;

function TRtcBasicServerProvider.GetPeerAddr: string;
  begin
  Result:=FPeerAddr;
  end;

function TRtcBasicServerProvider.GetPeerPort: string;
  begin
  Result:=FPeerPort;
  end;

function TRtcBasicServerProvider.GetState: TRtcConnectionState;
  begin
  Result:=FState;
  end;

procedure TRtcBasicServerProvider.SetLocalAddr(const Value: string);
  begin
  FLocalAddr:=Value;
  end;

procedure TRtcBasicServerProvider.SetLocalPort(const Value: string);
  begin
  FLocalPort:=Value;
  end;

procedure TRtcBasicServerProvider.SetPeerAddr(const Value: string);
  begin
  FPeerAddr:=Value;
  end;

procedure TRtcBasicServerProvider.SetPeerPort(const Value: string);
  begin
  FPeerPort:=Value;
  end;

procedure TRtcBasicServerProvider.SetState(value: TRtcConnectionState);
  begin
  FState:=Value;
  end;

const
  MaxConnID:longint=2000000000;

var
  GlobalConnID:longint=1;
  CS:TRtcCritSec;

function GetNextConnID:TRtcConnID;
  begin
  CS.Enter;
  try
    if GlobalConnID>=MaxConnID then
      GlobalConnID:=1
    else
      Inc(GlobalConnID);
    Result:=GlobalConnID;
  finally
    CS.Leave;
    end;
  end;

initialization
CS:=TRtcCritSec.Create;
finalization
Garbage(CS);
end.