Switch to VRExpansionPlugin Example 2

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/AdvancedSteamSessions.uplugin

@@ -0,0 +1,38 @@
+{
+    "FileVersion" : 3,
+ 
+    "FriendlyName" : "Advanced Steam Sessions",
+    "Version" : 5.1,
+    "VersionName": "5.1",
+    "Description" : "Adds new blueprint functions to handle more advanced session operations in Steam. REQUIRES ADVANCED SESSIONS",
+    "Category" : "Advanced Sessions Plugin",
+    "CreatedBy" : "Joshua Statzer",
+    "CreatedByURL" : "N/A",
+ 
+    "Modules" :
+    [
+        {
+            "Name" : "AdvancedSteamSessions",
+            "Type" : "RunTime",
+	    "LoadingPhase" : "PreDefault"
+        } 
+    ],
+	"Plugins": [
+		{
+			"Name": "AdvancedSessions",
+			"Enabled": true
+		},
+		{
+			"Name": "OnlineSubsystem",
+			"Enabled": true
+		},
+		{
+			"Name": "OnlineSubsystemUtils",
+			"Enabled": true
+		},
+		{
+			"Name": "SteamShared",
+			"Enabled": true
+		}
+	]
+}

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Config/FilterPlugin.ini

@@ -0,0 +1,8 @@
+[FilterPlugin]
+; This section lists additional files which will be packaged along with your plugin. Paths should be listed relative to the root plugin directory, and
+; may include "...", "*", and "?" wildcards to match directories, files, and individual characters respectively.
+;
+; Examples:
+;    /README.txt
+;    /Extras/...
+;    /Binaries/ThirdParty/*.dll

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/AdvancedSteamSessions.Build.cs

@@ -0,0 +1,22 @@
+using UnrealBuildTool;
+using System.IO;
+ 
+public class AdvancedSteamSessions : ModuleRules
+{
+    public AdvancedSteamSessions(ReadOnlyTargetRules Target) : base(Target)
+    {
+        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
+        //bEnforceIWYU = true;
+
+        PublicDefinitions.Add("WITH_ADVANCED_STEAM_SESSIONS=1");
+
+        PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "OnlineSubsystem", "CoreUObject", "OnlineSubsystemUtils", "Networking", "Sockets", "AdvancedSessions"/*"Voice", "OnlineSubsystemSteam"*/ });
+        PrivateDependencyModuleNames.AddRange(new string[] { "OnlineSubsystem", "Sockets", "Networking", "OnlineSubsystemUtils" /*"Voice", "Steamworks","OnlineSubsystemSteam"*/});
+
+        if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Linux) || (Target.Platform == UnrealTargetPlatform.Mac))
+        {
+            PublicDependencyModuleNames.AddRange(new string[] { "Steamworks"/*, "OnlineSubsystemSteam"*/ });
+            //PublicIncludePaths.AddRange(new string[] { "../Plugins/Online/OnlineSubsystemSteam/Source/Private" });// This is dumb but it isn't very open
+        }
+    }
+}

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Classes/AdvancedSteamFriendsLibrary.h

