Web socket bridge

Author: Nako Sung

Plugins/UnrealJS/Source/JavascriptWebSocket/IJavascriptWebSocketModule.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "ModuleInterface.h"
+
+/**
+* Interface for the JavascriptWebSocket Module.
+*/
+class IJavascriptWebSocketModule : public IModuleInterface
+{
+public:
+
+	/**
+	* Singleton-like access to this module's interface.  This is just for convenience!
+	* Beware of calling this during the shutdown phase, though.  Your module might have been unloaded already.
+	*
+	* @return Returns singleton instance, loading the module on demand if needed
+	*/
+	static inline IJavascriptWebSocketModule& Get()
+	{
+		return FModuleManager::LoadModuleChecked< IJavascriptWebSocketModule >("JavascriptWebSocket");
+	}
+
+	/**
+	* Checks to see if this module is loaded and ready.  It is only valid to call Get() if IsAvailable() returns true.
+	*
+	* @return True if the module is loaded and ready to use
+	*/
+	static inline bool IsAvailable()
+	{
+		return FModuleManager::Get().IsModuleLoaded("JavascriptWebSocket");
+	}
+};

Plugins/UnrealJS/Source/JavascriptWebSocket/JavascriptWebSocket.Build.cs

@@ -0,0 +1,18 @@
+using UnrealBuildTool;
+
+public class JavascriptWebSocket : ModuleRules
+{
+	public JavascriptWebSocket(TargetInfo Target)
+	{
+        PublicDependencyModuleNames.AddRange(new string[] { 
+            "Core", 
+            "CoreUObject", 
+            "Engine",
+            "V8",
+            "Sockets",
+            "WebSockets",
+            "OnlineSubSystemUtils",
+            "Networking"
+        });
+    }
+}

Plugins/UnrealJS/Source/JavascriptWebSocket/JavascriptWebSocket.cpp

@@ -0,0 +1,126 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#include "JavascriptWebSocketModule.h"
+#include "JavascriptWebSocket.h"
+#include "JavascriptWebSocketServer.h"
+#include "JavascriptContext.h"
+#include "WebSocket.h"
+
+UJavascriptWebSocket* UJavascriptWebSocket::Connect(const FString& EndpointString)
+{
+	FIPv4Endpoint Endpoint;
+
+	if (!FIPv4Endpoint::Parse(EndpointString, Endpoint))
+	{
+		return nullptr;
+	}
+	
+	auto addr = Endpoint.ToInternetAddr();
+	return CreateFrom(new FWebSocket(*addr), GetTransientPackage());
+}
+
+UJavascriptWebSocket* UJavascriptWebSocket::CreateFrom(FWebSocket* WebSocket, UObject* Outer)
+{
+	auto instance = NewObject<UJavascriptWebSocket>(Outer);
+	instance->WebSocket = MakeShareable<FWebSocket>(WebSocket);
+
+	{
+		FWebsocketPacketRecievedCallBack callback;
+		callback.BindUObject(instance, &UJavascriptWebSocket::OnReceivedCallback);
+		instance->WebSocket->SetRecieveCallBack(callback);
+	}
+
+	{
+		FWebsocketInfoCallBack callback;
+		callback.BindUObject(instance, &UJavascriptWebSocket::OnErrorCallback);
+		instance->WebSocket->SetErrorCallBack(callback);
+	}
+
+	{
+		FWebsocketInfoCallBack callback;
+		callback.BindUObject(instance, &UJavascriptWebSocket::OnConnectedCallback);
+		instance->WebSocket->SetConnectedCallBack(callback);
+	}
+	return instance;
+}
+
+void UJavascriptWebSocket::OnReceivedCallback(void* InData, int32 Count)
+{
+	Buffer = InData;
+	Size = Count;
+	OnReceived.Broadcast();
+	Buffer = InData;
+	Size = 0;
+}
+
+int32 UJavascriptWebSocket::GetReceivedBytes()
+{
+	return Size;
+}
+
+void UJavascriptWebSocket::CopyBuffer()
+{
+	if (FArrayBufferAccessor::GetSize() >= Size)
+	{
+		FMemory::Memcpy(FArrayBufferAccessor::GetData(), Buffer, Size);
+	}
+}
+
+void UJavascriptWebSocket::OnConnectedCallback()
+{
+	OnConnected.Broadcast();
+}
+
+void UJavascriptWebSocket::OnErrorCallback()
+{
+	OnError.Broadcast();
+
+	if (auto server = Cast<UJavascriptWebSocketServer>(GetOuter()))
+	{
+		server->OnConnectionLost(this);
+	}
+}
+
+void UJavascriptWebSocket::SendMemory(int32 NumBytes)
+{
+	if (!WebSocket.IsValid()) return;
+
+	auto Buffer = FArrayBufferAccessor::GetData();
+	auto Size = FArrayBufferAccessor::GetSize();
+
+	if (NumBytes > Size) return;
+
+	WebSocket->Send((uint8*)Buffer, NumBytes);
+}
+
+FString UJavascriptWebSocket::RemoteEndPoint()
+{
+	if (!WebSocket.IsValid()) return TEXT("Invalid");
+
+	return WebSocket->RemoteEndPoint();
+}
+
+FString UJavascriptWebSocket::LocalEndPoint()
+{
+	if (!WebSocket.IsValid()) return TEXT("Invalid");
+
+	return WebSocket->LocalEndPoint();
+}
+
+void UJavascriptWebSocket::Flush()
+{
+	if (!WebSocket.IsValid()) return;
+
+	WebSocket->Flush();
+}
+
+void UJavascriptWebSocket::Tick()
+{
+	if (!WebSocket.IsValid()) return;
+
+	WebSocket->Tick();
+}
+
+void UJavascriptWebSocket::Dispose()
+{
+	WebSocket.Reset();
+}

