feat: use new ecsact async session api (#17)

Author: zaucy

Source/Ecsact/Private/EcsactGameInstanceSubsystem.cpp

@@ -12,8 +12,7 @@
 auto UEcsactGameInstanceSubsystem::Initialize( //
 	FSubsystemCollectionBase& Collection
 ) -> void {
-	RuntimeHandle = ECSACT_LOAD_RUNTIME();
-
+	UE_LOG(LogTemp, Log, TEXT("Ecsact Game Instance Initialize"));
 	FWorldDelegates::OnPreWorldInitialization.AddUObject(
 		this,
 		&ThisClass::OnPreWorldInitialization
@@ -35,10 +34,6 @@ auto UEcsactGameInstanceSubsystem::Deinitialize() -> void {
 	if(runner) {
 		StopRunner();
 	}
-
-	if(RuntimeHandle) {
-		ECSACT_UNLOAD_RUNTIME(RuntimeHandle);
-	}
 }
 
 auto UEcsactGameInstanceSubsystem::OnPreWorldInitialization(

Source/Ecsact/Private/EcsactGameInstanceSubsystem.h

@@ -11,7 +11,6 @@ class UEcsactGameInstanceSubsystem : public UGameInstanceSubsystem {
 
 	friend class EcsactUnrealExecution;
 
-	FEcsactRuntimeHandle                RuntimeHandle;
 	TWeakObjectPtr<class UEcsactRunner> Runner;
 
 	auto OnPreWorldInitialization(

Source/Ecsact/Public/EcsactUnreal/Blueprint/EcsactAsyncConnectBlueprintAction.cpp

@@ -1,6 +1,7 @@
 #include "EcsactUnreal/Blueprint/EcsactAsyncConnectBlueprintAction.h"
-#include "EcsactUnreal/EcsactExecution.h"
 #include "EcsactUnreal/EcsactAsyncRunnerEvents.h"
+#include "EcsactUnreal/EcsactExecution.h"
+#include "EcsactUnreal/EcsactAsyncRunner.h"
 #include "ecsact/runtime/async.h"
 #include "EcsactUnreal/Ecsact.h"
 
@@ -21,57 +22,30 @@ auto UEcsactAsyncConnectBlueprintAction::ConnectRequest(
 ) -> void {
 	UE_LOG(Ecsact, Warning, TEXT("AsyncConnectActivate()"));
 	auto runner = EcsactUnrealExecution::Runner(GetWorld());
-	auto async_events = Cast<IEcsactAsyncRunnerEvents>(runner);
-	if(!async_events) {
+	auto async_runner = Cast<UEcsactAsyncRunner>(runner);
+	if(!async_runner) {
 		UE_LOG(
 			Ecsact,
 			Error,
 			TEXT("Cannot use Ecsact async blueprint api with runner that does not "
-					 "implement IEcsactAsyncRunnerEvents")
+					 "inherit UEcsactAsyncRunner")
 		);
-		OnError.Broadcast(EAsyncConnectError::AsyncRunnerEventsUnavailable);
-		OnDone.Broadcast({});
-		return;
-	}
-
-	auto req_id = ecsact_async_connect(ConnectionString.c_str());
-	UE_LOG(Ecsact, Warning, TEXT("async connect request id=%i"), req_id);
-
-	if(req_id == ECSACT_INVALID_ID(async_request)) {
-		UE_LOG(Ecsact, Error, TEXT("Invalid Request ID"));
-		OnError.Broadcast(EAsyncConnectError::InvalidRequestId);
+		OnError.Broadcast(EAsyncConnectError::AsyncRunnerUnavailable);
 		OnDone.Broadcast({});
 		return;
 	}
 
-	async_events->OnRequestDone(
-		req_id,
-		IEcsactAsyncRunnerEvents::FAsyncRequestDoneCallback::CreateUObject(
-			this,
-			&ThisClass::OnRequestDone
-		)
+	SessionEventHandle = async_runner->AsyncSessionEvent.AddUObject(
+		this,
+		&ThisClass::OnAsyncSessionEvent
 	);
 
-	async_events->OnRequestError(
-		req_id,
-		IEcsactAsyncRunnerEvents::FAsyncRequestErrorCallback::CreateUObject(
-			this,
-			&ThisClass::OnRequestError
-		)
+	async_runner->AsyncSessionStart(
+		ConnectionString.c_str(),
+		static_cast<int32_t>(ConnectionString.size())
 	);
 }
 
-auto UEcsactAsyncConnectBlueprintAction::OnRequestDone() -> void {
-	auto runner = EcsactUnrealExecution::Runner(GetWorld());
-	auto async_events = Cast<IEcsactAsyncRunnerEvents>(runner);
-	UE_LOG(Ecsact, Error, TEXT("OnRequestDone??"));
-	if(!bConnectFailed) {
-		async_events->TriggerGenericConnectCallbacks();
-		OnSuccess.Broadcast({});
-	}
-	OnDone.Broadcast({});
-}
-
 auto UEcsactAsyncConnectBlueprintAction::OnRequestError( //
 	ecsact_async_error Error
 ) -> void {
@@ -84,6 +58,28 @@ auto UEcsactAsyncConnectBlueprintAction::OnRequestError( //
 			OnError.Broadcast(EAsyncConnectError::InvalidConnectionString);
 			break;
 	}
+}
 
-	bConnectFailed = true;
+auto UEcsactAsyncConnectBlueprintAction::OnAsyncSessionEvent( //
+	int32                    SessionId,
+	EEcsactAsyncSessionEvent Event
+) -> void {
+	auto runner = EcsactUnrealExecution::Runner(GetWorld());
+	auto async_runner = Cast<UEcsactAsyncRunner>(runner);
+
+	if(async_runner) {
+		switch(Event) {
+			case EEcsactAsyncSessionEvent::Stopped:
+				async_runner->AsyncSessionEvent.Remove(SessionEventHandle);
+				OnDone.Broadcast({});
+				break;
+			case EEcsactAsyncSessionEvent::Started:
+				async_runner->AsyncSessionEvent.Remove(SessionEventHandle);
+				OnSuccess.Broadcast({});
+				OnDone.Broadcast({});
+				break;
+			default:
+				break;
+		}
+	}
 }

Source/Ecsact/Public/EcsactUnreal/Blueprint/EcsactAsyncConnectBlueprintAction.h

@@ -1,17 +1,19 @@
 #pragma once
 
 #include <string>
+#include "EcsactUnreal/EcsactAsyncRunnerEvents.h"
 #include "Kismet/BlueprintAsyncActionBase.h"
 #include "ecsact/runtime/async.h"
 #include "EcsactAsyncConnectBlueprintAction.generated.h"
 
 UENUM()
 enum class EAsyncConnectError : uint8 {
 	NoError,
-	AsyncRunnerEventsUnavailable,
+	AsyncRunnerUnavailable,
 	InvalidRequestId,
 	PermissionDenied,
 	InvalidConnectionString,
+	InvalidSessionId,
 };
 
 /**
@@ -26,6 +28,8 @@ class ECSACT_API UEcsactAsyncConnectBlueprintAction
 	std::string Utf8ConnectionString;
 	bool        bConnectFailed = false;
 
+	FDelegateHandle SessionEventHandle;
+
 	auto OnRequestDone() -> void;
 	auto OnRequestError(ecsact_async_error Error) -> void;
 
@@ -71,4 +75,8 @@ class ECSACT_API UEcsactAsyncConnectBlueprintAction
 
 protected:
 	auto ConnectRequest(std::string ConnectionString) -> void;
+	auto OnAsyncSessionEvent( //
+		int32                    SessionId,
+		EEcsactAsyncSessionEvent Event
+	) -> void;
 };

Source/Ecsact/Public/EcsactUnreal/Ecsact.cpp

@@ -41,10 +41,12 @@ auto FEcsactModule::Abort() -> void {
 }
 
 auto FEcsactModule::StartupModule() -> void {
+	UE_LOG(Ecsact, Log, TEXT("Ecsact Module Startup"));
 	Self = this;
 }
 
 auto FEcsactModule::ShutdownModule() -> void {
+	UE_LOG(Ecsact, Log, TEXT("Ecsact Module Shutdown"));
 	Self = nullptr;
 }