@@ -0,0 +1,387 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Online.h"
+#include "OnlineSubsystem.h"
+#include "Interfaces/OnlineFriendsInterface.h"
+#include "Interfaces/OnlineUserInterface.h"
+#include "Interfaces/OnlineMessageInterface.h"
+#include "Interfaces/OnlinePresenceInterface.h"
+#include "Engine/GameInstance.h"
+#include "Interfaces/OnlineSessionInterface.h"
+#include "BlueprintDataDefinitions.h"
+#include "UObject/UObjectIterator.h"
+
+// This is taken directly from UE4 - OnlineSubsystemSteamPrivatePCH.h as a fix for the array_count macro
+// @todo Steam: Steam headers trigger secure-C-runtime warnings in Visual C++. Rather than mess with _CRT_SECURE_NO_WARNINGS, we'll just
+//	disable the warnings locally. Remove when this is fixed in the SDK
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4996)
+// #TODO check back on this at some point
+#pragma warning(disable:4265) // SteamAPI CCallback< specifically, this warning is off by default but 4.17 turned it on....
+#endif
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+#pragma push_macro("ARRAY_COUNT")
+#undef ARRAY_COUNT
+
+#if USING_CODE_ANALYSIS
+MSVC_PRAGMA(warning(push))
+MSVC_PRAGMA(warning(disable : ALL_CODE_ANALYSIS_WARNINGS))
+#endif	// USING_CODE_ANALYSIS
+
+#include <steam/steam_api.h>
+
+#if USING_CODE_ANALYSIS
+MSVC_PRAGMA(warning(pop))
+#endif	// USING_CODE_ANALYSIS
+
+#include <steam/isteamapps.h>
+#include <steam/isteamapplist.h>
+//#include <OnlineSubsystemSteamTypes.h>
+#pragma pop_macro("ARRAY_COUNT")
+
+// @todo Steam: See above
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// Making a copy of this here since the original is still in a private folder and is screwing with things
+/**
+* Steam specific implementation of the unique net id
+*/
+class FUniqueNetIdSteam2 :
+	public FUniqueNetId
+{
+PACKAGE_SCOPE:
+	/** Holds the net id for a player */
+	uint64 UniqueNetId;
+
+	/** Hidden on purpose */
+	FUniqueNetIdSteam2() :
+		UniqueNetId(0)
+	{
+	}
+
+	/**
+	* Copy Constructor
+	*
+	* @param Src the id to copy
+	*/
+	explicit FUniqueNetIdSteam2(const FUniqueNetIdSteam2& Src) :
+		UniqueNetId(Src.UniqueNetId)
+	{
+	}
+
+public:
+	/**
+	* Constructs this object with the specified net id
+	*
+	* @param InUniqueNetId the id to set ours to
+	*/
+	explicit FUniqueNetIdSteam2(uint64 InUniqueNetId) :
+		UniqueNetId(InUniqueNetId)
+	{
+	}
+
+	/**
+	* Constructs this object with the steam id
+	*
+	* @param InUniqueNetId the id to set ours to
+	*/
+	explicit FUniqueNetIdSteam2(CSteamID InSteamId) :
+		UniqueNetId(InSteamId.ConvertToUint64())
+	{
+	}
+
+	/**
+	* Constructs this object with the specified net id
+	*
+	* @param String textual representation of an id
+	*/
+	explicit FUniqueNetIdSteam2(const FString& Str) :
+		UniqueNetId(FCString::Atoi64(*Str))
+	{
+	}
+
+
+	/**
+	* Constructs this object with the specified net id
+	*
+	* @param InUniqueNetId the id to set ours to (assumed to be FUniqueNetIdSteam in fact)
+	*/
+	explicit FUniqueNetIdSteam2(const FUniqueNetId& InUniqueNetId) :
+		UniqueNetId(*(uint64*)InUniqueNetId.GetBytes())
+	{
+	}
+
+	virtual FName GetType() const override
+	{
+		return STEAM_SUBSYSTEM;
+	}
+
+	/**
+	* Get the raw byte representation of this net id
+	* This data is platform dependent and shouldn't be manipulated directly
+	*
+	* @return byte array of size GetSize()
+	*/
+	virtual const uint8* GetBytes() const override
+	{
+		return (uint8*)&UniqueNetId;
+	}
+
+	/**
+	* Get the size of the id
+	*
+	* @return size in bytes of the id representation
+	*/
+	virtual int32 GetSize() const override
+	{
+		return sizeof(uint64);
+	}
+
+	/**
+	* Check the validity of the id
+	*
+	* @return true if this is a well formed ID, false otherwise
+	*/
+	virtual bool IsValid() const override
+	{
+		return UniqueNetId != 0 && CSteamID(UniqueNetId).IsValid();
+	}
+
+	/**
+	* Platform specific conversion to string representation of data
+	*
+	* @return data in string form
+	*/
+	virtual FString ToString() const override
+	{
+		return FString::Printf(TEXT("%llu"), UniqueNetId);
+	}
+
+	/**
+	* Get a human readable representation of the net id
+	* Shouldn't be used for anything other than logging/debugging
+	*
+	* @return id in string form
+	*/
+	virtual FString ToDebugString() const override
+	{
+		CSteamID SteamID(UniqueNetId);
+		if (SteamID.IsLobby())
+		{
+			return FString::Printf(TEXT("Lobby [0x%llX]"), UniqueNetId);
+		}
+		else if (SteamID.BAnonGameServerAccount())
+		{
+			return FString::Printf(TEXT("Server [0x%llX]"), UniqueNetId);
+		}
+		else if (SteamID.IsValid())
+		{
+			const FString NickName(SteamFriends() ? UTF8_TO_TCHAR(SteamFriends()->GetFriendPersonaName(UniqueNetId)) : TEXT("UNKNOWN"));
+			return FString::Printf(TEXT("%s [0x%llX]"), *NickName, UniqueNetId);
+		}
+		else
+		{
+			return FString::Printf(TEXT("INVALID [0x%llX]"), UniqueNetId);
+		}
+	}
+
+
+	virtual uint32 GetTypeHash() const override
+	{
+		return ::GetTypeHash(UniqueNetId);
+	}
+
+	/** Convenience cast to CSteamID */
+	operator CSteamID()
+	{
+		return UniqueNetId;
+	}
+
+	/** Convenience cast to CSteamID */
+	operator const CSteamID() const
+	{
+		return UniqueNetId;
+	}
+
+	/** Convenience cast to CSteamID pointer */
+	operator CSteamID*()
+	{
+		return (CSteamID*)&UniqueNetId;
+	}
+
+	/** Convenience cast to CSteamID pointer */
+	operator const CSteamID*() const
+	{
+		return (const CSteamID*)&UniqueNetId;
+	}
+
+	friend FArchive& operator<<(FArchive& Ar, FUniqueNetIdSteam2& UserId)
+	{
+		return Ar << UserId.UniqueNetId;
+	}
+};
+
+#endif
+
+#include "AdvancedSteamFriendsLibrary.generated.h"
+
+
+//General Advanced Sessions Log
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedSteamFriendsLog, Log, All);
+
+UENUM(Blueprintable)
+enum class SteamAvatarSize : uint8
+{
+	SteamAvatar_INVALID = 0,
+	SteamAvatar_Small = 1,
+	SteamAvatar_Medium = 2,
+	SteamAvatar_Large = 3
+};
+
+UENUM(Blueprintable)
+enum class ESteamUserOverlayType : uint8
+{
+	/*Opens the overlay web browser to the specified user or groups profile.*/
+	steamid,
+	/*Opens a chat window to the specified user, or joins the group chat.*/
+	chat,
+	/*Opens a window to a Steam Trading session that was started with the ISteamEconomy / StartTrade Web API.*/
+	jointrade,
+	/*Opens the overlay web browser to the specified user's stats.*/
+	stats,
+	/*Opens the overlay web browser to the specified user's achievements.*/
+	achievements,
+	/*Opens the overlay in minimal mode prompting the user to add the target user as a friend.*/
+	friendadd,
+	/*Opens the overlay in minimal mode prompting the user to remove the target friend.*/
+	friendremove,
+	/*Opens the overlay in minimal mode prompting the user to accept an incoming friend invite.*/
+	friendrequestaccept,
+	/*Opens the overlay in minimal mode prompting the user to ignore an incoming friend invite.*/
+	friendrequestignore
+};
+
+static FString EnumToString(const FString& enumName, uint8 value)
+{
+	
+	const UEnum* EnumPtr = FindFirstObject<UEnum>(*enumName, EFindFirstObjectOptions::None, ELogVerbosity::Warning, TEXT("EumtoString"));
+
+	if (!EnumPtr)
+		return FString();
+
+	FString EnumName = EnumPtr->GetNameStringByIndex(value);
+	return EnumName;
+}
+
+
+USTRUCT(BlueprintType, Category = "Online|SteamAPI|SteamGroups")
+struct FBPSteamGroupInfo
+{
+	GENERATED_USTRUCT_BODY()
+
+public:
+
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|SteamAPI|SteamGroups")
+		FBPUniqueNetId GroupID; // Uint64 representation
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|SteamAPI|SteamGroups")
+		FString GroupName;
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|SteamAPI|SteamGroups")
+		FString GroupTag;
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|SteamAPI|SteamGroups")
+		int32 numOnline = 0;
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|SteamAPI|SteamGroups")
+		int32 numInGame = 0;
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|SteamAPI|SteamGroups")
+		int32 numChatting = 0;
+
+};
+
+UENUM(Blueprintable)
+enum class EBPTextFilteringContext : uint8
+{
+	/*Unknown context.*/
+	FContext_Unknown = 0,
+	/*Game content, only legally required filtering is performed.*/
+	FContext_GameContent = 1,
+	/*Char from another player.*/
+	FContext_Chat = 2,
+	/*Character or item name.*/
+	FContext_Name = 3
+};
+
+UCLASS()
+class UAdvancedSteamFriendsLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+public:
+	
+	//********* Friend List Functions *************//
+
+	// Get a texture of a valid friends avatar, STEAM ONLY, Returns invalid texture if the subsystem hasn't loaded that size of avatar yet
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|SteamAPI", meta = (ExpandEnumAsExecs = "Result"))
+	static UTexture2D * GetSteamFriendAvatar(const FBPUniqueNetId UniqueNetId, EBlueprintAsyncResultSwitch &Result, SteamAvatarSize AvatarSize = SteamAvatarSize::SteamAvatar_Medium);
+
+	// Preloads the avatar and name of a steam friend, return whether it is already available or not, STEAM ONLY, Takes time to actually load everything after this is called.
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|SteamAPI")
+	static bool RequestSteamFriendInfo(const FBPUniqueNetId UniqueNetId, bool bRequireNameOnly = false);
+
+	// Opens the steam overlay to go to the specified user dialog
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|SteamAPI")
+		static bool OpenSteamUserOverlay(const FBPUniqueNetId UniqueNetId, ESteamUserOverlayType DialogType);
+	
+	// Returns if the steam overlay is currently active (this can return false during initial overlay hooking)
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedFriends|SteamAPI")
+		static bool IsOverlayEnabled();
+
+	// Gets the level of a friends steam account, STEAM ONLY, Returns -1 if the steam level is not known, might need RequestSteamFriendInfo called first.
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|SteamAPI")
+	static int32 GetFriendSteamLevel(const FBPUniqueNetId UniqueNetId);
+
+	// Gets the persona name of a steam ID, STEAM ONLY, Returns empty if no result, might need RequestSteamFriendInfo called first.
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|SteamAPI")
+	static FString GetSteamPersonaName(const FBPUniqueNetId UniqueNetId);
+
+	// Creates a unique steam id directly from a string holding a uint64 value, useful for testing
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedFriends|SteamAPI")
+	static FBPUniqueNetId CreateSteamIDFromString(const FString SteamID64);
+
+	// Retreives the local steam ID from steam
+	UFUNCTION(BlueprintPure, Category = "Online|AdvancedFriends|SteamAPI")
+		static FBPUniqueNetId GetLocalSteamIDFromSteam();
+
+	/* Gets the current game played by a friend - AppID is int32 even though steam ids are uint32, can't be helped in blueprint currently
+	*  can use the AppID with the WebAPI GetAppList request.
+	*/
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedFriends|SteamAPI", meta = (ExpandEnumAsExecs = "Result"))
+	static void GetSteamFriendGamePlayed(const FBPUniqueNetId UniqueNetId, EBlueprintResultSwitch &Result/*, FString & GameName*/, int32 & AppID);
+
+	// Get a full list of steam groups
+	UFUNCTION(BlueprintCallable, Category = "Online|SteamAPI|SteamGroups")
+		static void GetSteamGroups(TArray<FBPSteamGroupInfo> & SteamGroups);
+
+	// Initializes text filtering (pre-loading dictonaries)
+	// Returns if it succeeded, false if filtering is unavailable for the games language
+	UFUNCTION(BlueprintCallable, Category = "Online|SteamAPI|TextFiltering")
+		static bool InitTextFiltering();
+
+	// Attempts to filter a string with the given filtering context
+	// Returns true if the text has been filtered, false if it hasn't (no filtering required or operation failed)
+	// If false it will still output the original text
+	// Textsource is the steam id that is the source of the text (player name / chat)
+	// Requires that InitTextFiltering be called first!!
+	UFUNCTION(BlueprintCallable, Category = "Online|SteamAPI|TextFiltering")
+		static bool FilterText(FString TextToFilter, EBPTextFilteringContext Context, const FBPUniqueNetId TextSourceID, FString& FilteredText);
+
+	// Returns if steam is running in big picture mode
+	UFUNCTION(BlueprintPure, Category = "Online|SteamAPI")
+		static bool IsSteamInBigPictureMode();
+};	

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Classes/AdvancedSteamSessions.h

@@ -0,0 +1,12 @@
+#pragma once
+ 
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+
+class AdvancedSteamSessions : public IModuleInterface
+{
+public:
+	/** IModuleInterface implementation */
+	void StartupModule();
+	void ShutdownModule();
+};

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Classes/AdvancedSteamWorkshopLibrary.h

