VivoxGameInstance.h

Go to the documentation of this file.

#pragma once
 
#include "SteamBeaconGameInstance.h"
 
#if !PLATFORM_LINUX
#include "VivoxCore.h"
#endif
 
#include "VivoxGameInstance.generated.h"
 
#define VIVOX_ALLOW_EDITOR 0
#define VIVOX_ALLOW_PROD 1
 
//Turn the last flag off if you want to disable it entirely;
#define VIVOX_ENABLED ((WITH_EDITOR && VIVOX_ALLOW_EDITOR) || (!WITH_EDITOR && VIVOX_ALLOW_PROD)) && 1
 
DEFINE_LOG_CATEGORY_STATIC(LogVivoxGameInstance, Log, All);
DEFINE_LOG_CATEGORY_STATIC(LogVivoxToken, Log, All);
 
#if !PLATFORM_LINUX
struct FVivoxToken
{
    static void GenerateClientLoginToken(const ILoginSession& LoginSession, FString& OutToken);
    static void GenerateClientJoinToken(const IChannelSession& ChannelSession, FString& OutToken);
};
 
template<class T>
class CachedProperty
{
public:
    explicit CachedProperty(T value) {
        m_dirty = false;
        m_value = value;
    }
 
    const T &GetValue() const {
        return m_value;
    }
 
    void SetValue(const T &value) {
        if (m_value != value) {
            m_value = value;
            m_dirty = true;
        }
    }
 
    void SetDirty(bool value) {
        m_dirty = value;
    }
 
    bool IsDirty() const {
        return m_dirty;
    }
protected:
    bool m_dirty;
    T m_value;
};
#endif
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_ThreeParams(FParticipantUpdated, bool, bIsSelf, const FString&, PlayerName, bool, bIsSpeaking);
 
class AProjectXPlayerState;
 
USTRUCT()
struct FVoiceChannelInfo
{
    GENERATED_BODY()
public:
    UPROPERTY()
    FString SessionName = "Invalid";
    UPROPERTY()
    int32 SquadID = -1;
 
    bool IsValid() {return !SessionName.Equals("Invalid"); }
};
 
UCLASS(config = Game)
class PROJECTX_API UVivoxGameInstance : public USteamBeaconGameInstance
{
    GENERATED_BODY()
 
public:
    UVivoxGameInstance();
 
    virtual void Init() override;
    virtual void Shutdown() override;
    void OnClientTravel(const FString& PendingURL, ETravelType TravelType, bool bIsSeamlessTravel);
 
    virtual const FString GetPlatformAccountID();
    //Parses BaseName into a safe id that can be exposed to the network that is safe to be used by Vivox
    UFUNCTION(BlueprintPure)
    static FString GetVivoxSafeName(const FString BaseName);
    UFUNCTION(BlueprintPure)
    static FString GetVivoxSafePlayerName(const FString BaseName);
    UFUNCTION(BlueprintPure)
    static APlayerState* GetPlayerStateByVivoxName(const UObject* WorldContextObject, UPARAM(ref) const FString& ID);
    UFUNCTION(BlueprintPure, Category = "VOIP")
    float GetParticipantVolume() const;
    UFUNCTION(BlueprintPure)
    bool IsUsingPushToTalk() const { return bUsingPushToTalk; };
    UFUNCTION(BlueprintCallable, Category = "VOIP")
    void UpdateParticipantVolume(const float Volume);
    UFUNCTION(BlueprintCallable, Category = "VOIP")
    void UpdatePushToTalk(const bool bNewPushToTalk);
 
    UPROPERTY(BlueprintAssignable)
    FParticipantUpdated OnParticipantUpdated;
private:
    bool bUsingPushToTalk = false;
 
#if !PLATFORM_LINUX
public:
    virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Out = *GLog) override;
 
    //Steam Party Beacon overrides for party voice chat
    virtual void InitBeaconHost() override;
    virtual void InitBeaconClient(const FOnlineSessionSearchResult& DesiredHost) override;
    virtual void InitBeaconClientForServerPlayer() override;
 
    void BindLoginSessionHandlers(bool DoBind, ILoginSession& LoginSession);
    void BindChannelSessionHandlers(bool DoBind, IChannelSession& ChannelSession);
 
    VivoxCoreError Initialize(int logLevel);
    void Uninitialize();
 
    VivoxCoreError Login(const FString& PlayerName);
    void ReLog();
    void Logout();
    void ReJoinVoiceChannels();
    void ReJoinLastKnownSquadChannel();
    void RejoinPartyVoiceChannel();
    VivoxCoreError JoinVoiceChannels(FString OnlineSessionId, int32 TeamNum = -1);
    VivoxCoreError JoinVoiceChannels(FString OnlineSessionId, int32 TeamNum, bool bUseOpenMic);
    VivoxCoreError Join(ChannelType Type, bool IsOpenMic, FString ChannelName);
    VivoxCoreError MultiChanPushToTalk(bool PTTKeyPressed);
    void LeaveVoiceChannels(FVoiceChannelInfo Exception = FVoiceChannelInfo());
    void LeaveVoiceChannel(FVoiceChannelInfo ChannelToLeave);
    void Update3DPosition(APawn* Pawn);
    void MutePlayerByPlayerState(const class AProjectXPlayerState* PlayerState, bool bToggle);
 
    void OnLoginSessionStateChanged(LoginState State);
    void OnChannelParticipantAdded(const IParticipant& Participant);
    void OnChannelParticipantRemoved(const IParticipant& Participant);
    void OnChannelParticipantUpdated(const IParticipant& Participant);
    void OnChannelAudioStateChanged(const IChannelConnectionState& State);
    void OnChannelTextStateChanged(const IChannelConnectionState& State);
    void OnChannelTextMessageReceived(const IChannelTextMessage& Message);
 
    virtual bool IsInitialized();
    virtual bool IsLoggedIn();
 
protected:
    //Event: Login Complete Connected to Lobby/Party
    virtual void OnPlayerStateEvent(ASteamBeaconPlayerState* InPlayerState) override;
    //Event: Host Connection Failed
    virtual void OnSteamBeaconHostConnectionFailureEvent() override;
 
private:
    bool ChangeSoundClassVolume(float Volume, const FSoftObjectPath& SoundClassPath);
 
public:
    IClient* VivoxVoiceClient;
    AccountId LoggedInAccountID;
    bool bInitialized;
    bool bInitializing;
    bool bLoggedIn;
    bool bLoggingIn;
    bool bRelogging;
    TSharedPtr<IChannelSession> GetChannelSessionForRoster();
    FVoiceChannelInfo PartyVoiceChannel;
 
private:
    static bool bCleanedUp;
    FTimerHandle DelayDummyHandle;
    FTimerHandle RejoinSquadTimerHandle;
    FVivoxCoreModule* VivoxModule;
    FString LoggedInPlayerName;
    ChannelId ConnectedPositionalChannel; // You can only be in one Positional channel at a time.
    CachedProperty<FVector> CachedPosition = CachedProperty<FVector>(FVector());
    CachedProperty<FVector> CachedForwardVector = CachedProperty<FVector>(FVector());
    CachedProperty<FVector> CachedUpVector = CachedProperty<FVector>(FVector());
    FVoiceChannelInfo LastKnownSquadVoiceChannel;
    TMap<FString, FString> KnownParticipants = TMap<FString, FString>();
 
    bool Get3DValuesAreDirty() const;
    void Clear3DValuesAreDirty();
#endif
};