1707 lines
55 KiB
C++
1707 lines
55 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#if WITH_TENCENT_RAIL_SDK
|
|
|
|
#include "RailSDK.h"
|
|
#include "RailSdkWrapper.h"
|
|
#include "OnlineAsyncTaskManager.h"
|
|
#include "Interfaces/OnlineFriendsInterface.h"
|
|
#include "Interfaces/OnlinePresenceInterface.h"
|
|
#include "Interfaces/OnlinePurchaseInterface.h"
|
|
#include "OnlineSubsystemTencentTypes.h"
|
|
#include "OnlineError.h"
|
|
#include "OnlineJsonSerializer.h"
|
|
|
|
class FOnlineSubsystemTencent;
|
|
class FUniqueNetIdRail;
|
|
class FOnlineUserInfoTencent;
|
|
typedef TSharedRef<class FOnlineStoreOffer> FOnlineStoreOfferRef;
|
|
|
|
/** Timeout failsafe in case Tencent tasks/events don't get a callback */
|
|
#if UE_BUILD_SHIPPING
|
|
#define ASYNC_RAIL_TASK_TIMEOUT 20.0
|
|
#else
|
|
#define ASYNC_RAIL_TASK_TIMEOUT 80.0
|
|
#endif
|
|
|
|
/**
|
|
* Base class that holds a delegate to fire when a given async task is complete
|
|
*/
|
|
class FOnlineAsyncTaskRail : public FOnlineAsyncTaskBasic<FOnlineSubsystemTencent>, public rail::IRailEvent
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRail() = delete;
|
|
FOnlineAsyncTaskRail(FOnlineSubsystemTencent* InSubsystem, TSet<rail::RAIL_EVENT_ID> InRegisteredRailEvents)
|
|
: FOnlineAsyncTaskBasic(InSubsystem)
|
|
, RegisteredRailEvents(InRegisteredRailEvents)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRail() = default;
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void Tick() override;
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
protected:
|
|
|
|
/**
|
|
* Convert a raw Rail result into something resembling an FOnlineError
|
|
*
|
|
* @param InResult any rail result
|
|
* @param OutOnlineError the converted error result
|
|
*/
|
|
void ParseRailResult(rail::RailResult InResult, FOnlineError& OutOnlineError) const;
|
|
|
|
/**
|
|
* Parse a Rail event into something resembling an FOnlineError
|
|
*
|
|
* @param InResult any rail event
|
|
* @param OutOnlineError the converted error result
|
|
*/
|
|
void ParseRailResult(const rail::EventBase* InResult, FOnlineError& OutOnlineError) const;
|
|
|
|
/**
|
|
* Can this task timeout?
|
|
* Most tasks are able to timeout.
|
|
*/
|
|
bool bCanTimeout = true;
|
|
|
|
// Events registered with this task
|
|
TSet<rail::RAIL_EVENT_ID> RegisteredRailEvents;
|
|
};
|
|
|
|
class FOnlineAsyncEventRail : public FOnlineAsyncEvent<FOnlineSubsystemTencent>
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncEventRail() = delete;
|
|
FOnlineAsyncEventRail(FOnlineSubsystemTencent* InSubsystem)
|
|
: FOnlineAsyncEvent(InSubsystem)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncEventRail() = default;
|
|
|
|
/**
|
|
* Convert a raw Rail result into something resembling an FOnlineError
|
|
*
|
|
* @param InResult any rail result
|
|
* @param OutOnlineError the converted error result
|
|
*/
|
|
void ParseRailResult(rail::RailResult InResult, FOnlineError& OutOnlineError) const;
|
|
|
|
/**
|
|
* Parse a Rail event into something resembling an FOnlineError
|
|
*
|
|
* @param InResult any rail event
|
|
* @param OutOnlineError the converted error result
|
|
*/
|
|
void ParseRailResult(const rail::EventBase* InResult, FOnlineError& OutOnlineError) const;
|
|
};
|
|
|
|
class FOnlineAsyncTaskRailAcquireSessionTicket
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
DECLARE_DELEGATE_TwoParams(FCompletionDelegate, const FOnlineError& /*Result*/, const FString& /*SessionTicket*/);
|
|
|
|
FOnlineAsyncTaskRailAcquireSessionTicket() = delete;
|
|
FOnlineAsyncTaskRailAcquireSessionTicket(FOnlineSubsystemTencent* InSubsystem, rail::RailID InPlayerId, const FCompletionDelegate& InCompletionDelegate)
|
|
: FOnlineAsyncTaskRail(InSubsystem, {rail::kRailEventSessionTicketGetSessionTicket})
|
|
, PlayerId(InPlayerId)
|
|
, CompletionDelegate(InCompletionDelegate)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailAcquireSessionTicket()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailAcquireSessionTicket OnlineError: %s"), *OnlineError.ToLogString()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID EventId, rail::EventBase* Param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailGetSessionTicket(const rail::rail_event::AcquireSessionTicketResponse* SessionTicketResponse);
|
|
|
|
/** Player id we are obtaining the auth session for */
|
|
rail::RailID PlayerId;
|
|
/** The result */
|
|
FOnlineError OnlineError;
|
|
/** The acquired session ticket */
|
|
FString SessionTicket;
|
|
/** Function to fire when complete */
|
|
FCompletionDelegate CompletionDelegate;
|
|
};
|
|
|
|
/**
|
|
* Result structure after opening/closing a floating window
|
|
*/
|
|
struct FFloatingWindowTaskResult
|
|
{
|
|
FFloatingWindowTaskResult()
|
|
: bOpened(false)
|
|
{
|
|
}
|
|
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** State of the floating window */
|
|
bool bOpened;
|
|
};
|
|
|
|
class FOnlineAsyncTaskRailShowFloatingWindow
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailShowFloatingWindow() = delete;
|
|
FOnlineAsyncTaskRailShowFloatingWindow(FOnlineSubsystemTencent* InSubsystem, rail::EnumRailWindowType InWindowType)
|
|
: FOnlineAsyncTaskRail(InSubsystem, {rail::kRailEventShowFloatingWindow})
|
|
, WindowType(InWindowType)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailShowFloatingWindow()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailShowFloatingWindow bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailShowFloatingWindow(rail::rail_event::ShowFloatingWindowResult* param);
|
|
|
|
/** Result of the task */
|
|
FFloatingWindowTaskResult TaskResult;
|
|
/** Type of window to open */
|
|
rail::EnumRailWindowType WindowType;
|
|
};
|
|
|
|
/**
|
|
* Result structure after setting user metadata / presence
|
|
*/
|
|
struct FSetUserMetadataTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** Key/Value pairs in string form used with this task */
|
|
TMap<FString, FString> FinalData;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailSetUserMetadata completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailSetUserMetadataComplete, const FSetUserMetadataTaskResult& /*Result*/);
|
|
|
|
class FOnlineAsyncTaskRailSetUserMetadata
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailSetUserMetadata() = delete;
|
|
FOnlineAsyncTaskRailSetUserMetadata(FOnlineSubsystemTencent* InSubsystem, const FMetadataPropertiesRail& InMetdata, const FOnOnlineAsyncTaskRailSetUserMetadataComplete& InCompletionDelegate)
|
|
: FOnlineAsyncTaskRail(InSubsystem, {rail::kRailEventFriendsSetMetadataResult})
|
|
, Metadata(InMetdata)
|
|
, CompletionDelegate(InCompletionDelegate)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailSetUserMetadata()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailSetUserMetadata bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
/**
|
|
* Given an input of local metadata, populate a list of key value pairs for consumption by RailSDK
|
|
*
|
|
* @param InMetadata local metadata to convert to RailSDK
|
|
* @param OutFinalData map of data in final format
|
|
* @param OutRailKeyValuePairs list of keys and their values
|
|
*/
|
|
virtual bool GenerateRailMetadata(FMetadataPropertiesRail& InMetadata, TMap<FString, FString>& OutFinalData, rail::RailArray<rail::RailKeyValue>& OutRailKeyValuePairs);
|
|
void OnRailEventFriendsSetMetadataResult(const rail::rail_event::RailFriendsSetMetadataResult* MetadataResult);
|
|
|
|
/** Input metadata information */
|
|
FMetadataPropertiesRail Metadata;
|
|
/** Output presence result */
|
|
FSetUserMetadataTaskResult TaskResult;
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailSetUserMetadataComplete CompletionDelegate;
|
|
};
|
|
|
|
/**
|
|
* Builds on FOnlineAsyncTaskRailSetUserMetadata to provide the ability to dynamically store multiple keys
|
|
* by storing an additional key with a list of the others
|
|
*/
|
|
class FOnlineAsyncTaskRailSetUserPresence
|
|
: public FOnlineAsyncTaskRailSetUserMetadata
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailSetUserPresence() = delete;
|
|
FOnlineAsyncTaskRailSetUserPresence(FOnlineSubsystemTencent* InSubsystem, const FMetadataPropertiesRail& InMetdata, const FOnOnlineAsyncTaskRailSetUserMetadataComplete& InCompletionDelegate)
|
|
: FOnlineAsyncTaskRailSetUserMetadata(InSubsystem, InMetdata, InCompletionDelegate)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailSetUserPresence()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailSetUserPresence bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
protected:
|
|
|
|
//~ Begin FOnlineAsyncTaskRailSetUserMetadata interface
|
|
virtual bool GenerateRailMetadata(FMetadataPropertiesRail& InMetadata, TMap<FString, FString>& OutFinalData, rail::RailArray<rail::RailKeyValue>& OutRailKeyValuePairs) override;
|
|
//~ End FOnlineAsyncTaskRailSetUserMetadata interface
|
|
};
|
|
|
|
class FOnlineAsyncTaskRailSetSessionMetadata
|
|
: public FOnlineAsyncTaskRailSetUserMetadata
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailSetSessionMetadata() = delete;
|
|
FOnlineAsyncTaskRailSetSessionMetadata(FOnlineSubsystemTencent* InSubsystem, const FMetadataPropertiesRail& InMetdata, const FOnOnlineAsyncTaskRailSetUserMetadataComplete& InCompletionDelegate)
|
|
: FOnlineAsyncTaskRailSetUserMetadata(InSubsystem, InMetdata, InCompletionDelegate)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailSetSessionMetadata()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailSetSessionMetadata bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
};
|
|
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailSetInviteCommandlineComplete, const FSetUserMetadataTaskResult& /*Result*/);
|
|
|
|
class FOnlineAsyncTaskRailSetInviteCommandline
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailSetInviteCommandline() = delete;
|
|
FOnlineAsyncTaskRailSetInviteCommandline(FOnlineSubsystemTencent* InSubsystem, const FString& InCmdline, const FOnOnlineAsyncTaskRailSetInviteCommandlineComplete& InCompletionDelegate)
|
|
: FOnlineAsyncTaskRail(InSubsystem, {rail::kRailEventFriendsSetMetadataResult})
|
|
, Cmdline(InCmdline)
|
|
, CompletionDelegate(InCompletionDelegate)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailSetInviteCommandline()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailSetCommandline bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventFriendsSetMetadataResult(const rail::rail_event::RailFriendsSetMetadataResult* MetadataResult);
|
|
|
|
/** Command line to store with the backend */
|
|
FString Cmdline;
|
|
/** Output result of this call */
|
|
FSetUserMetadataTaskResult TaskResult;
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailSetInviteCommandlineComplete CompletionDelegate;
|
|
};
|
|
|
|
/**
|
|
* Result structure after getting user metadata / presence
|
|
*/
|
|
struct FGetUserMetadataTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** User whose presence was retrieved */
|
|
FUniqueNetIdRailPtr UserId;
|
|
/** Retrieved presence information */
|
|
FMetadataPropertiesRail Metadata;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailGetUserMetadata completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailGetUserMetadataComplete, const FGetUserMetadataTaskResult& /*Result*/);
|
|
|
|
class FOnlineAsyncTaskRailGetUserMetadata
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailGetUserMetadata() = delete;
|
|
FOnlineAsyncTaskRailGetUserMetadata(FOnlineSubsystemTencent* InSubsystem, const FUniqueNetIdRail& InUserId, const TArray<FString>& InMetadataKeys, const FOnOnlineAsyncTaskRailGetUserMetadataComplete& InCompletionDelegate);
|
|
virtual ~FOnlineAsyncTaskRailGetUserMetadata();
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override;
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
/**
|
|
* Retrieve a list of metadata key value pairs
|
|
*
|
|
* @param InMetadata list of keys to retrieve from the user specified by this task
|
|
*/
|
|
rail::RailResult QueryMetadata(const TArray<FString>& InMetadata);
|
|
virtual void OnRailEventFriendsGetMetadataResult(const rail::rail_event::RailFriendsGetMetadataResult* MetadataResult);
|
|
|
|
/** User to query presence for */
|
|
rail::RailID RailUserId;
|
|
/** Presence retrieved for this user */
|
|
TArray<FString> MetadataKeys;
|
|
/** Output result from the task */
|
|
FGetUserMetadataTaskResult TaskResult;
|
|
/** Delegate to fire when this task is completed */
|
|
FOnOnlineAsyncTaskRailGetUserMetadataComplete CompletionDelegate;
|
|
};
|
|
|
|
/**
|
|
* Builds on FOnlineAsyncTaskRailGetUserMetadata to provide the ability to dynamically retrieve multiple keys
|
|
* from an additional key with a list of the others
|
|
*/
|
|
class FOnlineAsyncTaskRailGetUserPresence
|
|
: public FOnlineAsyncTaskRailGetUserMetadata
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailGetUserPresence() = delete;
|
|
FOnlineAsyncTaskRailGetUserPresence(FOnlineSubsystemTencent* InSubsystem, const FUniqueNetIdRail& InUserId, const FOnOnlineAsyncTaskRailGetUserMetadataComplete& InCompletionDelegate);
|
|
virtual ~FOnlineAsyncTaskRailGetUserPresence();
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual FString ToString() const override;
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
protected:
|
|
|
|
/** Has the list of keys been queried */
|
|
bool bKeysQueried;
|
|
virtual void OnRailEventFriendsGetMetadataResult(const rail::rail_event::RailFriendsGetMetadataResult* MetadataResult) override;
|
|
};
|
|
|
|
/**
|
|
* Result structure after getting a user command line invite
|
|
*/
|
|
struct FGetInviteCommandLineTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** User whose command line invite was retrieved */
|
|
FUniqueNetIdRailPtr UserId;
|
|
/** Retrieved command line */
|
|
FString Commandline;
|
|
};
|
|
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailGetInviteCommandLineComplete, const FGetInviteCommandLineTaskResult& /*Result*/);
|
|
|
|
class FOnlineAsyncTaskRailGetInviteCommandline
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailGetInviteCommandline() = delete;
|
|
FOnlineAsyncTaskRailGetInviteCommandline(FOnlineSubsystemTencent* InSubsystem, const FUniqueNetIdRail& InUserId, const FOnOnlineAsyncTaskRailGetInviteCommandLineComplete& InCompletionDelegate);
|
|
virtual ~FOnlineAsyncTaskRailGetInviteCommandline();
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailGetInviteCommandline bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventFriendsGetInviteCommandLine(const rail::rail_event::RailFriendsGetInviteCommandLine* InviteResult);
|
|
|
|
/** User to query presence for */
|
|
rail::RailID RailUserId;
|
|
/** Output result from the task */
|
|
FGetInviteCommandLineTaskResult TaskResult;
|
|
/** Delegate to fire when this task is completed */
|
|
FOnOnlineAsyncTaskRailGetInviteCommandLineComplete CompletionDelegate;
|
|
};
|
|
|
|
/**
|
|
* Result structure after getting a complete user invite
|
|
*/
|
|
struct FGetUserInviteTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** User whose invite was retrieved */
|
|
FUniqueNetIdRailPtr UserId;
|
|
/** Retrieved presence information */
|
|
FMetadataPropertiesRail Metadata;
|
|
/** Retrieved presence information */
|
|
FString Commandline;
|
|
};
|
|
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailGetUserInviteComplete, const FGetUserInviteTaskResult& /*Result*/);
|
|
|
|
class FOnlineAsyncTaskRailGetUserInvite
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailGetUserInvite() = delete;
|
|
FOnlineAsyncTaskRailGetUserInvite(FOnlineSubsystemTencent* InSubsystem, const FUniqueNetIdRail& InUserId, const FOnOnlineAsyncTaskRailGetUserInviteComplete& InCompletionDelegate);
|
|
virtual ~FOnlineAsyncTaskRailGetUserInvite();
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailGetUserInvite Meta: %d CmdLine: %d"), static_cast<int32>(MetadataReceivedResult), static_cast<int32>(CommandLineResult)); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventFriendsGetMetadataResult(const rail::rail_event::RailFriendsGetMetadataResult* MetadataResult);
|
|
void OnRailEventFriendsGetInviteCommandLine(const rail::rail_event::RailFriendsGetInviteCommandLine* InviteResult);
|
|
/** Called when each event completes to check for total completion */
|
|
void OnEventComplete();
|
|
|
|
/**
|
|
* Get the session invite keys out of the command line
|
|
*
|
|
* @param InviteCommandLine string containing a list of session invite related keys to retrieve from a remote user
|
|
*/
|
|
void RetrieveFromInviteCommandLine(const FString& InviteCommandline);
|
|
|
|
/** Has the metadata callback fired */
|
|
bool bMetadataReceived;
|
|
/** Result of the metadata callback */
|
|
rail::RailResult MetadataReceivedResult;
|
|
/** Has the command line callback fired */
|
|
bool bCommandLineReceived;
|
|
/** Result of the command line callback */
|
|
rail::RailResult CommandLineResult;
|
|
|
|
/** User to query invite from (Inviter) */
|
|
rail::RailID RailUserId;
|
|
/** Presence retrieved for this user used to build session search result */
|
|
TArray<FString> MetadataKeys;
|
|
/** Output result from the task */
|
|
FGetUserInviteTaskResult TaskResult;
|
|
/** Delegate to fire when this task is completed */
|
|
FOnOnlineAsyncTaskRailGetUserInviteComplete CompletionDelegate;
|
|
};
|
|
|
|
class FOnlineAsyncTaskRailClearAllMetadata
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailClearAllMetadata() = delete;
|
|
FOnlineAsyncTaskRailClearAllMetadata(FOnlineSubsystemTencent* InSubsystem, const FUniqueNetIdRail& InUserId);
|
|
virtual ~FOnlineAsyncTaskRailClearAllMetadata();
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailClearAllMetadata bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventFriendsClearAllMetadataResult(const rail::rail_event::RailFriendsClearMetadataResult* MetadataResult);
|
|
|
|
/** User to clear metadata for */
|
|
rail::RailID RailUserId;
|
|
FOnlineError TaskResult;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailAddFriend completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailAddFriendComplete, const FOnlineError& /*Result*/);
|
|
|
|
class FOnlineAsyncTaskRailAddFriend
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailAddFriend() = delete;
|
|
/**
|
|
* Constructor
|
|
* @param InSubsystem the owning subsystem
|
|
* @param InUserId the rail id of the player you want to friend
|
|
* @param InCompletionDelegate the delegate to trigger when this request has completed
|
|
*/
|
|
FOnlineAsyncTaskRailAddFriend(FOnlineSubsystemTencent* InSubsystem, const FUniqueNetIdRail& InUserId, const FOnOnlineAsyncTaskRailAddFriendComplete& InCompletionDelegate);
|
|
virtual ~FOnlineAsyncTaskRailAddFriend();
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailAddFriend bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventFriendsAddFriendResult(const rail::rail_event::RailFriendsAddFriendResult* AddFriendResult);
|
|
|
|
/** User to friend */
|
|
rail::RailID RailUserId;
|
|
/** The result of the add friend request */
|
|
FOnlineError TaskResult;
|
|
/** Delegate to trigger on completion */
|
|
FOnOnlineAsyncTaskRailAddFriendComplete CompletionDelegate;
|
|
};
|
|
|
|
/**
|
|
* Result structure after getting users info
|
|
*/
|
|
struct FGetUsersInfoTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** Users successfully queried */
|
|
TArray<TSharedRef<FOnlineUserInfoTencent>> UserInfos;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailGetUsersInfo completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailGetUsersInfoComplete, const FGetUsersInfoTaskResult& /*Result*/);
|
|
|
|
class FOnlineAsyncTaskRailGetUsersInfo
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailGetUsersInfo() = delete;
|
|
FOnlineAsyncTaskRailGetUsersInfo(FOnlineSubsystemTencent* InSubsystem, const TArray<FUniqueNetIdRef>& InUserIds, const FOnOnlineAsyncTaskRailGetUsersInfoComplete& InCompletionDelegate);
|
|
virtual ~FOnlineAsyncTaskRailGetUsersInfo() = default;
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailGetUsersInfo bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
void OnRailEventUsersGetUsersInfo(const rail::rail_event::RailUsersInfoData* UsersInfoData);
|
|
|
|
/** Request id counter so we can map rail responses to the correct requests */
|
|
static FThreadSafeCounter RequestIdCounter;
|
|
/** Our request id */
|
|
int32 RequestId;
|
|
/** User to get data for */
|
|
TArray<FUniqueNetIdRef> UserIds;
|
|
/** Result of the task */
|
|
FGetUsersInfoTaskResult TaskResult;
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailGetUsersInfoComplete CompletionDelegate;
|
|
};
|
|
|
|
class FOnlineAsyncEventRailSystemStateChanged
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncEventRailSystemStateChanged() = delete;
|
|
FOnlineAsyncEventRailSystemStateChanged(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::RailSystemStateChanged* InParams)
|
|
: FOnlineAsyncEventRail(InSubsystem)
|
|
, State(InParams ? InParams->state : rail::RailSystemState::kSystemStateUnknown)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncEventRailSystemStateChanged() = default;
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override
|
|
{
|
|
return FString::Printf(TEXT("FOnlineAsyncEventRailSystemStateChanged State: %s"), *LexToString(State));
|
|
}
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
protected:
|
|
|
|
rail::RailSystemState State;
|
|
};
|
|
|
|
class FOnlineAsyncEventRailShowFloatingWindow
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncEventRailShowFloatingWindow() = delete;
|
|
FOnlineAsyncEventRailShowFloatingWindow(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::ShowFloatingWindowResult* InParams);
|
|
|
|
virtual ~FOnlineAsyncEventRailShowFloatingWindow()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncEvent interface
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncEventRailShowFloatingWindow Result: %s bWasOpened: %d"), *TaskResult.Error.ToLogString(), TaskResult.bOpened); }
|
|
//~ End FOnlineAsyncEvent interface
|
|
|
|
protected:
|
|
|
|
/** Result of the task */
|
|
FFloatingWindowTaskResult TaskResult;
|
|
};
|
|
|
|
struct FOnlineAsyncEventRailShowFloatingNotifyWindowPayload
|
|
: public FOnlineJsonSerializable
|
|
{
|
|
public:
|
|
/** Title of dialog to display*/
|
|
FString DialogTitle;
|
|
/** Text of dialog to display */
|
|
FString DialogText;
|
|
/** Text to display in OK button */
|
|
FString ButtonText;
|
|
|
|
public:
|
|
BEGIN_ONLINE_JSON_SERIALIZER
|
|
ONLINE_JSON_SERIALIZE("title", DialogTitle);
|
|
ONLINE_JSON_SERIALIZE("desc", DialogText);
|
|
ONLINE_JSON_SERIALIZE("confirm_button", ButtonText);
|
|
END_ONLINE_JSON_SERIALIZER
|
|
};
|
|
|
|
class FOnlineAsyncEventRailShowFloatingNotifyWindow
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncEventRailShowFloatingNotifyWindow() = delete;
|
|
FOnlineAsyncEventRailShowFloatingNotifyWindow(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::ShowNotifyWindow* InParams);
|
|
|
|
virtual ~FOnlineAsyncEventRailShowFloatingNotifyWindow()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncEvent interface
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncEventRailShowFloatingNotifyWindow")); }
|
|
//~ End FOnlineAsyncEvent interface
|
|
|
|
bool bShowAntiAddictionMessage;
|
|
FOnlineAsyncEventRailShowFloatingNotifyWindowPayload Payload;
|
|
|
|
};
|
|
|
|
class FOnlineAsyncEventRailInviteSent
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncEventRailInviteSent() = delete;
|
|
FOnlineAsyncEventRailInviteSent(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::RailUsersNotifyInviter* InParams)
|
|
: FOnlineAsyncEventRail(InSubsystem)
|
|
, Result(InParams ? InParams->get_result() : rail::kErrorUnknown)
|
|
, InviterId(InParams ? InParams->rail_id : rail::kInvalidRailId)
|
|
, InviteeId(InParams ? InParams->invitee_id : rail::kInvalidRailId)
|
|
, UserData(InParams ? InParams->user_data : rail::RailString())
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncEventRailInviteSent()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncEventRailInviteSent Inviter: %llu Invitee: %llu bWasSuccessful: %d"), InviterId.get_id(), InviteeId.get_id(), (Result == rail::kSuccess)); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
protected:
|
|
|
|
/** Result of the invite sent event */
|
|
rail::RailResult Result;
|
|
/** User id who sent the invite */
|
|
rail::RailID InviterId;
|
|
/** User id who will receive the invite */
|
|
rail::RailID InviteeId;
|
|
/** User data returned with the call */
|
|
rail::RailString UserData;
|
|
};
|
|
|
|
class FOnlineAsyncEventRailInviteSentEx
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncEventRailInviteSentEx() = delete;
|
|
FOnlineAsyncEventRailInviteSentEx(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::RailUsersInviteUsersResult* InParams)
|
|
: FOnlineAsyncEventRail(InSubsystem)
|
|
, Result(InParams ? InParams->get_result() : rail::kErrorUnknown)
|
|
, InviteType(InParams ? InParams->invite_type : rail::kRailUsersInviteTypeGame)
|
|
, UserData(InParams ? InParams->user_data : rail::RailString())
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncEventRailInviteSentEx()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncEventRailInviteSentEx bWasSuccessful: %d"), (Result == rail::kSuccess)); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
protected:
|
|
|
|
/** Result of the invite sent event */
|
|
rail::RailResult Result;
|
|
/** Type of invite */
|
|
rail::EnumRailUsersInviteType InviteType;
|
|
/** User data returned with the call */
|
|
rail::RailString UserData;
|
|
};
|
|
|
|
class FOnlineAsyncEventRailInviteResponse
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncEventRailInviteResponse() = delete;
|
|
FOnlineAsyncEventRailInviteResponse(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::RailUsersRespondInvitation* InParams)
|
|
: FOnlineAsyncEventRail(InSubsystem)
|
|
, Result(InParams ? InParams->get_result() : rail::kErrorUnknown)
|
|
, InviterId(InParams ? InParams->inviter_id : rail::kInvalidRailId)
|
|
, InviteeId(InParams ? InParams->rail_id : rail::kInvalidRailId)
|
|
, UserData(InParams ? InParams->user_data : rail::RailString())
|
|
, Response(InParams ? InParams->response : rail::kRailInviteResponseTypeUnknown)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncEventRailInviteResponse()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncEventRailInviteResponse Inviter: %llu Invitee: %llu bWasSuccessful: %d"), InviterId.get_id(), InviteeId.get_id(), (Result == rail::kSuccess)); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
protected:
|
|
|
|
/** Result of the invite response event */
|
|
rail::RailResult Result;
|
|
/** User id who sent the invite */
|
|
rail::RailID InviterId;
|
|
/** User id who received the invite */
|
|
rail::RailID InviteeId;
|
|
/** User data returned with the call */
|
|
rail::RailString UserData;
|
|
/** Invitees response to the invite */
|
|
rail::EnumRailUsersInviteResponseType Response;
|
|
};
|
|
|
|
class FOnlineAsyncEventRailJoinGameByUser
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncEventRailJoinGameByUser() = delete;
|
|
FOnlineAsyncEventRailJoinGameByUser(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::RailPlatformNotifyEventJoinGameByUser* InParams)
|
|
: FOnlineAsyncEventRail(InSubsystem)
|
|
, Result(InParams ? InParams->get_result() : rail::kErrorUnknown)
|
|
, UserToJoin(InParams ? InParams->rail_id_to_join : rail::kInvalidRailId)
|
|
, CommandLine(InParams ? InParams->commandline_info : rail::RailString())
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncEventRailJoinGameByUser()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncEventRailJoinGameByUser RemoteUser: %llu Commandline: %s bWasSuccessful: %d"), UserToJoin.get_id(), ANSI_TO_TCHAR(CommandLine.c_str()), (Result == rail::kSuccess)); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
protected:
|
|
|
|
/** Result of the invite response event */
|
|
rail::RailResult Result;
|
|
/** Remote user to join */
|
|
rail::RailID UserToJoin;
|
|
/** Commandline invite of remote user */
|
|
rail::RailString CommandLine;
|
|
};
|
|
|
|
class FOnlineAsyncEventRailJoinGameResult
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncEventRailJoinGameResult() = delete;
|
|
FOnlineAsyncEventRailJoinGameResult(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::RailUsersInviteJoinGameResult* InParams)
|
|
: FOnlineAsyncEventRail(InSubsystem)
|
|
, Result(InParams ? InParams->get_result() : rail::kErrorUnknown)
|
|
, InviterId(InParams ? InParams->rail_id : rail::kInvalidRailId)
|
|
, InviteeId(InParams ? InParams->invitee_id : rail::kInvalidRailId)
|
|
, UserData(InParams ? InParams->user_data : rail::RailString())
|
|
, Response(InParams ? InParams->response_value : rail::kRailInviteResponseTypeUnknown)
|
|
, InviteType(InParams ? InParams->invite_type : rail::kRailUsersInviteTypeGame)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncEventRailJoinGameResult()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncEventRailJoinGameResult Inviter: %llu Invitee: %llu bWasSuccessful: %d"), InviterId.get_id(), InviteeId.get_id(), (Result == rail::kSuccess)); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
protected:
|
|
|
|
/** Result of the join game event */
|
|
rail::RailResult Result;
|
|
/** User id who sent the invite */
|
|
rail::RailID InviterId;
|
|
/** User id who received the invite */
|
|
rail::RailID InviteeId;
|
|
/** User data returned with the call */
|
|
rail::RailString UserData;
|
|
/** Invitees response to the invite */
|
|
rail::EnumRailUsersInviteResponseType Response;
|
|
/** Type of invite sent */
|
|
rail::EnumRailUsersInviteType InviteType;
|
|
};
|
|
|
|
class FOnlineAsyncEventRailFriendsListChanged
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
public:
|
|
|
|
FOnlineAsyncEventRailFriendsListChanged() = delete;
|
|
FOnlineAsyncEventRailFriendsListChanged(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::RailFriendsListChanged* InParams)
|
|
: FOnlineAsyncEventRail(InSubsystem)
|
|
, UserId(InParams->rail_id)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncEventRailFriendsListChanged() = default;
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override
|
|
{
|
|
return FString::Printf(TEXT("FOnlineAsyncEventRailFriendsListChanged"));
|
|
}
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
private:
|
|
/** The user id whose list has changed */
|
|
rail::RailID UserId;
|
|
};
|
|
|
|
class FOnlineAsyncEventRailFriendsOnlineStateChanged
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
public:
|
|
|
|
FOnlineAsyncEventRailFriendsOnlineStateChanged() = delete;
|
|
FOnlineAsyncEventRailFriendsOnlineStateChanged(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::RailFriendsOnlineStateChanged* InParams)
|
|
: FOnlineAsyncEventRail(InSubsystem)
|
|
, OnlineState(InParams ? InParams->friend_online_state : rail::RailFriendOnLineState())
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncEventRailFriendsOnlineStateChanged() = default;
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Finalize() override;
|
|
virtual FString ToString() const override
|
|
{
|
|
return FString::Printf(TEXT("FOnlineAsyncEventRailFriendsOnlineStateChanged friend_rail_id=%llu, friend_online_state=%s, game_define_game_playing_state=%u"),
|
|
OnlineState.friend_rail_id.get_id(), *LexToString(OnlineState.friend_online_state), OnlineState.game_define_game_playing_state);
|
|
}
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
private:
|
|
/** Data related to the online state change */
|
|
rail::RailFriendOnLineState OnlineState;
|
|
};
|
|
|
|
class FOnlineAsyncEventRailFriendsMetadataChanged
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
public:
|
|
|
|
FOnlineAsyncEventRailFriendsMetadataChanged() = delete;
|
|
FOnlineAsyncEventRailFriendsMetadataChanged(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::RailFriendsMetadataChanged* InParams);
|
|
|
|
virtual ~FOnlineAsyncEventRailFriendsMetadataChanged() = default;
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override
|
|
{
|
|
return FString::Printf(TEXT("FOnlineAsyncEventRailFriendsMetadataChanged size: %d"), ChangedMetadata.Num());
|
|
}
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
private:
|
|
/** Data related to the metadata change */
|
|
TUniqueNetIdMap<FMetadataPropertiesRail> ChangedMetadata;
|
|
};
|
|
|
|
/**
|
|
* Result structure after getting users presence
|
|
*/
|
|
struct FQueryUserPresenceTaskResult
|
|
{
|
|
FQueryUserPresenceTaskResult()
|
|
: QueryCount(0)
|
|
, SuccessCount(0)
|
|
{}
|
|
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** Number of completed queries */
|
|
int32 QueryCount;
|
|
/** Number of successful queries */
|
|
int32 SuccessCount;
|
|
};
|
|
|
|
/**
|
|
* Query a list of friends presence to prime the presence cache
|
|
*/
|
|
class FOnlineAsyncTaskRailQueryFriendsPresence
|
|
: public FOnlineAsyncTaskBasic<FOnlineSubsystemTencent>
|
|
{
|
|
|
|
public:
|
|
|
|
/** Delegate fired when this task completed */
|
|
DECLARE_DELEGATE_OneParam(FCompletionDelegate, const FQueryUserPresenceTaskResult& /*TaskResult*/);
|
|
|
|
FOnlineAsyncTaskRailQueryFriendsPresence() = delete;
|
|
FOnlineAsyncTaskRailQueryFriendsPresence(FOnlineSubsystemTencent* InSubsystem, TArray<FUniqueNetIdRef>& InFriends, const FCompletionDelegate& InCompletionDelegate)
|
|
: FOnlineAsyncTaskBasic(InSubsystem)
|
|
, CompletionDelegate(InCompletionDelegate)
|
|
, FriendsList(InFriends)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailQueryFriendsPresence()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailQueryFriendsPresence bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
protected:
|
|
|
|
/** Completion delegate to fire */
|
|
FCompletionDelegate CompletionDelegate;
|
|
/** List of friends whose presence data is requested */
|
|
TArray<FUniqueNetIdRef> FriendsList;
|
|
/** Result of operation */
|
|
FQueryUserPresenceTaskResult TaskResult;
|
|
};
|
|
|
|
/**
|
|
* Result structure after sending an invite
|
|
*/
|
|
struct FSendInviteTaskResult
|
|
{
|
|
FSendInviteTaskResult() = delete;
|
|
FSendInviteTaskResult(const FString& InInviteStr)
|
|
: InviteStr(InInviteStr)
|
|
{ }
|
|
|
|
/** Invite command line */
|
|
FString InviteStr;
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailSendInvite completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailSendInviteComplete, const FSendInviteTaskResult& /*Result*/);
|
|
|
|
/**
|
|
* Send an invite to a list of friends
|
|
* Contains a string with the various metadata keys to query relating to the invite
|
|
*/
|
|
class FOnlineAsyncTaskRailSendInvite
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailSendInvite() = delete;
|
|
FOnlineAsyncTaskRailSendInvite(FOnlineSubsystemTencent* InSubsystem, const FString& InInviteStr, const TArray<FUniqueNetIdRef>& InUserIds, const FOnOnlineAsyncTaskRailSendInviteComplete& InCompletionDelegate)
|
|
: FOnlineAsyncTaskRail(InSubsystem, {rail::kRailEventUsersInviteUsersResult})
|
|
, UserIds(InUserIds)
|
|
, CompletionDelegate(InCompletionDelegate)
|
|
, TaskResult(InInviteStr)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailSendInvite()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailSendInvite bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventFriendsSendInviteResult(const rail::rail_event::RailUsersInviteUsersResult* InviteResult);
|
|
|
|
/** List of users to send invite to */
|
|
TArray<FUniqueNetIdRef> UserIds;
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailSendInviteComplete CompletionDelegate;
|
|
/** Task Result */
|
|
FSendInviteTaskResult TaskResult;
|
|
};
|
|
|
|
/**
|
|
* Result structure after retrieving details about an invite
|
|
*/
|
|
struct FGetInviteDetailsTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** Invite Details */
|
|
FString InviteString;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailGetInviteDetails completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailGetInviteDetailsComplete, const FGetInviteDetailsTaskResult& /*Result*/);
|
|
|
|
/**
|
|
* Get the details related to an invite sent by a remote user
|
|
*/
|
|
class FOnlineAsyncTaskRailGetInviteDetails
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailGetInviteDetails() = delete;
|
|
FOnlineAsyncTaskRailGetInviteDetails(FOnlineSubsystemTencent* InSubsystem, const FUniqueNetIdRail& InUserId, const FOnOnlineAsyncTaskRailGetInviteDetailsComplete& InCompletionDelegate);
|
|
|
|
virtual ~FOnlineAsyncTaskRailGetInviteDetails()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailGetInviteDetails bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventFriendsGetInviteDetailsResult(const rail::rail_event::RailUsersGetInviteDetailResult* InviteDetails);
|
|
|
|
/** User to query presence for */
|
|
rail::RailID RailUserId;
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailGetInviteDetailsComplete CompletionDelegate;
|
|
/** Task Result */
|
|
FGetInviteDetailsTaskResult TaskResult;
|
|
};
|
|
|
|
/**
|
|
* Result structure containing details about friends playing games on the platform
|
|
*/
|
|
struct FQueryFriendPlayedGamesTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** Friend queried */
|
|
FUniqueNetIdRailPtr FriendId;
|
|
|
|
struct FRailGamePlayedInfo
|
|
{
|
|
/** Are we in a Rail Server (not implemented) */
|
|
bool bInServer;
|
|
/** Are we in a Rail Room (not implemented) */
|
|
bool bInRoom;
|
|
///** Server Id */
|
|
//uint64 ServerId;
|
|
///** Room Id */
|
|
//uint64 RoomId;
|
|
/** Id of the game being played */
|
|
rail::RailGameID GameId;
|
|
/** Game state of the user */
|
|
rail::RailFriendPlayedGamePlayState GamePlayState;
|
|
};
|
|
|
|
/** Array of games being played on the platform */
|
|
TArray<FRailGamePlayedInfo> GameInfos;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailQueryFriendPlayedGamesInfo completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailQueryFriendPlayedGamesComplete, const FQueryFriendPlayedGamesTaskResult& /*Result*/);
|
|
|
|
/**
|
|
* Get details about a friend playing games on the RailSDK
|
|
* May contain an array of games information if the user has more than one open at the same time
|
|
*/
|
|
class FOnlineAsyncTaskRailQueryFriendPlayedGamesInfo
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailQueryFriendPlayedGamesInfo() = delete;
|
|
FOnlineAsyncTaskRailQueryFriendPlayedGamesInfo(FOnlineSubsystemTencent* InSubsystem, const FUniqueNetIdRail& InUserId, const FOnOnlineAsyncTaskRailQueryFriendPlayedGamesComplete& InCompletionDelegate);
|
|
|
|
virtual ~FOnlineAsyncTaskRailQueryFriendPlayedGamesInfo()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailQueryFriendPlayedGamesInfo bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventQueryFriendPlayedGamesResult(const rail::rail_event::RailFriendsQueryFriendPlayedGamesResult* PlayedGamesDetail);
|
|
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailQueryFriendPlayedGamesComplete CompletionDelegate;
|
|
/** Task Result */
|
|
FQueryFriendPlayedGamesTaskResult TaskResult;
|
|
};
|
|
|
|
/**
|
|
* Result structure containing details reporting players that were played with
|
|
*/
|
|
struct FReportPlayedWithUsersTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** Users reported */
|
|
TArray<FReportPlayedWithUser> UsersReported;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailReportPlayedWithUsers completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailReportPlayedWithUsersComplete, const FReportPlayedWithUsersTaskResult& /*Result*/);
|
|
|
|
/**
|
|
* Report details about a players that have been seen over the course of a game
|
|
*/
|
|
class FOnlineAsyncTaskRailReportPlayedWithUsers
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailReportPlayedWithUsers() = delete;
|
|
FOnlineAsyncTaskRailReportPlayedWithUsers(FOnlineSubsystemTencent* InSubsystem, const TArray<FReportPlayedWithUser>& InUsersReported, const FOnOnlineAsyncTaskRailReportPlayedWithUsersComplete& InCompletionDelegate);
|
|
|
|
virtual ~FOnlineAsyncTaskRailReportPlayedWithUsers()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailReportPlayedWithUsers bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventReportPlayedWithUsers(const rail::rail_event::RailFriendsReportPlayedWithUserListResult* PlayedGamesDetail);
|
|
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailReportPlayedWithUsersComplete CompletionDelegate;
|
|
/** Task Result */
|
|
FReportPlayedWithUsersTaskResult TaskResult;
|
|
};
|
|
|
|
/**
|
|
* Result structure containing details of users last played with (not just friends)
|
|
*/
|
|
struct FQueryPlayedWithFriendsListTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** Users reported */
|
|
TArray<FUniqueNetIdRef> UsersPlayedWith;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailQueryPlayedWithFriendsList completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailQueryPlayedWithFriendsListComplete, const FQueryPlayedWithFriendsListTaskResult& /*Result*/);
|
|
|
|
/**
|
|
* Report details about users the local user has played with
|
|
*/
|
|
class FOnlineAsyncTaskRailQueryPlayedWithFriendsList
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailQueryPlayedWithFriendsList() = delete;
|
|
FOnlineAsyncTaskRailQueryPlayedWithFriendsList(FOnlineSubsystemTencent* InSubsystem, const FOnOnlineAsyncTaskRailQueryPlayedWithFriendsListComplete& InCompletionDelegate);
|
|
|
|
virtual ~FOnlineAsyncTaskRailQueryPlayedWithFriendsList()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailQueryPlayedWithFriendsList bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventPlayedWithFriendsList(const rail::rail_event::RailFriendsQueryPlayedWithFriendsListResult* PlayedFriendsList);
|
|
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailQueryPlayedWithFriendsListComplete CompletionDelegate;
|
|
/** Task Result */
|
|
FQueryPlayedWithFriendsListTaskResult TaskResult;
|
|
};
|
|
|
|
/**
|
|
* Result structure containing details of the time a user was last seen
|
|
*/
|
|
struct FQueryPlayedWithFriendsTimeTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** List of users to query */
|
|
TArray<FUniqueNetIdRef> UserIds;
|
|
/** Last seen info for a single player */
|
|
struct FRecentPlayers
|
|
{
|
|
FRecentPlayers() = delete;
|
|
FRecentPlayers(const FUniqueNetIdRef InUserId, const FDateTime& InLastPlayed)
|
|
: UserId(InUserId)
|
|
, LastPlayed(InLastPlayed)
|
|
{
|
|
|
|
}
|
|
FUniqueNetIdRef UserId;
|
|
FDateTime LastPlayed;
|
|
};
|
|
/** All users reported as being seen by this user */
|
|
TArray<FRecentPlayers> LastPlayedWithUsers;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailQueryPlayedWithFriendsList completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailQueryPlayedWithFriendsTimeComplete, const FQueryPlayedWithFriendsTimeTaskResult& /*Result*/);
|
|
|
|
/**
|
|
* Report details about users the local user has played with
|
|
*/
|
|
class FOnlineAsyncTaskRailQueryPlayedWithFriendsTime
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailQueryPlayedWithFriendsTime() = delete;
|
|
FOnlineAsyncTaskRailQueryPlayedWithFriendsTime(FOnlineSubsystemTencent* InSubsystem, const TArray<FUniqueNetIdRef>& InUserIds, const FOnOnlineAsyncTaskRailQueryPlayedWithFriendsTimeComplete& InCompletionDelegate);
|
|
|
|
virtual ~FOnlineAsyncTaskRailQueryPlayedWithFriendsTime()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void Finalize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailQueryPlayedWithFriendsTime bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID event_id, rail::EventBase* param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailEventPlayedWithFriendsTime(const rail::rail_event::RailFriendsQueryPlayedWithFriendsTimeResult* PlayedTimeResult);
|
|
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailQueryPlayedWithFriendsTimeComplete CompletionDelegate;
|
|
/** Task Result */
|
|
FQueryPlayedWithFriendsTimeTaskResult TaskResult;
|
|
};
|
|
|
|
/**
|
|
* Result structure for requesting all receipts
|
|
*/
|
|
struct FRequestAllAssetsTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** Purchase receipts */
|
|
FPurchaseReceipt PurchaseReceipt;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailQueryFriendPlayedGamesInfo completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailRequestAllAssetsComplete, const FRequestAllAssetsTaskResult& /*Result*/);
|
|
|
|
class FOnlineAsyncTaskRailRequestAllAssets
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
public:
|
|
FOnlineAsyncTaskRailRequestAllAssets() = delete;
|
|
FOnlineAsyncTaskRailRequestAllAssets(FOnlineSubsystemTencent* InSubsystem, const FUniqueNetIdRef& InUserId, const FOnOnlineAsyncTaskRailRequestAllAssetsComplete& InCompletionDelegate)
|
|
: FOnlineAsyncTaskRail(InSubsystem, {rail::kRailEventAssetsRequestAllAssetsFinished})
|
|
, UserId(InUserId)
|
|
, CompletionDelegate(InCompletionDelegate)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailRequestAllAssets()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailRequestAllAssets bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID EventId, rail::EventBase* Param) override;
|
|
//~ End IRailEvent interface
|
|
protected:
|
|
|
|
void OnRailRequestAllAssetsFinished(const rail::rail_event::RequestAllAssetsFinished* AssetsResponse);
|
|
|
|
/** User we are requesting assets for */
|
|
const FUniqueNetIdRef UserId;
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailRequestAllAssetsComplete CompletionDelegate;
|
|
/** Task Result */
|
|
FRequestAllAssetsTaskResult TaskResult;
|
|
};
|
|
|
|
class FOnlineAsyncEventRailAssetsChanged
|
|
: public FOnlineAsyncEventRail
|
|
{
|
|
public:
|
|
|
|
FOnlineAsyncEventRailAssetsChanged() = delete;
|
|
FOnlineAsyncEventRailAssetsChanged(FOnlineSubsystemTencent* InSubsystem, const rail::rail_event::RailAssetsChanged* InParams);
|
|
|
|
virtual ~FOnlineAsyncEventRailAssetsChanged() = default;
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override
|
|
{
|
|
return FString::Printf(TEXT("FOnlineAsyncEventRailAssetsChanged"));
|
|
}
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
private:
|
|
};
|
|
|
|
/**
|
|
* Result structure for requesting all purchasable products
|
|
*/
|
|
struct FRequestAllPurchasableProductsTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** Purchasable products */
|
|
TArray<FOnlineStoreOfferRef> Offers;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailRequestAllPurchasableProducts completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailRequestAllPurchasableProductsComplete, const FRequestAllPurchasableProductsTaskResult& /*Result*/);
|
|
|
|
class FOnlineAsyncTaskRailRequestAllPurchasableProducts
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailRequestAllPurchasableProducts() = delete;
|
|
FOnlineAsyncTaskRailRequestAllPurchasableProducts(FOnlineSubsystemTencent* InSubsystem, const FOnOnlineAsyncTaskRailRequestAllPurchasableProductsComplete& InCompletionDelegate)
|
|
: FOnlineAsyncTaskRail(InSubsystem, {rail::kRailEventInGamePurchaseAllPurchasableProductsInfoReceived})
|
|
, CompletionDelegate(InCompletionDelegate)
|
|
{
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailRequestAllPurchasableProducts()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailRequestAllPurchasableProducts bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID EventId, rail::EventBase* Param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailRequestAllPurchasableProductsResponse(rail::rail_event::RailInGamePurchaseRequestAllPurchasableProductsResponse* Response);
|
|
|
|
/** Result of the task */
|
|
FRequestAllPurchasableProductsTaskResult TaskResult;
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailRequestAllPurchasableProductsComplete CompletionDelegate;
|
|
};
|
|
|
|
/**
|
|
* Result structure for purchasing products
|
|
*/
|
|
struct FPurchaseProductsTaskResult
|
|
{
|
|
/** Error information */
|
|
FOnlineError Error;
|
|
/** Purchase receipt, if successful */
|
|
TSharedPtr<FPurchaseReceipt> PurchaseReceipt;
|
|
};
|
|
|
|
/**
|
|
* Delegate fired when FOnlineAsyncTaskRailPurchaseProducts completes
|
|
*
|
|
* @param Result the result of the call
|
|
*/
|
|
DECLARE_DELEGATE_OneParam(FOnOnlineAsyncTaskRailPurchaseProductsComplete, const FPurchaseProductsTaskResult& /*Result*/);
|
|
|
|
class FOnlineAsyncTaskRailPurchaseProducts
|
|
: public FOnlineAsyncTaskRail
|
|
{
|
|
|
|
public:
|
|
|
|
FOnlineAsyncTaskRailPurchaseProducts() = delete;
|
|
FOnlineAsyncTaskRailPurchaseProducts(FOnlineSubsystemTencent* InSubsystem, const FUniqueNetIdRef& InUserId, const FPurchaseCheckoutRequest& InCheckoutRequest, const FOnOnlineAsyncTaskRailPurchaseProductsComplete& InCompletionDelegate)
|
|
: FOnlineAsyncTaskRail(InSubsystem, {rail::kRailEventInGamePurchasePurchaseProductsToAssetsResult})
|
|
, UserId(InUserId)
|
|
, CheckoutRequest(InCheckoutRequest)
|
|
, CompletionDelegate(InCompletionDelegate)
|
|
{
|
|
// User will be in a dialog, allow the user to take their time.
|
|
bCanTimeout = false;
|
|
}
|
|
|
|
virtual ~FOnlineAsyncTaskRailPurchaseProducts()
|
|
{
|
|
}
|
|
|
|
//~ Begin FOnlineAsyncTask interface
|
|
virtual void Initialize() override;
|
|
virtual void TriggerDelegates() override;
|
|
virtual FString ToString() const override { return FString::Printf(TEXT("FOnlineAsyncTaskRailPurchaseProducts bWasSuccessful: %d"), WasSuccessful()); }
|
|
//~ End FOnlineAsyncTask interface
|
|
|
|
//~ Begin IRailEvent interface
|
|
virtual void OnRailEvent(rail::RAIL_EVENT_ID EventId, rail::EventBase* Param) override;
|
|
//~ End IRailEvent interface
|
|
|
|
protected:
|
|
|
|
void OnRailPurchaseProductsToAssetsResult(rail::rail_event::RailInGamePurchasePurchaseProductsToAssetsResponse* Response);
|
|
void HandlePurchaseProductsResult(const TOptional<rail::RailResult> RailResult);
|
|
|
|
/** User performing the purchase */
|
|
const FUniqueNetIdRef UserId;
|
|
/** Items to purchase */
|
|
FPurchaseCheckoutRequest CheckoutRequest;
|
|
/** Result of the task */
|
|
FPurchaseProductsTaskResult TaskResult;
|
|
/** Delegate to fire on completion */
|
|
FOnOnlineAsyncTaskRailPurchaseProductsComplete CompletionDelegate;
|
|
};
|
|
|
|
#endif // WITH_TENCENT_RAIL_SDK
|