@@ -0,0 +1,351 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "Online.h"
+#include "OnlineSubsystem.h"
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+#include "steam/isteamugc.h"
+#include "steam/isteamremotestorage.h"
+#endif
+#include "Interfaces/OnlineSessionInterface.h"
+
+// @todo Steam: Steam headers trigger secure-C-runtime warnings in Visual C++. Rather than mess with _CRT_SECURE_NO_WARNINGS, we'll just
+//	disable the warnings locally. Remove when this is fixed in the SDK
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4996)
+// #TODO check back on this at some point
+#pragma warning(disable:4265) // SteamAPI CCallback< specifically, this warning is off by default but 4.17 turned it on....
+#endif
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+#pragma push_macro("ARRAY_COUNT")
+#undef ARRAY_COUNT
+
+#if USING_CODE_ANALYSIS
+MSVC_PRAGMA(warning(push))
+MSVC_PRAGMA(warning(disable : ALL_CODE_ANALYSIS_WARNINGS))
+#endif	// USING_CODE_ANALYSIS
+
+#include <steam/steam_api.h>
+
+#if USING_CODE_ANALYSIS
+MSVC_PRAGMA(warning(pop))
+#endif	// USING_CODE_ANALYSIS
+
+
+#pragma pop_macro("ARRAY_COUNT")
+
+#endif
+
+// @todo Steam: See above
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+
+#include "AdvancedSteamWorkshopLibrary.generated.h"
+
+
+//General Advanced Sessions Log
+DECLARE_LOG_CATEGORY_EXTERN(AdvancedSteamWorkshopLog, Log, All);
+
+
+// Using a custom struct because uint32 isn't blueprint supported and I don't want to cast to int32
+// due to the size of the workshop it could end up overflowing?
+USTRUCT(BlueprintType)
+struct FBPSteamWorkshopID
+{
+	GENERATED_USTRUCT_BODY()
+
+public:
+
+	uint64 SteamWorkshopID;
+
+	FBPSteamWorkshopID()
+	{
+
+	}
+
+	FBPSteamWorkshopID(uint64 ID)
+	{
+		SteamWorkshopID = ID;
+	}
+};
+
+
+// General result codes - Copying steams version over
+// Check these to future proof
+UENUM(BlueprintType)
+enum class FBPSteamResult : uint8
+{
+	K_EResultInvalid = 0,
+	k_EResultOK = 1,							// success
+	k_EResultFail = 2,							// generic failure 
+	k_EResultNoConnection = 3,					// no/failed network connection
+	//	k_EResultNoConnectionRetry = 4,				// OBSOLETE - removed
+	k_EResultInvalidPassword = 5,				// password/ticket is invalid
+	k_EResultLoggedInElsewhere = 6,				// same user logged in elsewhere
+	k_EResultInvalidProtocolVer = 7,			// protocol version is incorrect
+	k_EResultInvalidParam = 8,					// a parameter is incorrect
+	k_EResultFileNotFound = 9,					// file was not found
+	k_EResultBusy = 10,							// called method busy - action not taken
+	k_EResultInvalidState = 11,					// called object was in an invalid state
+	k_EResultInvalidName = 12,					// name is invalid
+	k_EResultInvalidEmail = 13,					// email is invalid
+	k_EResultDuplicateName = 14,				// name is not unique
+	k_EResultAccessDenied = 15,					// access is denied
+	k_EResultTimeout = 16,						// operation timed out
+	k_EResultBanned = 17,						// VAC2 banned
+	k_EResultAccountNotFound = 18,				// account not found
+	k_EResultInvalidSteamID = 19,				// steamID is invalid
+	k_EResultServiceUnavailable = 20,			// The requested service is currently unavailable
+	k_EResultNotLoggedOn = 21,					// The user is not logged on
+	k_EResultPending = 22,						// Request is pending (may be in process, or waiting on third party)
+	k_EResultEncryptionFailure = 23,			// Encryption or Decryption failed
+	k_EResultInsufficientPrivilege = 24,		// Insufficient privilege
+	k_EResultLimitExceeded = 25,				// Too much of a good thing
+	k_EResultRevoked = 26,						// Access has been revoked (used for revoked guest passes)
+	k_EResultExpired = 27,						// License/Guest pass the user is trying to access is expired
+	k_EResultAlreadyRedeemed = 28,				// Guest pass has already been redeemed by account, cannot be acked again
+	k_EResultDuplicateRequest = 29,				// The request is a duplicate and the action has already occurred in the past, ignored this time
+	k_EResultAlreadyOwned = 30,					// All the games in this guest pass redemption request are already owned by the user
+	k_EResultIPNotFound = 31,					// IP address not found
+	k_EResultPersistFailed = 32,				// failed to write change to the data store
+	k_EResultLockingFailed = 33,				// failed to acquire access lock for this operation
+	k_EResultLogonSessionReplaced = 34,
+	k_EResultConnectFailed = 35,
+	k_EResultHandshakeFailed = 36,
+	k_EResultIOFailure = 37,
+	k_EResultRemoteDisconnect = 38,
+	k_EResultShoppingCartNotFound = 39,			// failed to find the shopping cart requested
+	k_EResultBlocked = 40,						// a user didn't allow it
+	k_EResultIgnored = 41,						// target is ignoring sender
+	k_EResultNoMatch = 42,						// nothing matching the request found
+	k_EResultAccountDisabled = 43,
+	k_EResultServiceReadOnly = 44,				// this service is not accepting content changes right now
+	k_EResultAccountNotFeatured = 45,			// account doesn't have value, so this feature isn't available
+	k_EResultAdministratorOK = 46,				// allowed to take this action, but only because requester is admin
+	k_EResultContentVersion = 47,				// A Version mismatch in content transmitted within the Steam protocol.
+	k_EResultTryAnotherCM = 48,					// The current CM can't service the user making a request, user should try another.
+	k_EResultPasswordRequiredToKickSession = 49,// You are already logged in elsewhere, this cached credential login has failed.
+	k_EResultAlreadyLoggedInElsewhere = 50,		// You are already logged in elsewhere, you must wait
+	k_EResultSuspended = 51,					// Long running operation (content download) suspended/paused
+	k_EResultCancelled = 52,					// Operation canceled (typically by user: content download)
+	k_EResultDataCorruption = 53,				// Operation canceled because data is ill formed or unrecoverable
+	k_EResultDiskFull = 54,						// Operation canceled - not enough disk space.
+	k_EResultRemoteCallFailed = 55,				// an remote call or IPC call failed
+	k_EResultPasswordUnset = 56,				// Password could not be verified as it's unset server side
+	k_EResultExternalAccountUnlinked = 57,		// External account (PSN, Facebook...) is not linked to a Steam account
+	k_EResultPSNTicketInvalid = 58,				// PSN ticket was invalid
+	k_EResultExternalAccountAlreadyLinked = 59,	// External account (PSN, Facebook...) is already linked to some other account, must explicitly request to replace/delete the link first
+	k_EResultRemoteFileConflict = 60,			// The sync cannot resume due to a conflict between the local and remote files
+	k_EResultIllegalPassword = 61,				// The requested new password is not legal
+	k_EResultSameAsPreviousValue = 62,			// new value is the same as the old one ( secret question and answer )
+	k_EResultAccountLogonDenied = 63,			// account login denied due to 2nd factor authentication failure
+	k_EResultCannotUseOldPassword = 64,			// The requested new password is not legal
+	k_EResultInvalidLoginAuthCode = 65,			// account login denied due to auth code invalid
+	k_EResultAccountLogonDeniedNoMail = 66,		// account login denied due to 2nd factor auth failure - and no mail has been sent
+	k_EResultHardwareNotCapableOfIPT = 67,		// 
+	k_EResultIPTInitError = 68,					// 
+	k_EResultParentalControlRestricted = 69,	// operation failed due to parental control restrictions for current user
+	k_EResultFacebookQueryError = 70,			// Facebook query returned an error
+	k_EResultExpiredLoginAuthCode = 71,			// account login denied due to auth code expired
+	k_EResultIPLoginRestrictionFailed = 72,
+	k_EResultAccountLockedDown = 73,
+	k_EResultAccountLogonDeniedVerifiedEmailRequired = 74,
+	k_EResultNoMatchingURL = 75,
+	k_EResultBadResponse = 76,					// parse failure, missing field, etc.
+	k_EResultRequirePasswordReEntry = 77,		// The user cannot complete the action until they re-enter their password
+	k_EResultValueOutOfRange = 78,				// the value entered is outside the acceptable range
+	k_EResultUnexpectedError = 79,				// something happened that we didn't expect to ever happen
+	k_EResultDisabled = 80,						// The requested service has been configured to be unavailable
+	k_EResultInvalidCEGSubmission = 81,			// The set of files submitted to the CEG server are not valid !
+	k_EResultRestrictedDevice = 82,				// The device being used is not allowed to perform this action
+	k_EResultRegionLocked = 83,					// The action could not be complete because it is region restricted
+	k_EResultRateLimitExceeded = 84,			// Temporary rate limit exceeded, try again later, different from k_EResultLimitExceeded which may be permanent
+	k_EResultAccountLoginDeniedNeedTwoFactor = 85,	// Need two-factor code to login
+	k_EResultItemDeleted = 86,					// The thing we're trying to access has been deleted
+	k_EResultAccountLoginDeniedThrottle = 87,	// login attempt failed, try to throttle response to possible attacker
+	k_EResultTwoFactorCodeMismatch = 88,		// two factor code mismatch
+	k_EResultTwoFactorActivationCodeMismatch = 89,	// activation code for two-factor didn't match
+	k_EResultAccountAssociatedToMultiplePartners = 90,	// account has been associated with multiple partners
+	k_EResultNotModified = 91, // data not modified
+};
+
+// Check these to future proof
+UENUM(BlueprintType)
+enum class FBPWorkshopFileType : uint8
+{
+	k_EWorkshopFileTypeCommunity = 0,
+	k_EWorkshopFileTypeMicrotransaction = 1,
+	k_EWorkshopFileTypeCollection = 2,
+	k_EWorkshopFileTypeArt = 3,
+	k_EWorkshopFileTypeVideo = 4,
+	k_EWorkshopFileTypeScreenshot = 5,
+	k_EWorkshopFileTypeGame = 6,
+	k_EWorkshopFileTypeSoftware = 7,
+	k_EWorkshopFileTypeConcept = 8,
+	k_EWorkshopFileTypeWebGuide = 9,
+	k_EWorkshopFileTypeIntegratedGuide = 10,
+	k_EWorkshopFileTypeMerch = 11,
+	k_EWorkshopFileTypeControllerBinding = 12,
+	k_EWorkshopFileTypeSteamworksAccessInvite = 13,
+	k_EWorkshopFileTypeSteamVideo = 14,
+
+	// Update k_EWorkshopFileTypeMax if you add values.
+	k_EWorkshopFileTypeMax = 15
+};
+
+// WorkshopItemDetails Struct
+USTRUCT(BlueprintType)
+struct FBPSteamWorkshopItemDetails
+{
+	GENERATED_USTRUCT_BODY()
+
+public:
+
+	FBPSteamWorkshopItemDetails()
+	{
+		ResultOfRequest = FBPSteamResult::k_EResultOK;
+		FileType = FBPWorkshopFileType::k_EWorkshopFileTypeMax;
+		CreatorAppID = 0;
+		ConsumerAppID = 0;
+		VotesUp = 0;
+		VotesDown = 0;
+		CalculatedScore = 0.f;
+		bBanned = false;
+		bAcceptedForUse = false;
+		bTagsTruncated = false;
+	}
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	FBPSteamWorkshopItemDetails(SteamUGCDetails_t &hUGCDetails)
+	{
+		ResultOfRequest = (FBPSteamResult)hUGCDetails.m_eResult;
+		FileType = (FBPWorkshopFileType)hUGCDetails.m_eFileType;
+		CreatorAppID = (int32)hUGCDetails.m_nCreatorAppID;
+		ConsumerAppID = (int32)hUGCDetails.m_nConsumerAppID;
+		Title = FString(hUGCDetails.m_rgchTitle, k_cchPublishedDocumentTitleMax);
+		Description = FString(hUGCDetails.m_rgchDescription, k_cchPublishedDocumentDescriptionMax);
+		ItemUrl = FString(hUGCDetails.m_rgchURL, k_cchPublishedFileURLMax);
+		VotesUp = (int32)hUGCDetails.m_unVotesUp;
+		VotesDown = (int32)hUGCDetails.m_unVotesDown;
+		CalculatedScore = hUGCDetails.m_flScore;
+		bBanned = hUGCDetails.m_bBanned;
+		bAcceptedForUse = hUGCDetails.m_bAcceptedForUse;
+		bTagsTruncated = hUGCDetails.m_bTagsTruncated;
+
+		CreatorSteamID = FString::Printf(TEXT("%llu"), hUGCDetails.m_ulSteamIDOwner);
+	}
+
+	FBPSteamWorkshopItemDetails(const SteamUGCDetails_t &hUGCDetails)
+	{
+		ResultOfRequest = (FBPSteamResult)hUGCDetails.m_eResult;
+		FileType = (FBPWorkshopFileType)hUGCDetails.m_eFileType;
+		CreatorAppID = (int32)hUGCDetails.m_nCreatorAppID;
+		ConsumerAppID = (int32)hUGCDetails.m_nConsumerAppID;
+		Title = FString(hUGCDetails.m_rgchTitle, k_cchPublishedDocumentTitleMax);
+		Description = FString(hUGCDetails.m_rgchDescription, k_cchPublishedDocumentDescriptionMax);
+		ItemUrl = FString(hUGCDetails.m_rgchURL, k_cchPublishedFileURLMax);
+		VotesUp = (int32)hUGCDetails.m_unVotesUp;
+		VotesDown = (int32)hUGCDetails.m_unVotesDown;
+		CalculatedScore = hUGCDetails.m_flScore;
+		bBanned = hUGCDetails.m_bBanned;
+		bAcceptedForUse = hUGCDetails.m_bAcceptedForUse;
+		bTagsTruncated = hUGCDetails.m_bTagsTruncated;
+
+		CreatorSteamID = FString::Printf(TEXT("%llu"), hUGCDetails.m_ulSteamIDOwner);
+	}
+#endif
+
+	// Result of obtaining the details
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+		FBPSteamResult ResultOfRequest;
+
+	// Type of file
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+		FBPWorkshopFileType FileType;
+
+	// These two are listed as baked to an int, but is stored as a uint, think its safe to keep int
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+		int32 CreatorAppID;
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+		int32 ConsumerAppID;
+
+	// Title of item
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+		FString Title;
+
+	// Description of item
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+		FString Description;
+	
+	//Url for a video of website
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+		FString ItemUrl;
+
+	// Votes will be unlikely to go above signed limited
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+	int32 VotesUp;
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+	int32 VotesDown;
+
+	// Calculated score
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+	float CalculatedScore;
+
+	// whether the file was banned
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+	bool bBanned;													
+	
+	// developer has specifically flagged this item as accepted in the Workshop
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+	bool bAcceptedForUse;	
+	
+	// whether the list of tags was too long to be returned in the provided buffer
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+	bool bTagsTruncated;
+
+	// Steam ID of the user who created this content.
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|AdvancedSteamWorkshop")
+	FString CreatorSteamID;
+
+	/*
+	PublishedFileId_t m_nPublishedFileId;
+	uint32 m_rtimeCreated;											// time when the published file was created
+	uint32 m_rtimeUpdated;											// time when the published file was last updated
+	uint32 m_rtimeAddedToUserList;									// time when the user added the published file to their list (not always applicable)
+	ERemoteStoragePublishedFileVisibility m_eVisibility;			// visibility
+	char m_rgchTags[k_cchTagListMax];								// comma separated list of all tags associated with this file
+	// file/url information
+	UGCHandle_t m_hFile;											// The handle of the primary file
+	UGCHandle_t m_hPreviewFile;										// The handle of the preview file
+	char m_pchFileName[k_cchFilenameMax];							// The cloud filename of the primary file
+	int32 m_nFileSize;												// Size of the primary file
+	int32 m_nPreviewFileSize;										// Size of the preview file
+	uint32 m_unNumChildren;											// if m_eFileType == k_EWorkshopFileTypeCollection, then this number will be the number of children contained within the collection
+	*/
+
+};
+
+UCLASS()
+class UAdvancedSteamWorkshopLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+public:
+	
+	//********* Steam Functions *************//
+	
+	// Returns IDs for subscribed workshop items, TArray length dictates how many
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSteamWorkshop")
+	static TArray<FBPSteamWorkshopID> GetSubscribedWorkshopItems(int32 & NumberOfItems);
+
+	UFUNCTION(BlueprintCallable, Category = "Online|AdvancedSteamWorkshop")
+	static void GetNumSubscribedWorkshopItems(int32 & NumberOfItems);
+
+};	

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Classes/SteamNotificationsSubsystem.h

