InteractiveProcess.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Queue.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformProcess.h"
#include "HAL/Runnable.h"
#include "Logging/LogMacros.h"
#include "Misc/DateTime.h"
#include "Misc/Timespan.h"
 
class FRunnableThread;
 
DECLARE_LOG_CATEGORY_EXTERN(LogInteractiveProcess, Log, All);
 
DECLARE_DELEGATE_TwoParams(FOnInteractiveProcessCompleted, int32, bool);
 
DECLARE_DELEGATE_OneParam(FOnInteractiveProcessOutput, const FString&);
 
class FInteractiveProcess
    : public FRunnable
{
public:
 
    CORE_API FInteractiveProcess(const FString& InURL, const FString& InParams, bool InHidden, bool LongTime = false);
 
    CORE_API FInteractiveProcess(const FString& InURL, const FString& InParams, const FString& InWorkingDir, bool InHidden, bool LongTime = false);
 
    CORE_API ~FInteractiveProcess();
 
    CORE_API FTimespan GetDuration() const;
 
    FProcHandle GetProcessHandle() const
    {
        return ProcessHandle;
    }
 
    bool IsRunning() const
    {
        return Thread != nullptr;
    }
 
    CORE_API bool Launch();
 
    FSimpleDelegate& OnCanceled()
    {
        return CanceledDelegate;
    }
 
    FOnInteractiveProcessCompleted& OnCompleted()
    {
        return CompletedDelegate;
    }
 
    FOnInteractiveProcessOutput& OnOutput()
    {
        return OutputDelegate;
    }
 
    CORE_API void SendWhenReady(const FString &Message);
 
    CORE_API void SendWhenReady(const TArray<uint8> &Data);
 
    int GetReturnCode() const
    {
        return ReturnCode;
    }
 
    void Cancel(bool InKillTree = false)
    {
        bCanceling = true;
        bKillTree = InKillTree;
    }
 
    // FRunnable interface
 
    virtual bool Init() override
    {
        return true;
    }
 
    CORE_API virtual uint32 Run() override;
 
    virtual void Stop() override
    {
        Cancel();
    }
 
    virtual void Exit() override { }
 
protected:
 
    CORE_API void ProcessOutput(const FString& Output);
 
    CORE_API void SendMessageToProcessIf();
 
private:
    // Whether the process is being canceled. */
    bool bCanceling : 1;
 
    // Whether the window of the process should be hidden. */
    bool bHidden : 1;
 
    // Whether to kill the entire process tree when cancelling this process. */
    bool bKillTree : 1;
    
    // How many milliseconds should the process sleep */
    float SleepTime;
 
    // Holds the URL of the executable to launch. */
    FString URL;
 
    // Holds the command line parameters. */
    FString Params;
 
    // Holds the URL of the working dir for the process. */
    FString WorkingDir;
 
    // Holds the handle to the process. */
    FProcHandle ProcessHandle;
 
    // Holds the read pipe of parent process. */
    void* ReadPipeParent;
 
    // Holds the write pipe of parent process. */
    void* WritePipeParent;
 
    // Holds the read pipe of child process. Should not be used except for testing */
    void* ReadPipeChild;
    
    // Holds the write pipe of child process. Should not be used except for testing */
    void* WritePipeChild;
 
    // Holds the thread object. */
    FRunnableThread* Thread;
 
    // Holds the name of thread */
    FString ThreadName;
 
    // Holds the return code. */
    int ReturnCode;
 
    // Holds the time at which the process started. */
    FDateTime StartTime;
 
    // Holds the time at which the process ended. */
    FDateTime EndTime;
 
    // Holds string messages to be written to pipe when ready */
    TQueue<FString> StringMessagesToProcess;
 
    // Holds data messages to be written to pipe when ready */
    TQueue<TArray<uint8>> DataMessagesToProcess;
 
    // Holds a delegate that is executed when the process has been canceled. */
    FSimpleDelegate CanceledDelegate;
 
    // Holds a delegate that is executed when a interactive process completed. */
    FOnInteractiveProcessCompleted CompletedDelegate;
 
    // Holds a delegate that is executed when a interactive process produces output. */
    FOnInteractiveProcessOutput OutputDelegate;
};