Plugins/UnrealJS/Source/JavascriptWebSocket/JavascriptWebSocket.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "JavascriptWebSocket.generated.h"
+
+UCLASS()
+class UJavascriptWebSocket : public UObject
+{
+	GENERATED_BODY()
+
+public:
+	DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnWebSocketDelegate);
+
+	UPROPERTY(BlueprintAssignable, Category = "Scripting | Javascript")
+	FOnWebSocketDelegate OnReceived;
+
+	UPROPERTY(BlueprintAssignable, Category = "Scripting | Javascript")
+	FOnWebSocketDelegate OnConnected;
+
+	UPROPERTY(BlueprintAssignable, Category = "Scripting | Javascript")
+	FOnWebSocketDelegate OnError;
+
+	UFUNCTION(BlueprintCallable, Category = "Scripting | Javascript")
+	static UJavascriptWebSocket* Connect(const FString& Endpoint);
+
+	static UJavascriptWebSocket* CreateFrom(FWebSocket*, UObject* Outer);
+
+	UFUNCTION(BlueprintCallable, Category = "Scripting | Javascript")
+	void SendMemory(int32 NumBytes);
+
+	UFUNCTION(BlueprintPure, Category = "Scripting | Javascript")
+	int32 GetReceivedBytes();
+
+	UFUNCTION(BlueprintCallable, Category = "Scripting | Javascript")
+	void CopyBuffer();
+
+	UFUNCTION(BlueprintPure, Category = "Scripting | Javascript")
+	FString RemoteEndPoint();
+
+	UFUNCTION(BlueprintPure, Category = "Scripting | Javascript")
+	FString LocalEndPoint();
+
+	UFUNCTION(BlueprintCallable, Category = "Scripting | Javascript")
+	void Flush();
+
+	UFUNCTION(BlueprintCallable, Category = "Scripting | Javascript")
+	void Tick();
+
+	UFUNCTION(BlueprintCallable, Category = "Scripting | Javascript")
+	void Dispose();
+
+private:
+	TSharedPtr<FWebSocket> WebSocket;
+	int32 Size{ 0 };
+	void* Buffer{ nullptr };
+
+	void OnReceivedCallback(void* InData, int32 Count);
+	void OnConnectedCallback();
+	void OnErrorCallback();
+};

Plugins/UnrealJS/Source/JavascriptWebSocket/JavascriptWebSocketModule.cpp

@@ -0,0 +1,25 @@
+#include "JavascriptWebSocketModule.h"
+
+class FJavascripWebSocketModule : public IJavascriptWebSocketModule
+{
+	// Begin IModuleInterface
+	virtual void StartupModule() override;
+	virtual void ShutdownModule() override;
+	// End IModuleInterface
+
+};
+
+
+void FJavascripWebSocketModule::StartupModule()
+{
+
+}
+
+
+void FJavascripWebSocketModule::ShutdownModule()
+{
+
+}
+
+IMPLEMENT_MODULE(FJavascripWebSocketModule, JavascriptWebSocket);
+DEFINE_LOG_CATEGORY(LogWebsocket);