@@ -0,0 +1,90 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Subsystems/GameInstanceSubsystem.h"
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+//#include "OnlineSubsystemSteam.h"
+//#include "OnlineSubsystemSteamPrivate.h"
+
+#include <steam/steam_api.h>
+
+#endif
+
+#include "SteamNotificationsSubsystem.generated.h"
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSteamOverlayActivated, bool, bOverlayState);
+
+UCLASS()
+class ADVANCEDSTEAMSESSIONS_API USteamNotificationsSubsystem : public UGameInstanceSubsystem
+{
+	GENERATED_BODY()
+
+public:
+	
+	// Event thrown when the steam overlay switches states
+	UPROPERTY(BlueprintAssignable, Category = "SteamEvents")
+		FOnSteamOverlayActivated OnSteamOverlayActivated_Bind;
+	
+	USteamNotificationsSubsystem() : Super()
+	{
+
+	}
+
+	class cSteamEventsStore
+	{
+	public:
+		USteamNotificationsSubsystem* ParentSubsystem = nullptr;
+		void Initialize(USteamNotificationsSubsystem* MyParent)
+		{
+			ParentSubsystem = MyParent;
+		}
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+		cSteamEventsStore() :
+		OnExternalUITriggeredCallback(this, &cSteamEventsStore::OnExternalUITriggered)
+		{
+
+		}
+#else
+		//cSteamEventsStore()
+		//{
+
+		//}
+#endif
+
+		//~cSteamEventsStore(){}
+
+	private:
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+		STEAM_CALLBACK(cSteamEventsStore, OnExternalUITriggered, GameOverlayActivated_t, OnExternalUITriggeredCallback);
+#endif
+	};
+
+	cSteamEventsStore MyEvents;
+
+	/** Implement this for initialization of instances of the system */
+	virtual void Initialize(FSubsystemCollectionBase& Collection) override
+	{
+		MyEvents.Initialize(this);
+	}
+
+	/** Implement this for deinitialization of instances of the system */
+	virtual void Deinitialize() override
+	{
+
+	}
+};
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+void USteamNotificationsSubsystem::cSteamEventsStore::OnExternalUITriggered(GameOverlayActivated_t* CallbackData)
+{
+	if (ParentSubsystem)
+	{
+		ParentSubsystem->OnSteamOverlayActivated_Bind.Broadcast((bool)CallbackData->m_bActive);
+	}
+}
+#endif

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Classes/SteamRequestGroupOfficersCallbackProxy.h

