IQueuedWork and Async stuff

In this example we will create a custom async task to execute python code.

Base class of our custom task

#include "PythonScriptTypes.h"
class IPythonAutoDeleteAsyncTask : IQueuedWork
{
    DECLARE_DELEGATE_OneParam(FOnPythonTaskComplete, FString&)
    
public:
	/**
	 * Create and initialize a new instance
	 *
	 * @param pythonCommand Python command container
	 * @param threadTarget
	 */
	IPythonAutoDeleteAsyncTask(const FPythonCommandEx& pythonCommand, ENamedThreads::Type threadTarget = ENamedThreads::GameThread);

public:
	/**
	 * Override Methods
	 */

	/** todo make non Abandonable behaviour implementation */
	virtual void Abandon() override {};
	virtual void DoWork() = 0;
	virtual void Start();

private:
	virtual void DoThreadedWork() override;

public:
	/**
	 * Public fields
	 */

	FOnPythonTaskComplete OnPythonTaskComplete;
	FPythonCommandEx PythonCommand;
	ENamedThreads::Type ThreadTarget;
};

/** Inline Methods */
FORCEINLINE IPythonAutoDeleteAsyncTask::IPythonAutoDeleteAsyncTask(const FPythonCommandEx& pythonCommand, ENamedThreads::Type threadTarget) :
	PythonCommand(pythonCommand),
	ThreadTarget(threadTarget)
{}

inline void IPythonAutoDeleteAsyncTask::Start()
{
	GThreadPool->AddQueuedWork(this);
}

inline void IPythonAutoDeleteAsyncTask::DoThreadedWork()
{
    DoWork();
    delete this;
}

Custom Task implementation

// .h
#include "Interfaces/IPythonAutoDeleteAsyncTask.h"
#include "IPythonScriptPlugin.h"

/**
 * Class representing a PythonTask Async object
 *
 */
class FPythonAsyncTask final : public IPythonAutoDeleteAsyncTask
{

public:
	explicit FPythonAsyncTask(const FPythonCommandEx& pythonCommand)
		: IPythonAutoDeleteAsyncTask(pythonCommand, ENamedThreads::AnyThread)
	{
	}

	virtual void DoWork() override;

private:
	/**
	 * Private Method
	 */
	FPythonAsyncTask(const FPythonAsyncTask&) = default;
};

// .cpp
void FPythonAsyncTask::DoWork()
{
	IPythonScriptPlugin::Get()->ExecPythonCommandEx(PythonCommand);

	if (PythonCommand.CommandResult.IsEmpty())
		return;

	/**
	 * Todo improvement:
	 *	I think we can made a custom layer between str response from python and convert it into an SG object.
	 *	We don't have this layer for now, so each SG response object are construct in each request ...
	 *	So removing single quote, can be done in this futur layer.
	 */
	PythonCommand.CommandResult = PythonCommand.CommandResult.Replace(WIDETEXT("'"), TEXT(""));

	OnPythonTaskComplete.ExecuteIfBound(PythonCommand.CommandResult);
	
}

Usage

FPythonCommandEx command;
command.Command = FString("import json; import sgtk; engine = sgtk.platform.current_engine(); sg = engine.shotgun; current_context = engine.context");
command.ExecutionMode = EPythonCommandExecutionMode::ExecuteStatement;
IPythonAutoDeleteAsyncTask* pythonTask = new FPythonAsyncTask(command);
pythonTask->OnPythonTaskComplete.BindLambda([this, onInitImportComplete](const FString& result)
    {
        onInitImportComplete.ExecuteIfBound();
    });
pythonTask->Start();

For Slate

When using functions of Slate UE library, in other thread, we can faces to a specific issue: Assertion failed: IsInGameThread() || IsInSlateThread()

This mean, we can't execute slate function in other thread than GameThread or SlateThread, this is a security check from Slate (assert).

To keep async behaviour we can use AsyncTask function:

With this behaviour we can get result from an api dynamically in custom thread -> catch result -> copy result to a new GameThread -> process our result and use it on Slate side.

Example:

void FPythonRequest::MakeAsyncRequest(const FSGRequest& request, OnRequestComplete onRequestComplete)
{
    //..
	InitShotgunApi3Async(FOnInitImportComplete::CreateLambda([this, entityName, filters, fields, onRequestComplete]()
		{
			FPythonCommandEx requestCommand;
			requestCommand.Command = FString::Printf(TEXT("json.dumps({ \"data\": sg.find(\"%s\", %s, %s)})"), *entityName, *filters, *fields);
			requestCommand.ExecutionMode = EPythonCommandExecutionMode::EvaluateStatement;
			IPythonAutoDeleteAsyncTask* pythonTask = new FPythonAsyncTask(requestCommand);
			pythonTask->OnPythonTaskComplete.BindLambda([this, onRequestComplete](const FString& result)
				{
					AsyncTask(ENamedThreads::GameThread, [=]()
						{
							// convert str response to SGResponse Object
							FSGResponseEntities entity;
							if (!FJsonObjectConverter::JsonObjectStringToUStruct(result, &entity))
							{
								UE_LOG(LogTemp, Error, TEXT("ERROR When execute JsonObjectStringToUStruct on response."));
								return;
							}
							onRequestComplete.ExecuteIfBound(entity);
						});
				});
			pythonTask->Start();
		})
	);
}

Very usefull

AsyncTask(ENamedThreads::GameThread, []()
    {

    });