IAnalyticsProvider.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "AnalyticsEventAttribute.h"
 
class Error;
 
enum class EAnalyticsRecordEventMode : uint8
{
    Cached,
    Immediate
};
 
const TCHAR* LexToString(EAnalyticsRecordEventMode Mode);
 
class IAnalyticsProvider
{
public:
    bool StartSession()
    {
        return StartSession(TArray<FAnalyticsEventAttribute>());
    }
 
    virtual bool StartSession(const TArray<FAnalyticsEventAttribute>& Attributes) = 0;
 
    bool StartSession(const FAnalyticsEventAttribute& Attribute)
    {
        return StartSession(TArray<FAnalyticsEventAttribute> { Attribute });
    }
 
    bool StartSession(const FString& ParamName, const FString& ParamValue)
    {
        return StartSession(TArray<FAnalyticsEventAttribute> { FAnalyticsEventAttribute(ParamName, ParamValue) });
    }
 
    virtual void EndSession() = 0;
 
    virtual FString GetSessionID() const = 0;
 
    virtual bool SetSessionID(const FString& InSessionID) = 0;
 
    virtual void FlushEvents() = 0;
 
    virtual void SetUserID(const FString& InUserID) = 0;
 
    virtual FString GetUserID() const = 0;
 
 
    virtual void SetDefaultEventAttributes(TArray<FAnalyticsEventAttribute>&& Attributes) = 0;
 
    virtual TArray<FAnalyticsEventAttribute> GetDefaultEventAttributesSafe() const = 0;
 
    virtual int32 GetDefaultEventAttributeCount() const = 0;
 
    virtual FAnalyticsEventAttribute GetDefaultEventAttribute(int AttributeIndex) const = 0;
 
    virtual void SetBuildInfo(const FString& InBuildInfo)
    {
        RecordEvent(TEXT("BuildInfo"), TArray<FAnalyticsEventAttribute> { FAnalyticsEventAttribute(TEXT("BuildInfo"), InBuildInfo) });
    }
 
    virtual void SetGender(const FString& InGender)
    {
        RecordEvent(TEXT("Gender"), TArray<FAnalyticsEventAttribute> { FAnalyticsEventAttribute(TEXT("Gender"), InGender) });
    }
 
    virtual void SetLocation(const FString& InLocation)
    {
        RecordEvent(TEXT("Location"), TArray<FAnalyticsEventAttribute> { FAnalyticsEventAttribute(TEXT("Location"), InLocation) });
    }
 
    virtual void SetAge(const int32 InAge)
    {
        RecordEvent(TEXT("Age"), TArray<FAnalyticsEventAttribute> { FAnalyticsEventAttribute(TEXT("Age"), InAge) });
    }
 
    virtual void RecordEvent(const FString& EventName, const TArray<FAnalyticsEventAttribute>& Attributes) = 0;
 
    virtual void RecordEvent(const FString& EventName, const TArray<FAnalyticsEventAttribute>& Attributes, EAnalyticsRecordEventMode Mode)
    {
        RecordEvent(EventName, Attributes);
    }
 
    void RecordEvent(const FString& EventName)
    {
        RecordEvent(EventName, TArray<FAnalyticsEventAttribute>());
    }
 
    void RecordEvent(const FString& EventName, const FAnalyticsEventAttribute& Attribute)
    {
        RecordEvent(EventName, TArray<FAnalyticsEventAttribute> { Attribute });
    }
 
    void RecordEvent(const FString& EventName, const FString& ParamName, const FString& ParamValue)
    {
        RecordEvent(EventName, TArray<FAnalyticsEventAttribute> { FAnalyticsEventAttribute(ParamName, ParamValue) });
    }
 
    virtual void RecordItemPurchase(const FString& ItemId, const FString& Currency, int PerItemCost, int ItemQuantity)
    {
        TArray<FAnalyticsEventAttribute> Params;
        Params.Add(FAnalyticsEventAttribute(TEXT("Currency"), Currency));
        Params.Add(FAnalyticsEventAttribute(TEXT("PerItemCost"), PerItemCost));
        RecordItemPurchase(ItemId, ItemQuantity, Params);
    }
 
    virtual void RecordItemPurchase(const FString& ItemId, int ItemQuantity, const TArray<FAnalyticsEventAttribute>& EventAttrs)
    {
        TArray<FAnalyticsEventAttribute> Params(EventAttrs);
        Params.Add(FAnalyticsEventAttribute(TEXT("ItemId"), ItemId));
        Params.Add(FAnalyticsEventAttribute(TEXT("ItemQuantity"), ItemQuantity));
        RecordEvent(TEXT("Item Purchase"), Params);
    }
 