@@ -0,0 +1,100 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "BlueprintDataDefinitions.h"
+
+// This is taken directly from UE4 - OnlineSubsystemSteamPrivatePCH.h as a fix for the array_count macro
+
+// @todo Steam: Steam headers trigger secure-C-runtime warnings in Visual C++. Rather than mess with _CRT_SECURE_NO_WARNINGS, we'll just
+//	disable the warnings locally. Remove when this is fixed in the SDK
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4996)
+// #TODO check back on this at some point
+#pragma warning(disable:4265) // SteamAPI CCallback< specifically, this warning is off by default but 4.17 turned it on....
+#endif
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+//#include "OnlineSubsystemSteam.h"
+
+#pragma push_macro("ARRAY_COUNT")
+#undef ARRAY_COUNT
+
+#if USING_CODE_ANALYSIS
+MSVC_PRAGMA(warning(push))
+MSVC_PRAGMA(warning(disable : ALL_CODE_ANALYSIS_WARNINGS))
+#endif	// USING_CODE_ANALYSIS
+
+#include <steam/steam_api.h>
+
+#if USING_CODE_ANALYSIS
+MSVC_PRAGMA(warning(pop))
+#endif	// USING_CODE_ANALYSIS
+
+
+#pragma pop_macro("ARRAY_COUNT")
+
+#endif
+
+// @todo Steam: See above
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#include "SteamRequestGroupOfficersCallbackProxy.generated.h"
+
+USTRUCT(BlueprintType, Category = "Online|SteamAPI|SteamGroups")
+struct FBPSteamGroupOfficer
+{
+	GENERATED_USTRUCT_BODY()
+
+public:
+
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|SteamAPI|SteamGroups")
+		FBPUniqueNetId OfficerUniqueNetID; // Uint64 representation
+	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Online|SteamAPI|SteamGroups")
+		bool bIsOwner = false;
+
+};
+
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FBlueprintGroupOfficerDetailsDelegate, const TArray<FBPSteamGroupOfficer> &, OfficerList);
+
+UCLASS(MinimalAPI)
+class USteamRequestGroupOfficersCallbackProxy : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	virtual ~USteamRequestGroupOfficersCallbackProxy();
+
+	// Called when there is a successful results return
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintGroupOfficerDetailsDelegate OnSuccess;
+
+	// Called when there is an unsuccessful results return
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintGroupOfficerDetailsDelegate OnFailure;
+
+	// Returns a list of steam group officers
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|SteamAPI|SteamGroups")
+	static USteamRequestGroupOfficersCallbackProxy* GetSteamGroupOfficerList(UObject* WorldContextObject, FBPUniqueNetId GroupUniqueNetID);
+
+	// UOnlineBlueprintCallProxyBase interface
+	virtual void Activate() override;
+	// End of UOnlineBlueprintCallProxyBase interface
+
+private:
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	void OnRequestGroupOfficerDetails( ClanOfficerListResponse_t *pResult, bool bIOFailure);
+	CCallResult<USteamRequestGroupOfficersCallbackProxy, ClanOfficerListResponse_t> m_callResultGroupOfficerRequestDetails;
+
+#endif
+
+private:
+
+	FBPUniqueNetId GroupUniqueID;
+	UObject* WorldContextObject;
+};

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Classes/SteamWSRequestUGCDetailsCallbackProxy.h

@@ -0,0 +1,87 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+#pragma once
+
+#include "CoreMinimal.h"
+#include "AdvancedSteamWorkshopLibrary.h"
+#include "BlueprintDataDefinitions.h"
+
+// This is taken directly from UE4 - OnlineSubsystemSteamPrivatePCH.h as a fix for the array_count macro
+
+// @todo Steam: Steam headers trigger secure-C-runtime warnings in Visual C++. Rather than mess with _CRT_SECURE_NO_WARNINGS, we'll just
+//	disable the warnings locally. Remove when this is fixed in the SDK
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4996)
+// #TODO check back on this at some point
+#pragma warning(disable:4265) // SteamAPI CCallback< specifically, this warning is off by default but 4.17 turned it on....
+#endif
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+//#include "OnlineSubsystemSteam.h"
+
+#pragma push_macro("ARRAY_COUNT")
+#undef ARRAY_COUNT
+
+#if USING_CODE_ANALYSIS
+MSVC_PRAGMA(warning(push))
+MSVC_PRAGMA(warning(disable : ALL_CODE_ANALYSIS_WARNINGS))
+#endif	// USING_CODE_ANALYSIS
+
+#include <steam/steam_api.h>
+
+#if USING_CODE_ANALYSIS
+MSVC_PRAGMA(warning(pop))
+#endif	// USING_CODE_ANALYSIS
+
+
+#pragma pop_macro("ARRAY_COUNT")
+
+#endif
+
+// @todo Steam: See above
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+
+#include "SteamWSRequestUGCDetailsCallbackProxy.generated.h"
+
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FBlueprintWorkshopDetailsDelegate, const FBPSteamWorkshopItemDetails&, WorkShopDetails);
+
+UCLASS(MinimalAPI)
+class USteamWSRequestUGCDetailsCallbackProxy : public UOnlineBlueprintCallProxyBase
+{
+	GENERATED_UCLASS_BODY()
+
+	// Called when there is a successful results return
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintWorkshopDetailsDelegate OnSuccess;
+
+	// Called when there is an unsuccessful results return
+	UPROPERTY(BlueprintAssignable)
+	FBlueprintWorkshopDetailsDelegate OnFailure;
+
+	// Ends the current session
+	UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext="WorldContextObject"), Category = "Online|AdvancedSteamWorkshop")
+	static USteamWSRequestUGCDetailsCallbackProxy* GetWorkshopItemDetails(UObject* WorldContextObject, FBPSteamWorkshopID WorkShopID);
+
+	// UOnlineBlueprintCallProxyBase interface
+	virtual void Activate() override;
+	// End of UOnlineBlueprintCallProxyBase interface
+
+private:
+	
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	// Internal callback when the operation completes, calls out to the public success/failure callbacks
+		
+	void OnUGCRequestUGCDetails(SteamUGCQueryCompleted_t *pResult, bool bIOFailure);
+	CCallResult<USteamWSRequestUGCDetailsCallbackProxy, SteamUGCQueryCompleted_t> m_callResultUGCRequestDetails;
+
+#endif
+
+private:
+
+	FBPSteamWorkshopID WorkShopID;
+	UObject* WorldContextObject;
+};

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Private/AdvancedSteamFriendsLibrary.cpp