Plugins/UnrealJS/Source/JavascriptWebSocket/JavascriptWebSocketModule.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "Core.h"
+#include "Engine.h"
+#include "Networking.h"
+#include "Sockets.h"
+#include "SocketSubsystem.h"
+#include "ModuleManager.h"
+
+// Interfaces
+#include "IJavascriptWebSocketModule.h"
+
+class FWebSocket;
+class FWebSocketServer;
+
+typedef struct libwebsocket_context WebSocketInternalContext;
+typedef struct libwebsocket WebSocketInternal;
+typedef struct libwebsocket_protocols WebSocketInternalProtocol;
+
+DECLARE_DELEGATE_TwoParams(FWebsocketPacketRecievedCallBack, void* /*Data*/, int32 /*Data Size*/);
+DECLARE_DELEGATE_OneParam(FWebsocketClientConnectedCallBack, FWebSocket* /*Socket*/);
+DECLARE_DELEGATE(FWebsocketInfoCallBack);
+
+DECLARE_LOG_CATEGORY_EXTERN(LogWebsocket, Warning, All);

Plugins/UnrealJS/Source/JavascriptWebSocket/JavascriptWebSocketServer.cpp

@@ -0,0 +1,54 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#include "JavascriptWebSocketModule.h"
+#include "WebSocket.h"
+#include "WebSocketServer.h"
+#include "JavascriptWebSocketServer.h"
+
+UJavascriptWebSocketServer* UJavascriptWebSocketServer::Create(int32 Port)
+{	
+	auto instance = NewObject<UJavascriptWebSocketServer>();
+	auto server = instance->WebSocketServer = MakeShareable<FWebSocketServer>(new FWebSocketServer);
+	FWebsocketClientConnectedCallBack callback;
+	callback.BindUObject(instance, &UJavascriptWebSocketServer::OnConnectedCallback);
+	if (!server->Init(Port, callback))
+	{
+		return nullptr;
+	}
+	return instance;
+}
+
+FString UJavascriptWebSocketServer::Info()
+{
+	if (!WebSocketServer.IsValid()) return TEXT("Invalid");
+
+	return WebSocketServer->Info();
+}
+
+void UJavascriptWebSocketServer::OnConnectedCallback(FWebSocket* WebSocket)
+{
+	auto instance = UJavascriptWebSocket::CreateFrom(WebSocket, this);
+	Connections.Add(instance);
+	OnConnected.Broadcast(instance);
+}
+
+void UJavascriptWebSocketServer::OnConnectionLost(UJavascriptWebSocket* Connection)
+{
+	Connections.Remove(Connection);
+}
+
+void UJavascriptWebSocketServer::Tick()
+{
+	if (!WebSocketServer.IsValid()) return;
+
+	WebSocketServer->Tick();
+
+	for (auto Connection : Connections)
+	{
+		Connection->Tick();
+	}	
+}
+
+void UJavascriptWebSocketServer::Dispose()
+{
+	WebSocketServer.Reset();
+}

Plugins/UnrealJS/Source/JavascriptWebSocket/JavascriptWebSocketServer.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "JavascriptWebSocketServer.generated.h"
+
+class FWebSocketServer;
+class UJavascriptWebSocket;
+
+UCLASS()
+class UJavascriptWebSocketServer : public UObject
+{
+	GENERATED_BODY()
+
+public:
+	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnWebSocketServerDelegate,UJavascriptWebSocket*,WebSocket);
+
+	UPROPERTY(BlueprintAssignable, Category = "Scripting | Javascript")
+	FOnWebSocketServerDelegate OnConnected;
+
+	UFUNCTION(BlueprintCallable, Category = "Scripting | Javascript")
+	static UJavascriptWebSocketServer* Create(int32 Port);
+
+	UFUNCTION(BlueprintPure, Category = "Scripting | Javascript")
+	FString Info();	
+
+	UFUNCTION(BlueprintCallable, Category = "Scripting | Javascript")
+	void Tick();
+
+	UFUNCTION(BlueprintCallable, Category = "Scripting | Javascript")
+	void Dispose();
+
+	UPROPERTY()
+	TArray<UJavascriptWebSocket*> Connections;
+
+	void OnConnectionLost(UJavascriptWebSocket* Connection);
+
+private:
+	TSharedPtr<FWebSocketServer> WebSocketServer;
+
+	void OnConnectedCallback(FWebSocket*);
+};