unit uCEFServerComponent;
{$IFDEF FPC}
{$MODE OBJFPC}{$H+}
{$ENDIF}
{$I cef.inc}
{$IFNDEF TARGET_64BITS}{$ALIGN ON}{$ENDIF}
{$MINENUMSIZE 4}
interface
uses
{$IFDEF DELPHI16_UP}
{$IFDEF MSWINDOWS}WinApi.Windows, WinApi.Messages, WinApi.ActiveX,{$ENDIF}
System.Classes, System.Math,
{$ELSE}
{$IFDEF MSWINDOWS}Windows, ActiveX,{$ENDIF} Classes, Math,
{$IFDEF FPC}
LCLProc, LCLType, LCLIntf, LResources, LMessages, InterfaceBase,
{$ELSE}
Messages,
{$ENDIF}
{$ENDIF}
uCEFTypes, uCEFInterfaces, uCEFConstants, uCEFServer, uCEFServerEvents, uCEFServerHandler;
const
DEFAULT_CEFSERVER_ADDRESS = '127.0.0.1';
DEFAULT_CEFSERVER_PORT = 8099;
DEFAULT_CEFSERVER_BACKLOG = 10;
type
{$IFNDEF FPC}{$IFDEF DELPHI16_UP}[ComponentPlatformsAttribute(pfidWindows or pfidOSX or pfidLinux)]{$ENDIF}{$ENDIF}
/// <summary>
/// The TCEFServerComponent class puts together all CEF server procedures, functions, properties and events in one place.
/// </summary>
TCEFServerComponent = class(TComponent, IServerEvents)
protected
FHandler : ICefServerHandler;
FServer : ICefServer;
FInitialized : boolean;
// IServerEvents
FOnServerCreated : TOnServerCreated;
FOnServerDestroyed : TOnServerDestroyed;
FOnClientConnected : TOnClientConnected;
FOnClientDisconnected : TOnClientDisconnected;
FOnHttpRequest : TOnHttpRequest;
FOnWebSocketRequest : TOnWebSocketRequest;
FOnWebSocketConnected : TOnWebSocketConnected;
FOnWebSocketMessage : TOnWebSocketMessage;
function GetInitialized : boolean;
function GetIsRunning : boolean;
function GetAddress : ustring;
function GetHasConnection : boolean;
// IServerEvents
procedure doOnServerCreated(const server: ICefServer); virtual;
procedure doOnServerDestroyed(const server: ICefServer); virtual;
procedure doOnClientConnected(const server: ICefServer; connection_id: Integer); virtual;
procedure doOnClientDisconnected(const server: ICefServer; connection_id: Integer); virtual;
procedure doOnHttpRequest(const server: ICefServer; connection_id: Integer; const client_address: ustring; const request: ICefRequest); virtual;
procedure doOnWebSocketRequest(const server: ICefServer; connection_id: Integer; const client_address: ustring; const request: ICefRequest; const callback: ICefCallback); virtual;
procedure doOnWebSocketConnected(const server: ICefServer; connection_id: Integer); virtual;
procedure doOnWebSocketMessage(const server: ICefServer; connection_id: Integer; const data: Pointer; data_size: NativeUInt); virtual;
procedure InitializeEvents;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
/// <summary>
/// Create a new server that binds to |address| and |port|. |address| must be a
/// valid IPv4 or IPv6 address (e.g. 127.0.0.1 or ::1) and |port| must be a port
/// number outside of the reserved range (e.g. between 1025 and 65535 on most
/// platforms). |backlog| is the maximum number of pending connections. A new
/// thread will be created for each CreateServer call (the "dedicated server
/// thread"). It is therefore recommended to use a different
/// ICefServerHandler instance for each CreateServer call to avoid thread
/// safety issues in the ICefServerHandler implementation. The
/// ICefServerHandler.OnServerCreated function will be called on the
/// dedicated server thread to report success or failure. See
/// ICefServerHandler.OnServerCreated documentation for a description of
/// server lifespan.
/// </summary>
procedure CreateServer(const address : ustring = DEFAULT_CEFSERVER_ADDRESS; port : uint16 = DEFAULT_CEFSERVER_PORT; backlog : Integer = DEFAULT_CEFSERVER_BACKLOG);
/// <summary>
/// Stop the server and shut down the dedicated server thread. See
/// ICefServerHandler.OnServerCreated documentation for a description of
/// server lifespan.
/// </summary>
procedure Shutdown;
/// <summary>
/// Returns true (1) if |connection_id| represents a valid connection. This
/// function must be called on the dedicated server thread.
/// </summary>
function IsValidConnection(connection_id: Integer) : boolean;
/// <summary>
/// Send an HTTP 200 "OK" response to the connection identified by
/// |connection_id|. |content_type| is the response content type (e.g.
/// "text/html"), |data| is the response content, and |data_size| is the size
/// of |data| in bytes. The contents of |data| will be copied. The connection
/// will be closed automatically after the response is sent.
/// </summary>
procedure SendHttp200response(connection_id: Integer; const content_type: ustring; const data: Pointer; data_size: NativeUInt);
/// <summary>
/// Send an HTTP 404 "Not Found" response to the connection identified by
/// |connection_id|. The connection will be closed automatically after the
/// response is sent.
/// </summary>
procedure SendHttp404response(connection_id: Integer);
/// <summary>
/// Send an HTTP 500 "Internal Server Error" response to the connection
/// identified by |connection_id|. |error_message| is the associated error
/// message. The connection will be closed automatically after the response is
/// sent.
/// </summary>
procedure SendHttp500response(connection_id: Integer; const error_message: ustring);
/// <summary>
/// Send a custom HTTP response to the connection identified by
/// |connection_id|. |response_code| is the HTTP response code sent in the
/// status line (e.g. 200), |content_type| is the response content type sent
/// as the "Content-Type" header (e.g. "text/html"), |content_length| is the
/// expected content length, and |extra_headers| is the map of extra response
/// headers. If |content_length| is >= 0 then the "Content-Length" header will
/// be sent. If |content_length| is 0 then no content is expected and the
/// connection will be closed automatically after the response is sent. If
/// |content_length| is < 0 then no "Content-Length" header will be sent and
/// the client will continue reading until the connection is closed. Use the
/// SendRawData function to send the content, if applicable, and call
/// CloseConnection after all content has been sent.
/// </summary>
procedure SendHttpResponse(connection_id, response_code: Integer; const content_type: ustring; content_length: int64; const extra_headers: ICefStringMultimap);
/// <summary>
/// Send raw data directly to the connection identified by |connection_id|.
/// |data| is the raw data and |data_size| is the size of |data| in bytes. The
/// contents of |data| will be copied. No validation of |data| is performed
/// internally so the client should be careful to send the amount indicated by
/// the "Content-Length" header, if specified. See SendHttpResponse
/// documentation for intended usage.
/// </summary>
procedure SendRawData(connection_id: Integer; const data: Pointer; data_size: NativeUInt);
/// <summary>
/// Close the connection identified by |connection_id|. See SendHttpResponse
/// documentation for intended usage.
/// </summary>
procedure CloseConnection(connection_id: Integer);
/// <summary>
/// Send a WebSocket message to the connection identified by |connection_id|.
/// |data| is the response content and |data_size| is the size of |data| in
/// bytes. The contents of |data| will be copied. See
/// ICefServerHandler.OnWebSocketRequest documentation for intended usage.
/// </summary>
procedure SendWebSocketMessage(connection_id: Integer; const data: Pointer; data_size: NativeUInt);
/// <summary>
/// Returns true when the server and the handler are initialized.
/// </summary>
property Initialized : boolean read GetInitialized;
/// <summary>
/// Returns true (1) if the server is currently running and accepting incoming
/// connections. See ICefServerHandler.OnServerCreated documentation for a
/// description of server lifespan. This function must be called on the
/// dedicated server thread.
/// </summary>
property IsRunning : boolean read GetIsRunning;
/// <summary>
/// Returns the server address including the port number.
/// </summary>
property Address : ustring read GetAddress;
/// <summary>
/// Returns true (1) if the server currently has a connection. This function
/// must be called on the dedicated server thread.
/// </summary>
property HasConnection : boolean read GetHasConnection;
published
/// <summary>
/// Called when |server| is created. If the server was started successfully
/// then ICefServer.IsRunning will return true (1). The server will
/// continue running until ICefServerShutdown is called, after which time
/// OnServerDestroyed will be called. If the server failed to start then
/// OnServerDestroyed will be called immediately after this function returns.
/// </summary>
/// <remarks>
/// <para>This event will be called on the CEF server thread.</para>
/// <para><see href="https://bitbucket.org/chromiumembedded/cef/src/master/include/capi/cef_server_capi.h">CEF source file: /include/capi/cef_server_capi.h (cef_server_handler_t)</see></para>
/// </remarks>
property OnServerCreated : TOnServerCreated read FOnServerCreated write FOnServerCreated;
/// <summary>
/// Called when |server| is destroyed. The server thread will be stopped after
/// this function returns. The client should release any references to
/// |server| when this function is called. See OnServerCreated documentation
/// for a description of server lifespan.
/// </summary>
/// <remarks>
/// <para>This event will be called on the CEF server thread.</para>
/// <para><see href="https://bitbucket.org/chromiumembedded/cef/src/master/include/capi/cef_server_capi.h">CEF source file: /include/capi/cef_server_capi.h (cef_server_handler_t)</see></para>
/// </remarks>
property OnServerDestroyed : TOnServerDestroyed read FOnServerDestroyed write FOnServerDestroyed;
/// <summary>
/// Called when a client connects to |server|. |connection_id| uniquely
/// identifies the connection. Each call to this function will have a matching
/// call to OnClientDisconnected.
/// </summary>
/// <remarks>
/// <para>This event will be called on the CEF server thread.</para>
/// <para><see href="https://bitbucket.org/chromiumembedded/cef/src/master/include/capi/cef_server_capi.h">CEF source file: /include/capi/cef_server_capi.h (cef_server_handler_t)</see></para>
/// </remarks>
property OnClientConnected : TOnClientConnected read FOnClientConnected write FOnClientConnected;
/// <summary>
/// Called when a client disconnects from |server|. |connection_id| uniquely
/// identifies the connection. The client should release any data associated
/// with |connection_id| when this function is called and |connection_id|
/// should no longer be passed to ICefServer functions. Disconnects can
/// originate from either the client or the server. For example, the server
/// will disconnect automatically after a ICefServer.SendHttpXXXResponse
/// function is called.
/// </summary>
/// <remarks>
/// <para>This event will be called on the CEF server thread.</para>
/// <para><see href="https://bitbucket.org/chromiumembedded/cef/src/master/include/capi/cef_server_capi.h">CEF source file: /include/capi/cef_server_capi.h (cef_server_handler_t)</see></para>
/// </remarks>
property OnClientDisconnected : TOnClientDisconnected read FOnClientDisconnected write FOnClientDisconnected;
/// <summary>
/// Called when |server| receives an HTTP request. |connection_id| uniquely
/// identifies the connection, |client_address| is the requesting IPv4 or IPv6
/// client address including port number, and |request| contains the request
/// contents (URL, function, headers and optional POST data). Call
/// ICefServer functions either synchronously or asynchronusly to send a
/// response.
/// </summary>
/// <remarks>
/// <para>This event will be called on the CEF server thread.</para>
/// <para><see href="https://bitbucket.org/chromiumembedded/cef/src/master/include/capi/cef_server_capi.h">CEF source file: /include/capi/cef_server_capi.h (cef_server_handler_t)</see></para>
/// </remarks>
property OnHttpRequest : TOnHttpRequest read FOnHttpRequest write FOnHttpRequest;
/// <summary>
/// Called when |server| receives a WebSocket request. |connection_id|
/// uniquely identifies the connection, |client_address| is the requesting
/// IPv4 or IPv6 client address including port number, and |request| contains
/// the request contents (URL, function, headers and optional POST data).
/// Execute |callback| either synchronously or asynchronously to accept or
/// decline the WebSocket connection. If the request is accepted then
/// OnWebSocketConnected will be called after the WebSocket has connected and
/// incoming messages will be delivered to the OnWebSocketMessage callback. If
/// the request is declined then the client will be disconnected and
/// OnClientDisconnected will be called. Call the
/// ICefServer.SendWebSocketMessage function after receiving the
/// OnWebSocketConnected callback to respond with WebSocket messages.
/// </summary>
/// <remarks>
/// <para>This event will be called on the CEF server thread.</para>
/// <para><see href="https://bitbucket.org/chromiumembedded/cef/src/master/include/capi/cef_server_capi.h">CEF source file: /include/capi/cef_server_capi.h (cef_server_handler_t)</see></para>
/// </remarks>
property OnWebSocketRequest : TOnWebSocketRequest read FOnWebSocketRequest write FOnWebSocketRequest;
/// <summary>
/// Called after the client has accepted the WebSocket connection for |server|
/// and |connection_id| via the OnWebSocketRequest callback. See
/// OnWebSocketRequest documentation for intended usage.
/// </summary>
/// <remarks>
/// <para>This event will be called on the CEF server thread.</para>
/// <para><see href="https://bitbucket.org/chromiumembedded/cef/src/master/include/capi/cef_server_capi.h">CEF source file: /include/capi/cef_server_capi.h (cef_server_handler_t)</see></para>
/// </remarks>
property OnWebSocketConnected : TOnWebSocketConnected read FOnWebSocketConnected write FOnWebSocketConnected;
/// <summary>
/// Called when |server| receives an WebSocket message. |connection_id|
/// uniquely identifies the connection, |data| is the message content and
/// |data_size| is the size of |data| in bytes. Do not keep a reference to
/// |data| outside of this function. See OnWebSocketRequest documentation for
/// intended usage.
/// </summary>
/// <remarks>
/// <para>This event will be called on the CEF server thread.</para>
/// <para><see href="https://bitbucket.org/chromiumembedded/cef/src/master/include/capi/cef_server_capi.h">CEF source file: /include/capi/cef_server_capi.h (cef_server_handler_t)</see></para>
/// </remarks>
property OnWebSocketMessage : TOnWebSocketMessage read FOnWebSocketMessage write FOnWebSocketMessage;
end;
{$IFDEF FPC}
procedure Register;
{$ENDIF}
// *********************************************************
// ********************** ATTENTION ! **********************
// *********************************************************
// ** **
// ** MANY OF THE EVENTS IN CEF4DELPHI COMPONENTS LIKE **
// ** TCHROMIUM, TFMXCHROMIUM OR TCEFAPPLICATION ARE **
// ** EXECUTED IN A CEF THREAD BY DEFAULT. **
// ** **
// ** WINDOWS CONTROLS MUST BE CREATED AND DESTROYED IN **
// ** THE SAME THREAD TO AVOID ERRORS. **
// ** SOME OF THEM RECREATE THE HANDLERS IF THEY ARE **
// ** MODIFIED AND CAN CAUSE THE SAME ERRORS. **
// ** **
// ** DON'T CREATE, MODIFY OR DESTROY WINDOWS CONTROLS **
// ** INSIDE THE CEF4DELPHI EVENTS AND USE **
// ** SYNCHRONIZATION OBJECTS TO PROTECT VARIABLES AND **
// ** FIELDS IF THEY ARE ALSO USED IN THE MAIN THREAD. **
// ** **
// ** READ THIS FOR MORE INFORMATION : **
// ** https://www.briskbard.com/index.php?pageid=cef **
// ** **
// ** USE OUR FORUMS FOR MORE QUESTIONS : **
// ** https://www.briskbard.com/forum/ **
// ** **
// *********************************************************
// *********************************************************
implementation
uses
uCEFLibFunctions, uCEFApplicationCore, uCEFMiscFunctions;
// For more information about the TCEFServerComponent properties and functions
// read the code comments in the CEF source file /include/capi/cef_server_cap.h
constructor TCEFServerComponent.Create(AOwner: TComponent);
begin
inherited Create(aOwner);
FHandler := nil;
FServer := nil;
FInitialized := False;
InitializeEvents;
end;
destructor TCEFServerComponent.Destroy;
begin
FServer := nil;
FHandler := nil;
inherited Destroy;
end;
procedure TCEFServerComponent.InitializeEvents;
begin
FOnServerCreated := nil;
FOnServerDestroyed := nil;
FOnClientConnected := nil;
FOnClientDisconnected := nil;
FOnHttpRequest := nil;
FOnWebSocketRequest := nil;
FOnWebSocketConnected := nil;
FOnWebSocketMessage := nil;
end;
function TCEFServerComponent.GetInitialized : boolean;
begin
Result := FInitialized and (FHandler <> nil) and (FServer <> nil);
end;
function TCEFServerComponent.GetIsRunning : boolean;
begin
Result := Initialized and FServer.IsRunning;
end;
function TCEFServerComponent.GetAddress : ustring;
begin
if Initialized then
Result := FServer.GetAddress
else
Result := '';
end;
function TCEFServerComponent.GetHasConnection : boolean;
begin
Result := Initialized and FServer.HasConnection;
end;
procedure TCEFServerComponent.doOnServerCreated(const server: ICefServer);
begin
if (FServer = nil) and
(server <> nil) and
server.IsRunning and
not(server.HasConnection) then
begin
FServer := server;
FInitialized := True;
end;
if assigned(FOnServerCreated) then FOnServerCreated(self, server);
end;
procedure TCEFServerComponent.doOnServerDestroyed(const server: ICefServer);
begin
if assigned(FOnServerDestroyed) then FOnServerDestroyed(self, server);
FServer := nil;
FInitialized := False;
end;
procedure TCEFServerComponent.doOnClientConnected(const server: ICefServer; connection_id: Integer);
begin
if assigned(FOnClientConnected) then FOnClientConnected(self, server, connection_id);
end;
procedure TCEFServerComponent.doOnClientDisconnected(const server: ICefServer; connection_id: Integer);
begin
if assigned(FOnClientDisconnected) then FOnClientDisconnected(self, server, connection_id);
end;
procedure TCEFServerComponent.doOnHttpRequest(const server : ICefServer;
connection_id : Integer;
const client_address : ustring;
const request : ICefRequest);
begin
if assigned(FOnHttpRequest) then FOnHttpRequest(self, server, connection_id, client_address, request);
end;
procedure TCEFServerComponent.doOnWebSocketRequest(const server : ICefServer;
connection_id : Integer;
const client_address : ustring;
const request : ICefRequest;
const callback : ICefCallback);
begin
if assigned(FOnWebSocketRequest) then FOnWebSocketRequest(self, server, connection_id, client_address, request, callback);
end;
procedure TCEFServerComponent.doOnWebSocketConnected(const server: ICefServer; connection_id: Integer);
begin
if assigned(FOnWebSocketConnected) then FOnWebSocketConnected(self, server, connection_id);
end;
procedure TCEFServerComponent.doOnWebSocketMessage(const server : ICefServer;
connection_id : Integer;
const data : Pointer;
data_size : NativeUInt);
begin
if assigned(FOnWebSocketMessage) then FOnWebSocketMessage(self, server, connection_id, data, data_size);
end;
procedure TCEFServerComponent.CreateServer(const address : ustring; port : uint16; backlog : Integer);
const
CEFSERVER_MIN_PORT = 1025;
CEFSERVER_MAX_PORT = 65535;
var
TempAddress : TCefString;
TempPort : integer;
begin
if (GlobalCEFApp <> nil) and
(GlobalCEFApp.Status = asInitialized) and
not(Initialized) and
(length(address) > 0) then
begin
if (FHandler = nil) then FHandler := TCustomServerHandler.Create(self);
TempPort := max(CEFSERVER_MIN_PORT, min(CEFSERVER_MAX_PORT, port));
TempAddress := CefString(address);
cef_server_create(@TempAddress, TempPort, backlog, FHandler.Wrap);
end;
end;
procedure TCEFServerComponent.Shutdown;
begin
if Initialized then FServer.shutdown;
end;
function TCEFServerComponent.IsValidConnection(connection_id: Integer) : boolean;
begin
Result := Initialized and FServer.IsValidConnection(connection_id);
end;
procedure TCEFServerComponent.SendHttp200response( connection_id : Integer;
const content_type : ustring;
const data : Pointer;
data_size : NativeUInt);
begin
if Initialized then FServer.SendHttp200response(connection_id, content_type, data, data_size);
end;
procedure TCEFServerComponent.SendHttp404response(connection_id: Integer);
begin
if Initialized then FServer.SendHttp404response(connection_id);
end;
procedure TCEFServerComponent.SendHttp500response(connection_id: Integer; const error_message: ustring);
begin
if Initialized then FServer.SendHttp500response(connection_id, error_message);
end;
procedure TCEFServerComponent.SendHttpResponse( connection_id : Integer;
response_code : Integer;
const content_type : ustring;
content_length : int64;
const extra_headers : ICefStringMultimap);
begin
if Initialized then FServer.SendHttpResponse(connection_id, response_code, content_type, content_length, extra_headers);
end;
procedure TCEFServerComponent.SendRawData(connection_id: Integer; const data: Pointer; data_size: NativeUInt);
begin
if Initialized then FServer.SendRawData(connection_id, data, data_size);
end;
procedure TCEFServerComponent.CloseConnection(connection_id: Integer);
begin
if Initialized then FServer.CloseConnection(connection_id);
end;
procedure TCEFServerComponent.SendWebSocketMessage(connection_id: Integer; const data: Pointer; data_size: NativeUInt);
begin
if Initialized then FServer.SendWebSocketMessage(connection_id, data, data_size);
end;
{$IFDEF FPC}
procedure Register;
begin
{$I res/tcefservercomponent.lrs}
RegisterComponents('Chromium', [TCEFServerComponent]);
end;
{$ENDIF}
end.