@@ -0,0 +1,432 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+#include "AdvancedSteamFriendsLibrary.h"
+#include "OnlineSubSystemHeader.h"
+
+//General Log
+DEFINE_LOG_CATEGORY(AdvancedSteamFriendsLog);
+
+
+// Clan functions, add in soon
+/*int32 UAdvancedSteamFriendsLibrary::GetFriendSteamLevel(const FBPUniqueNetId UniqueNetId)
+{
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (!UniqueNetId.IsValid() || !UniqueNetId.UniqueNetId->IsValid() || UniqueNetId.UniqueNetId->GetType() != STEAM_SUBSYSTEM)
+	{
+		UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("IsAFriend Had a bad UniqueNetId!"));
+		return 0;
+	}
+
+	if (SteamAPI_Init())
+	{
+		uint64 id = *((uint64*)UniqueNetId.UniqueNetId->GetBytes());
+
+
+		// clan (group) iteration and access functions
+		//virtual int GetClanCount() = 0;
+		//virtual CSteamID GetClanByIndex(int iClan) = 0;
+		//virtual const char *GetClanName(CSteamID steamIDClan) = 0;
+		//virtual const char *GetClanTag(CSteamID steamIDClan) = 0;
+		// returns the most recent information we have about what's happening in a clan
+		//virtual bool GetClanActivityCounts(CSteamID steamIDClan, int *pnOnline, int *pnInGame, int *pnChatting) = 0;
+		// for clans a user is a member of, they will have reasonably up-to-date information, but for others you'll have to download the info to have the latest
+		//virtual SteamAPICall_t DownloadClanActivityCounts(ARRAY_COUNT(cClansToRequest) CSteamID *psteamIDClans, int cClansToRequest) = 0;
+
+		// requests information about a clan officer list
+		// when complete, data is returned in ClanOfficerListResponse_t call result
+		// this makes available the calls below
+		// you can only ask about clans that a user is a member of
+		// note that this won't download avatars automatically; if you get an officer,
+		// and no avatar image is available, call RequestUserInformation( steamID, false ) to download the avatar
+		//virtual SteamAPICall_t RequestClanOfficerList(CSteamID steamIDClan) = 0;
+
+
+		// returns the steamID of the clan owner
+		//virtual CSteamID GetClanOwner(CSteamID steamIDClan) = 0;
+		// returns the number of officers in a clan (including the owner)
+		//virtual int GetClanOfficerCount(CSteamID steamIDClan) = 0;
+		// returns the steamID of a clan officer, by index, of range [0,GetClanOfficerCount)
+		//virtual CSteamID GetClanOfficerByIndex(CSteamID steamIDClan, int iOfficer) = 0;
+
+
+		return SteamFriends()->GetFriendSteamLevel(id);
+	}
+#endif
+
+	return 0;
+}*/
+
+void UAdvancedSteamFriendsLibrary::GetSteamGroups(TArray<FBPSteamGroupInfo> & SteamGroups)
+{
+	
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+	if (SteamAPI_Init())
+	{
+		int numClans = SteamFriends()->GetClanCount();
+
+		for (int i = 0; i < numClans; i++)
+		{
+			CSteamID SteamGroupID = SteamFriends()->GetClanByIndex(i);
+
+			if(!SteamGroupID.IsValid())
+				continue;
+
+			FBPSteamGroupInfo GroupInfo;
+
+			TSharedPtr<const FUniqueNetId> ValueID(new const FUniqueNetIdSteam2(SteamGroupID));
+			GroupInfo.GroupID.SetUniqueNetId(ValueID);
+			SteamFriends()->GetClanActivityCounts(SteamGroupID, &GroupInfo.numOnline, &GroupInfo.numInGame, &GroupInfo.numChatting);
+			GroupInfo.GroupName = FString(UTF8_TO_TCHAR(SteamFriends()->GetClanName(SteamGroupID)));
+			GroupInfo.GroupTag = FString(UTF8_TO_TCHAR(SteamFriends()->GetClanTag(SteamGroupID)));
+
+			SteamGroups.Add(GroupInfo);
+		}
+	}
+#endif
+
+}
+
+void UAdvancedSteamFriendsLibrary::GetSteamFriendGamePlayed(const FBPUniqueNetId UniqueNetId, EBlueprintResultSwitch &Result/*, FString & GameName*/, int32 & AppID)
+{
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (!UniqueNetId.IsValid() || !UniqueNetId.UniqueNetId->IsValid() || UniqueNetId.UniqueNetId->GetType() != STEAM_SUBSYSTEM)
+	{
+		UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("GetSteamFriendGamePlayed Had a bad UniqueNetId!"));
+		Result = EBlueprintResultSwitch::OnFailure;
+		return;
+	}
+
+	if (SteamAPI_Init())
+	{
+		uint64 id = *((uint64*)UniqueNetId.UniqueNetId->GetBytes());
+
+		FriendGameInfo_t GameInfo;
+		bool bIsInGame = SteamFriends()->GetFriendGamePlayed(id, &GameInfo);
+
+		if (bIsInGame && GameInfo.m_gameID.IsValid())
+		{
+			AppID = GameInfo.m_gameID.AppID();
+
+			// Forgot this test and left it in, it is incorrect, you would need restricted access
+			// And it would only find games in the local library anyway
+			/*char NameBuffer[512];
+			int Len = SteamAppList()->GetAppName(GameInfo.m_gameID.AppID(), NameBuffer, 512);
+
+			if (Len != -1) // Invalid
+			{
+				GameName = FString(UTF8_TO_TCHAR(NameBuffer));
+			}*/
+
+			Result = EBlueprintResultSwitch::OnSuccess;
+			return;
+		}
+
+	}
+#endif
+
+	Result = EBlueprintResultSwitch::OnFailure;
+}
+
+int32 UAdvancedSteamFriendsLibrary::GetFriendSteamLevel(const FBPUniqueNetId UniqueNetId)
+{
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (!UniqueNetId.IsValid() || !UniqueNetId.UniqueNetId->IsValid() || UniqueNetId.UniqueNetId->GetType() != STEAM_SUBSYSTEM)
+	{
+		UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("IsAFriend Had a bad UniqueNetId!"));
+		return 0;
+	}
+
+	if (SteamAPI_Init())
+	{
+		uint64 id = *((uint64*)UniqueNetId.UniqueNetId->GetBytes());
+
+		return SteamFriends()->GetFriendSteamLevel(id);
+	}
+#endif
+
+	return 0;
+}
+
+FString UAdvancedSteamFriendsLibrary::GetSteamPersonaName(const FBPUniqueNetId UniqueNetId)
+{
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (!UniqueNetId.IsValid() || !UniqueNetId.UniqueNetId->IsValid() || UniqueNetId.UniqueNetId->GetType() != STEAM_SUBSYSTEM)
+	{
+		UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("GetSteamPersonaName Had a bad UniqueNetId!"));
+		return FString(TEXT(""));
+	}
+
+	if (SteamAPI_Init())
+	{
+		uint64 id = *((uint64*)UniqueNetId.UniqueNetId->GetBytes());
+		const char* PersonaName = SteamFriends()->GetFriendPersonaName(id);
+		return FString(UTF8_TO_TCHAR(PersonaName));
+	}
+#endif
+
+	return FString(TEXT(""));
+}
+
+FBPUniqueNetId UAdvancedSteamFriendsLibrary::CreateSteamIDFromString(const FString SteamID64)
+{
+	FBPUniqueNetId netId;
+	
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (!(SteamID64.Len() > 0))
+	{
+		UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("CreateSteamIDFromString Had a bad UniqueNetId!"));
+		return netId;
+	}
+
+	if (SteamAPI_Init())
+	{
+		// Already does the conversion
+		TSharedPtr<const FUniqueNetId> ValueID(new const FUniqueNetIdSteam2(SteamID64));
+		//FCString::Atoi64(*SteamID64));
+		
+		netId.SetUniqueNetId(ValueID);
+		return netId;
+	}
+#endif
+
+	return netId;
+}
+
+FBPUniqueNetId UAdvancedSteamFriendsLibrary::GetLocalSteamIDFromSteam()
+{
+	FBPUniqueNetId netId;
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (SteamAPI_Init())
+	{
+		TSharedPtr<const FUniqueNetId> SteamID(new const FUniqueNetIdSteam2(SteamUser()->GetSteamID()));
+		netId.SetUniqueNetId(SteamID);
+	}
+#endif
+
+	return netId;
+}
+
+bool UAdvancedSteamFriendsLibrary::RequestSteamFriendInfo(const FBPUniqueNetId UniqueNetId, bool bRequireNameOnly)
+{
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (!UniqueNetId.IsValid() || !UniqueNetId.UniqueNetId->IsValid() || UniqueNetId.UniqueNetId->GetType() != STEAM_SUBSYSTEM)
+	{
+		UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("RequestSteamFriendInfo Had a bad UniqueNetId!"));
+		return false;
+	}
+
+	if (SteamAPI_Init())
+	{
+		uint64 id = *((uint64*)UniqueNetId.UniqueNetId->GetBytes());
+
+		return !SteamFriends()->RequestUserInformation(id, bRequireNameOnly);
+	}
+#endif
+
+	UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("RequestSteamFriendInfo Couldn't init steamAPI!"));
+	return false;
+}
+
+
+bool UAdvancedSteamFriendsLibrary::OpenSteamUserOverlay(const FBPUniqueNetId UniqueNetId, ESteamUserOverlayType DialogType)
+{
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (!UniqueNetId.IsValid() || !UniqueNetId.UniqueNetId->IsValid() || UniqueNetId.UniqueNetId->GetType() != STEAM_SUBSYSTEM)
+	{
+		UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("OpenSteamUserOverlay Had a bad UniqueNetId!"));
+		return false;
+	}
+
+	if (SteamAPI_Init())
+	{
+		uint64 id = *((uint64*)UniqueNetId.UniqueNetId->GetBytes());
+		FString DialogName = EnumToString("ESteamUserOverlayType", (uint8)DialogType);
+		SteamFriends()->ActivateGameOverlayToUser(TCHAR_TO_ANSI(*DialogName), id);
+		return true;
+	}
+#endif
+
+	UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("OpenSteamUserOverlay Couldn't init steamAPI!"));
+	return false;
+}
+
+bool UAdvancedSteamFriendsLibrary::IsOverlayEnabled()
+{
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (SteamAPI_Init())
+	{
+		return SteamUtils()->IsOverlayEnabled();
+	}
+#endif
+
+	UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("OpenSteamUserOverlay Couldn't init steamAPI!"));
+	return false;
+}
+
+UTexture2D * UAdvancedSteamFriendsLibrary::GetSteamFriendAvatar(const FBPUniqueNetId UniqueNetId, EBlueprintAsyncResultSwitch &Result, SteamAvatarSize AvatarSize)
+{
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (!UniqueNetId.IsValid() || !UniqueNetId.UniqueNetId->IsValid() || UniqueNetId.UniqueNetId->GetType() != STEAM_SUBSYSTEM)
+	{
+		UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("GetSteamFriendAvatar Had a bad UniqueNetId!"));
+		Result = EBlueprintAsyncResultSwitch::OnFailure;
+		return nullptr;
+	}
+
+	uint32 Width = 0;
+	uint32 Height = 0;
+
+	if (SteamAPI_Init())
+	{
+		//Getting the PictureID from the SteamAPI and getting the Size with the ID
+		//virtual bool RequestUserInformation( CSteamID steamIDUser, bool bRequireNameOnly ) = 0;
+
+		
+		uint64 id = *((uint64*)UniqueNetId.UniqueNetId->GetBytes());
+		int Picture = 0;
+		
+		switch(AvatarSize)
+		{
+		case SteamAvatarSize::SteamAvatar_Small: Picture = SteamFriends()->GetSmallFriendAvatar(id); break;
+		case SteamAvatarSize::SteamAvatar_Medium: Picture = SteamFriends()->GetMediumFriendAvatar(id); break;
+		case SteamAvatarSize::SteamAvatar_Large: Picture = SteamFriends()->GetLargeFriendAvatar(id); break;
+		default: break;
+		}
+
+		if (Picture == -1)
+		{
+			Result = EBlueprintAsyncResultSwitch::AsyncLoading;
+			return NULL;
+		}
+
+		SteamUtils()->GetImageSize(Picture, &Width, &Height);
+
+		// STOLEN FROM ANSWERHUB :p, then fixed because answerhub wasn't releasing the memory O.o
+		// Also fixed image pixel format and switched to a memcpy instead of manual iteration.
+		// At some point I should probably reply to that answerhub post with these fixes to prevent people killing their games.....
+
+		if (Width > 0 && Height > 0)
+		{
+			//Creating the buffer "oAvatarRGBA" and then filling it with the RGBA Stream from the Steam Avatar
+			uint8 *oAvatarRGBA = new uint8[Width * Height * 4];
+
+
+			//Filling the buffer with the RGBA Stream from the Steam Avatar and creating a UTextur2D to parse the RGBA Steam in
+			SteamUtils()->GetImageRGBA(Picture, (uint8*)oAvatarRGBA, 4 * Height * Width * sizeof(char));
+
+
+			// Removed as I changed the image bit code to be RGB, I think the original author was unaware that there were different pixel formats
+			/*
+			//Swap R and B channels because for some reason the games whack
+			for (uint32 i = 0; i < (Width * Height * 4); i += 4)
+			{
+				uint8 Temp = oAvatarRGBA[i + 0];
+				oAvatarRGBA[i + 0] = oAvatarRGBA[i + 2];
+				oAvatarRGBA[i + 2] = Temp;
+			}*/
+
+			UTexture2D* Avatar = UTexture2D::CreateTransient(Width, Height, PF_R8G8B8A8);
+			// Switched to a Memcpy instead of byte by byte transer
+
+			if (FTexturePlatformData* PlatformData = Avatar->GetPlatformData())
+			{
+				uint8* MipData = (uint8*)PlatformData->Mips[0].BulkData.Lock(LOCK_READ_WRITE);
+				FMemory::Memcpy(MipData, (void*)oAvatarRGBA, Height * Width * 4);
+				PlatformData->Mips[0].BulkData.Unlock();
+
+				// Original implementation was missing this!!
+				// the hell man......
+				delete[] oAvatarRGBA;
+
+				//Setting some Parameters for the Texture and finally returning it
+				PlatformData->SetNumSlices(1);
+				Avatar->NeverStream = true;
+				//Avatar->CompressionSettings = TC_EditorIcon;
+			}
+
+			Avatar->UpdateResource();
+
+			Result = EBlueprintAsyncResultSwitch::OnSuccess;
+			return Avatar;
+		}
+		else
+		{
+			UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("Bad Height / Width with steam avatar!"));
+		}
+
+		Result = EBlueprintAsyncResultSwitch::OnFailure;
+		return nullptr;
+	}
+#endif
+
+	UE_LOG(AdvancedSteamFriendsLog, Warning, TEXT("STEAM Couldn't be verified as initialized"));
+	Result = EBlueprintAsyncResultSwitch::OnFailure;
+	return nullptr;
+}
+
+bool UAdvancedSteamFriendsLibrary::InitTextFiltering()
+{
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+	if (SteamAPI_Init())
+	{
+		return SteamUtils()->InitFilterText();
+	}
+
+#endif
+
+	return false;
+}
+
+bool UAdvancedSteamFriendsLibrary::FilterText(FString TextToFilter, EBPTextFilteringContext Context, const FBPUniqueNetId TextSourceID, FString& FilteredText)
+{
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+	if (SteamAPI_Init())
+	{
+		uint32 BufferLen = TextToFilter.Len() + 10; // Docs say 1 byte excess min, going with 10
+		char* OutText = new char[BufferLen];
+		
+		uint64 id = 0;
+
+		if (TextSourceID.IsValid())
+		{
+			id = *((uint64*)TextSourceID.UniqueNetId->GetBytes());
+		}
+		
+		int FilterCount = SteamUtils()->FilterText((ETextFilteringContext)Context, id, TCHAR_TO_ANSI(*TextToFilter), OutText, BufferLen);
+
+		if (FilterCount > 0)
+		{
+			FilteredText = FString(UTF8_TO_TCHAR(OutText));
+			delete[] OutText;
+			return true;
+		}
+
+		delete[] OutText;
+	}
+
+#endif
+
+	FilteredText = TextToFilter;
+	return false;
+}
+
+bool UAdvancedSteamFriendsLibrary::IsSteamInBigPictureMode()
+{
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+	if (SteamAPI_Init())
+	{
+		return SteamUtils()->IsSteamInBigPictureMode();
+	}
+
+#endif
+
+	return false;
+}

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Private/AdvancedSteamSessions.cpp