    void RecordItemPurchase(const FString& ItemId, int ItemQuantity)
    {
        RecordItemPurchase(ItemId, ItemQuantity, TArray<FAnalyticsEventAttribute>());
    }
 
    virtual void RecordCurrencyPurchase(const FString& GameCurrencyType, int GameCurrencyAmount, const FString& RealCurrencyType, float RealMoneyCost, const FString& PaymentProvider)
    {
        TArray<FAnalyticsEventAttribute> Params;
        Params.Add(FAnalyticsEventAttribute(TEXT("RealCurrencyType"), RealCurrencyType));
        Params.Add(FAnalyticsEventAttribute(TEXT("RealMoneyCost"), RealMoneyCost));
        Params.Add(FAnalyticsEventAttribute(TEXT("PaymentProvider"), PaymentProvider));
        RecordCurrencyPurchase(GameCurrencyType, GameCurrencyAmount, Params);
    }
 
    virtual void RecordCurrencyPurchase(const FString& GameCurrencyType, int GameCurrencyAmount, const TArray<FAnalyticsEventAttribute>& EventAttrs)
    {
        TArray<FAnalyticsEventAttribute> Params(EventAttrs);
        Params.Add(FAnalyticsEventAttribute(TEXT("GameCurrencyType"), GameCurrencyType));
        Params.Add(FAnalyticsEventAttribute(TEXT("GameCurrencyAmount"), GameCurrencyAmount));
        RecordEvent(TEXT("Currency Purchase"), Params);
    }
 
    virtual void RecordCurrencyPurchase(const FString& GameCurrencyType, int GameCurrencyAmount)
    {
        RecordCurrencyPurchase(GameCurrencyType, GameCurrencyAmount, TArray<FAnalyticsEventAttribute>());
    }
 
    virtual void RecordCurrencyGiven(const FString& GameCurrencyType, int GameCurrencyAmount)
    {
        RecordCurrencyGiven(GameCurrencyType, GameCurrencyAmount, TArray<FAnalyticsEventAttribute>());
    }
 
    virtual void RecordCurrencyGiven(const FString& GameCurrencyType, int GameCurrencyAmount, const TArray<FAnalyticsEventAttribute>& EventAttrs)
    {
        TArray<FAnalyticsEventAttribute> Params(EventAttrs);
        Params.Add(FAnalyticsEventAttribute(TEXT("GameCurrencyType"), GameCurrencyType));
        Params.Add(FAnalyticsEventAttribute(TEXT("GameCurrencyAmount"), GameCurrencyAmount));
        RecordEvent(TEXT("Currency Given"), Params);
    }
 
    virtual void RecordError(const FString& Error, const TArray<FAnalyticsEventAttribute>& EventAttrs)
    {
        TArray<FAnalyticsEventAttribute> Params(EventAttrs);
        Params.Add(FAnalyticsEventAttribute(TEXT("Error"), *Error));
        RecordEvent(TEXT("Game Error"), Params);
    }
 
    virtual void RecordError(const FString& Error)
    {
        RecordError(Error, TArray<FAnalyticsEventAttribute>());
    }
 
    virtual void RecordProgress(const FString& ProgressType, const TArray<FString>& ProgressHierarchy, const TArray<FAnalyticsEventAttribute>& EventAttrs)
    {
        TArray<FAnalyticsEventAttribute> Params(EventAttrs);
        Params.Add(FAnalyticsEventAttribute(TEXT("ProgressType"), *ProgressType));
        FString Hierarchy;
        // Build a dotted hierarchy string from the list of hierarchy progress
        for (int32 Index = 0; Index < ProgressHierarchy.Num(); Index++)
        {
            Hierarchy += ProgressHierarchy[Index];
            if (Index + 1 < ProgressHierarchy.Num())
            {
                Hierarchy += TEXT(".");
            }
        }
        Params.Add(FAnalyticsEventAttribute(TEXT("ProgressHierarchy"), *Hierarchy));
        RecordEvent(TEXT("Progression"), Params);
    }
 
    virtual void RecordProgress(const FString& ProgressType, const FString& ProgressHierarchy)
    {
        TArray<FString> Hierarchy;
        Hierarchy.Add(ProgressHierarchy);
        RecordProgress(ProgressType, Hierarchy, TArray<FAnalyticsEventAttribute>());
    }
 
    virtual void RecordProgress(const FString& ProgressType, const FString& ProgressHierarchy, const TArray<FAnalyticsEventAttribute>& EventAttrs)
    {
        TArray<FString> Hierarchy;
        Hierarchy.Add(ProgressHierarchy);
        RecordProgress(ProgressType, Hierarchy, EventAttrs);
    }
 
    virtual ~IAnalyticsProvider() {}
 
protected:
 
};