@@ -0,0 +1,12 @@
+//#include "StandAlonePrivatePCH.h"
+#include "AdvancedSteamSessions.h"
+
+void AdvancedSteamSessions::StartupModule()
+{
+}
+ 
+void AdvancedSteamSessions::ShutdownModule()
+{
+}
+ 
+IMPLEMENT_MODULE(AdvancedSteamSessions, AdvancedSteamSessions)

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Private/AdvancedSteamWorkshopLibrary.cpp

@@ -0,0 +1,69 @@
+// Fill out your copyright notice in the Description page of Project Settings.
+#include "AdvancedSteamWorkshopLibrary.h"
+#include "OnlineSubSystemHeader.h"
+//General Log
+DEFINE_LOG_CATEGORY(AdvancedSteamWorkshopLog);
+
+
+void UAdvancedSteamWorkshopLibrary::GetNumSubscribedWorkshopItems(int32 & NumberOfItems)
+{
+	NumberOfItems = 0;
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+	if (SteamAPI_Init())
+	{
+		NumberOfItems = SteamUGC()->GetNumSubscribedItems();
+		return;
+	}
+	else
+	{
+		UE_LOG(AdvancedSteamWorkshopLog, Warning, TEXT("Error in GetNumSubscribedWorkshopItemCount : SteamAPI is not Inited!"));
+		return;
+	}
+#endif
+
+	UE_LOG(AdvancedSteamWorkshopLog, Warning, TEXT("Error in GetNumSubscribedWorkshopItemCount : Called on an incompatible platform"));
+	return;
+}
+
+TArray<FBPSteamWorkshopID> UAdvancedSteamWorkshopLibrary::GetSubscribedWorkshopItems(int32 & NumberOfItems)
+{
+	TArray<FBPSteamWorkshopID> outArray;
+	NumberOfItems = 0;
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+
+	if (SteamAPI_Init())
+	{
+		uint32 NumItems = SteamUGC()->GetNumSubscribedItems();
+		
+		if (NumItems == 0)
+			return outArray;
+
+		// Not using the actual variable above in case someone somehow goes past int32 limits
+		// Don't want to go negative on the iteration.
+		NumberOfItems = NumItems;
+
+		PublishedFileId_t *fileIds = new PublishedFileId_t[NumItems];
+		
+		uint32 subItems = SteamUGC()->GetSubscribedItems(fileIds, NumItems);
+
+		for (uint32 i = 0; i < subItems; ++i)
+		{
+			outArray.Add(FBPSteamWorkshopID(fileIds[i]));
+		}
+
+		delete[] fileIds;
+
+		return outArray;
+	}
+	else
+	{
+		UE_LOG(AdvancedSteamWorkshopLog, Warning, TEXT("Error in GetSubscribedWorkshopItemCount : SteamAPI is not Inited!"));
+		return outArray;
+	}
+#endif
+
+	UE_LOG(AdvancedSteamWorkshopLog, Warning, TEXT("Error in GetSubscribedWorkshopItemCount : Called on an incompatible platform"));
+	return outArray;
+}

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Private/SteamRequestGroupOfficersCallbackProxy.cpp

@@ -0,0 +1,121 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+
+#include "SteamRequestGroupOfficersCallbackProxy.h"
+#include "Online/CoreOnline.h"
+#include "AdvancedSteamFriendsLibrary.h"
+#include "OnlineSubSystemHeader.h"
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+#include "steam/isteamfriends.h"
+#endif
+//#include "OnlineSubsystemSteamTypes.h"
+
+//////////////////////////////////////////////////////////////////////////
+// UEndSessionCallbackProxy
+
+USteamRequestGroupOfficersCallbackProxy::USteamRequestGroupOfficersCallbackProxy(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+USteamRequestGroupOfficersCallbackProxy::~USteamRequestGroupOfficersCallbackProxy()
+{
+}
+
+USteamRequestGroupOfficersCallbackProxy* USteamRequestGroupOfficersCallbackProxy::GetSteamGroupOfficerList(UObject* WorldContextObject, FBPUniqueNetId GroupUniqueNetID)
+{
+	USteamRequestGroupOfficersCallbackProxy* Proxy = NewObject<USteamRequestGroupOfficersCallbackProxy>();
+
+	Proxy->GroupUniqueID = GroupUniqueNetID;
+	return Proxy;
+}
+
+void USteamRequestGroupOfficersCallbackProxy::Activate()
+{
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (SteamAPI_Init())
+	{
+		uint64 id = *((uint64*)GroupUniqueID.UniqueNetId->GetBytes());
+		SteamAPICall_t hSteamAPICall = SteamFriends()->RequestClanOfficerList(id);
+	
+		m_callResultGroupOfficerRequestDetails.Set(hSteamAPICall, this, &USteamRequestGroupOfficersCallbackProxy::OnRequestGroupOfficerDetails);
+		return;
+	}
+#endif
+	TArray<FBPSteamGroupOfficer> EmptyArray;
+	OnFailure.Broadcast(EmptyArray);
+}
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+void USteamRequestGroupOfficersCallbackProxy::OnRequestGroupOfficerDetails(ClanOfficerListResponse_t *pResult, bool bIOFailure)
+{
+	TArray<FBPSteamGroupOfficer> OfficerArray;
+	
+	//FOnlineSubsystemSteam* SteamSubsystem = (FOnlineSubsystemSteam*)(IOnlineSubsystem::Get(STEAM_SUBSYSTEM));
+
+	if (bIOFailure || !pResult || !pResult->m_bSuccess)
+	{
+		//if (SteamSubsystem != nullptr)
+		{
+		//	SteamSubsystem->ExecuteNextTick([this]()
+			//{
+				TArray<FBPSteamGroupOfficer> FailureArray;
+				OnFailure.Broadcast(FailureArray);
+			//});
+		}
+		//OnFailure.Broadcast(OfficerArray);
+		return;
+	}
+
+	if (SteamAPI_Init())
+	{
+		uint64 id = *((uint64*)GroupUniqueID.UniqueNetId->GetBytes());
+
+		FBPSteamGroupOfficer Officer;
+		CSteamID ClanOwner = SteamFriends()->GetClanOwner(id);
+
+		Officer.bIsOwner = true;
+
+		TSharedPtr<const FUniqueNetId> ValueID(new const FUniqueNetIdSteam2(ClanOwner));
+		Officer.OfficerUniqueNetID.SetUniqueNetId(ValueID);
+		OfficerArray.Add(Officer);
+
+		for (int i = 0; i < pResult->m_cOfficers; i++)
+		{
+			CSteamID OfficerSteamID = SteamFriends()->GetClanOfficerByIndex(id, i);
+
+			Officer.bIsOwner = false;
+
+			TSharedPtr<const FUniqueNetId> newValueID(new const FUniqueNetIdSteam2(OfficerSteamID));
+			Officer.OfficerUniqueNetID.SetUniqueNetId(newValueID);
+
+			OfficerArray.Add(Officer);
+		}
+
+		//if (SteamSubsystem != nullptr)
+		//{
+			//SteamSubsystem->ExecuteNextTick([OfficerArray, this]()
+			//{
+				OnSuccess.Broadcast(OfficerArray);
+			//});
+		//}
+
+		//OnSuccess.Broadcast(OfficerArray);
+		return;
+	}
+	else
+	{
+		//if (SteamSubsystem != nullptr)
+		{
+			//SteamSubsystem->ExecuteNextTick([this]()
+			//{
+				TArray<FBPSteamGroupOfficer> FailureArray;
+				OnFailure.Broadcast(FailureArray);
+			//});
+		}
+	}
+
+	// Should never hit this anyway
+	//OnFailure.Broadcast(OfficerArray);
+}
+#endif
+

VIRTUOS_ExpansionPluginTests/Plugins/AdvancedSessions/AdvancedSteamSessions/Source/AdvancedSteamSessions/Private/SteamWSRequestUGCDetailsCallbackProxy.cpp

@@ -0,0 +1,101 @@
+// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
+
+#include "SteamWSRequestUGCDetailsCallbackProxy.h"
+#include "OnlineSubSystemHeader.h"
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+#include "steam/isteamugc.h"
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+// UEndSessionCallbackProxy
+
+USteamWSRequestUGCDetailsCallbackProxy::USteamWSRequestUGCDetailsCallbackProxy(const FObjectInitializer& ObjectInitializer)
+	: Super(ObjectInitializer)
+{
+}
+
+
+USteamWSRequestUGCDetailsCallbackProxy* USteamWSRequestUGCDetailsCallbackProxy::GetWorkshopItemDetails(UObject* WorldContextObject, FBPSteamWorkshopID WorkShopID/*, int32 NumSecondsBeforeTimeout*/)
+{
+	USteamWSRequestUGCDetailsCallbackProxy* Proxy = NewObject<USteamWSRequestUGCDetailsCallbackProxy>();
+
+	Proxy->WorkShopID = WorkShopID;
+	return Proxy;
+}
+
+void USteamWSRequestUGCDetailsCallbackProxy::Activate()
+{
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+	if (SteamAPI_Init())
+	{
+		// #TODO: Support arrays instead in the future?
+		UGCQueryHandle_t hQueryHandle = SteamUGC()->CreateQueryUGCDetailsRequest((PublishedFileId_t *)&WorkShopID.SteamWorkshopID, 1);
+		// #TODO: add search settings here by calling into the handle?
+		SteamAPICall_t hSteamAPICall = SteamUGC()->SendQueryUGCRequest(hQueryHandle);
+
+		// Need to release the query
+		SteamUGC()->ReleaseQueryUGCRequest(hQueryHandle);
+
+		if (hSteamAPICall == k_uAPICallInvalid)
+		{
+			OnFailure.Broadcast(FBPSteamWorkshopItemDetails());
+			return;
+		}
+
+		m_callResultUGCRequestDetails.Set(hSteamAPICall, this, &USteamWSRequestUGCDetailsCallbackProxy::OnUGCRequestUGCDetails);
+		return;
+	}
+#endif
+	OnFailure.Broadcast(FBPSteamWorkshopItemDetails());
+}
+
+#if PLATFORM_WINDOWS || PLATFORM_MAC || PLATFORM_LINUX
+void USteamWSRequestUGCDetailsCallbackProxy::OnUGCRequestUGCDetails(SteamUGCQueryCompleted_t *pResult, bool bIOFailure)
+{	
+	//FOnlineSubsystemSteam* SteamSubsystem = (FOnlineSubsystemSteam*)(IOnlineSubsystem::Get(STEAM_SUBSYSTEM));
+
+	if (bIOFailure || !pResult || pResult->m_unNumResultsReturned <= 0)
+	{
+		//if (SteamSubsystem != nullptr)
+		{
+		//	SteamSubsystem->ExecuteNextTick([this]()
+			//{
+				OnFailure.Broadcast(FBPSteamWorkshopItemDetails());
+			//});
+		}
+		//OnFailure.Broadcast(FBPSteamWorkshopItemDetails());
+		return;
+	}
+	if (SteamAPI_Init())
+	{
+		SteamUGCDetails_t Details;
+		if (SteamUGC()->GetQueryUGCResult(pResult->m_handle, 0, &Details))
+		{
+			//if (SteamSubsystem != nullptr)
+			{
+				//SteamSubsystem->ExecuteNextTick([Details, this]()
+				//{
+					OnSuccess.Broadcast(FBPSteamWorkshopItemDetails(Details));
+				//});
+			}
+
+			//OnSuccess.Broadcast(FBPSteamWorkshopItemDetails(Details));
+			return;
+		}
+	}
+	else
+	{
+		//if (SteamSubsystem != nullptr)
+		{
+			//SteamSubsystem->ExecuteNextTick([this]()
+			//{
+				OnFailure.Broadcast(FBPSteamWorkshopItemDetails());
+			//});
+		}
+	}
+
+	// Not needed, should never hit here
+	//OnFailure.Broadcast(FBPSteamWorkshopItemDetails());
+}
+#endif
+