TextLocalizationManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Async/TaskGraphFwd.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/CriticalSection.h"
#include "Internationalization/LocKeyFuncs.h"
#include "Internationalization/LocTesting.h"
#include "Internationalization/LocalizedTextSourceTypes.h"
#include "Internationalization/TextKey.h"
#include "Misc/Crc.h"
#include "Misc/EnumClassFlags.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
 
#include <atomic>
 
class FTextLocalizationResource;
class ILocalizedTextSource;
class IPakFile;
struct FLogCategoryBase;
struct FPolyglotTextData;
 
enum class ETextLocalizationManagerInitializedFlags : uint8
{
    None = 0,
    Engine = 1<<0,
    Game = 1<<1,
};
ENUM_CLASS_FLAGS(ETextLocalizationManagerInitializedFlags);
 
class FTextLocalizationManager
{
    friend CORE_API void BeginPreInitTextLocalization();
    friend CORE_API void BeginInitTextLocalization();
    friend CORE_API void InitEngineTextLocalization();
    friend CORE_API void InitGameTextLocalization();
 
private:
 
    struct FDisplayStringEntry
    {
        FTextConstDisplayStringRef DisplayString;
#if WITH_EDITORONLY_DATA
        FTextKey LocResID;
#endif
        int32 LocalizationTargetPathId = INDEX_NONE;
        uint32 SourceStringHash;
 
        FDisplayStringEntry(const FTextKey& InLocResID, const int32 InLocalizationTargetPathId, const uint32 InSourceStringHash, const FTextConstDisplayStringRef& InDisplayString)
            : DisplayString(InDisplayString)
#if WITH_EDITORONLY_DATA
            , LocResID(InLocResID)
#endif
            , LocalizationTargetPathId(InLocalizationTargetPathId)
            , SourceStringHash(InSourceStringHash)
        {
        }
    };
 
    typedef TMap<FTextId, FDisplayStringEntry> FDisplayStringLookupTable;
 
    struct FDisplayStringsForLocalizationTarget
    {
        FString LocalizationTargetPath;
 
        TSet<FTextId> TextIds;
 
        bool bIsMounted = false;
    };
 
    struct FDisplayStringsByLocalizationTargetId
    {
    public:
        FDisplayStringsForLocalizationTarget& FindOrAdd(FStringView InLocalizationTargetPath, int32* OutLocalizationTargetPathId = nullptr);
        FDisplayStringsForLocalizationTarget* Find(const int32 InLocalizationTargetPathId);
        void TrackTextId(const int32 InCurrentLocalizationPathId, const int32 InNewLocalizationPathId, const FTextId& InTextId);
 
    private:
        TArray<FDisplayStringsForLocalizationTarget> LocalizationTargets;
        TMap<FStringView, int32> LocalizationTargetPathsToIds;
    };
 
private:
    std::atomic<ETextLocalizationManagerInitializedFlags> InitializedFlags{ ETextLocalizationManagerInitializedFlags::None };
    
    bool IsInitialized() const
    {
        return InitializedFlags != ETextLocalizationManagerInitializedFlags::None;
    }
 
    mutable FRWLock DisplayStringTableRW;
    FDisplayStringLookupTable DisplayStringLookupTable;
    FDisplayStringsByLocalizationTargetId DisplayStringsByLocalizationTargetId;
 
    mutable FRWLock TextRevisionRW;
    TMap<FTextId, uint16> LocalTextRevisions;
    uint16 TextRevisionCounter;
 
#if WITH_EDITOR
    uint8 GameLocalizationPreviewAutoEnableCount;
    bool bIsGameLocalizationPreviewEnabled;
    bool bIsLocalizationLocked;
#endif
 
    CORE_API FTextLocalizationManager();
    friend class FLazySingleton;
    
public:
 
    CORE_API ~FTextLocalizationManager();
    UE_NONCOPYABLE(FTextLocalizationManager);
 
    static CORE_API FTextLocalizationManager& Get();
    static CORE_API void TearDown();
 
    static CORE_API bool IsDisplayStringSupportEnabled();
 
    CORE_API void DumpMemoryInfo() const;
    CORE_API void CompactDataStructures();
 
#if ENABLE_LOC_TESTING
private:
    void DumpLiveTableImpl(const FString* NamespaceFilter, const FString* KeyFilter, const FString* DisplayStringFilter, TFunctionRef<void(const FTextId& Id, const FTextConstDisplayStringRef& DisplayString)> Callback) const;
public:
    CORE_API void DumpLiveTable(const FString* NamespaceFilter = nullptr, const FString* KeyFilter = nullptr, const FString* DisplayStringFilter = nullptr, const FLogCategoryBase* CategoryOverride = nullptr) const;
    CORE_API void DumpLiveTable(const FString& OutputFilename, const FString* NamespaceFilter = nullptr, const FString* KeyFilter = nullptr, const FString* DisplayStringFilter = nullptr) const;
    CORE_API void AddOrUpdateDisplayStringInLiveTable(const FString& Namespace, const FString& Key, const FString& DisplayString, const FString* const SourceStringPtr = nullptr);
#endif
 
    CORE_API FString GetRequestedLanguageName() const;
 
    CORE_API FString GetRequestedLocaleName() const;
 
    CORE_API FString GetNativeCultureName(const ELocalizedTextSourceCategory InCategory) const;
 
    CORE_API TArray<FString> GetLocalizedCultureNames(const ELocalizationLoadFlags InLoadFlags) const;
 
    CORE_API int32 GetLocalizationTargetPathId(FStringView InLocalizationTargetPath);
 
    CORE_API void RegisterTextSource(const TSharedRef<ILocalizedTextSource>& InLocalizedTextSource, const bool InRefreshResources = true);
 
    CORE_API void RegisterPolyglotTextData(const FPolyglotTextData& InPolyglotTextData, const bool InAddDisplayString = true);
    CORE_API void RegisterPolyglotTextData(TArrayView<const FPolyglotTextData> InPolyglotTextDataArray, const bool InAddDisplayStrings = true);
 
    CORE_API FTextConstDisplayStringPtr FindDisplayString(const FTextKey& Namespace, const FTextKey& Key, const FString* const SourceStringPtr = nullptr) const;
 
    CORE_API FTextConstDisplayStringPtr GetDisplayString(const FTextKey& Namespace, const FTextKey& Key, const FString* const SourceStringPtr) const;
 
#if WITH_EDITORONLY_DATA
    CORE_API bool GetLocResID(const FTextKey& Namespace, const FTextKey& Key, FString& OutLocResId) const;
#endif
 
    CORE_API void UpdateFromLocalizationResource(const FString& LocalizationResourceFilePath);
    CORE_API void UpdateFromLocalizationResource(const FTextLocalizationResource& TextLocalizationResource);
 
    CORE_API void WaitForAsyncTasks();
 
    CORE_API void NotifyWhenAsyncTasksCompleted(TUniqueFunction<void()>&& Notification);
 
    CORE_API void RefreshResources(TUniqueFunction<void()>&& Notification = nullptr);
 
    CORE_API void HandleLocalizationTargetsMounted(TArrayView<const FString> LocalizationTargetPaths, TUniqueFunction<void()>&& Notification = nullptr);
 
    CORE_API void HandleLocalizationTargetsUnmounted(TArrayView<const FString> LocalizationTargetPaths, TUniqueFunction<void()>&& Notification = nullptr);
 
    CORE_API uint16 GetTextRevision() const;
 
    CORE_API uint16 GetLocalRevisionForTextId(const FTextId& InTextId) const;
 
    CORE_API void GetTextRevisions(const FTextId& InTextId, uint16& OutGlobalTextRevision, uint16& OutLocalTextRevision) const;
 
#if WITH_EDITOR
    CORE_API void EnableGameLocalizationPreview();
 
    CORE_API void EnableGameLocalizationPreview(const FString& CultureName);
 
    CORE_API void DisableGameLocalizationPreview();
 
    CORE_API bool IsGameLocalizationPreviewEnabled() const;
 
    CORE_API void PushAutoEnableGameLocalizationPreview();
 
    CORE_API void PopAutoEnableGameLocalizationPreview();
 
    CORE_API bool ShouldGameLocalizationPreviewAutoEnable() const;
 
    CORE_API void ConfigureGameLocalizationPreviewLanguage(const FString& CultureName);
 
    CORE_API FString GetConfiguredGameLocalizationPreviewLanguage() const;
 
    CORE_API bool IsLocalizationLocked() const;
#endif
 
    CORE_API bool ShouldForceLoadGameLocalization() const;
 
    DECLARE_EVENT(FTextLocalizationManager, FTextRevisionChangedEvent)
    FTextRevisionChangedEvent OnTextRevisionChangedEvent;
 
private:
    void OnPakFileMounted(const IPakFile& PakFile);
 
    void OnCultureChanged();
 
    void LoadLocalizationResourcesForCulture_Sync(TArrayView<const TSharedPtr<ILocalizedTextSource>> AvailableTextSources, const FString& CultureName, const ELocalizationLoadFlags LocLoadFlags);
    void LoadLocalizationResourcesForCulture_Async(const FString& CultureName, const ELocalizationLoadFlags LocLoadFlags, TUniqueFunction<void()>&& Notification);
 
    void LoadLocalizationResourcesForPrioritizedCultures_Sync(TArrayView<const TSharedPtr<ILocalizedTextSource>> AvailableTextSources, TArrayView<const FString> PrioritizedCultureNames, const ELocalizationLoadFlags LocLoadFlags);
    void LoadLocalizationResourcesForPrioritizedCultures_Async(TArrayView<const FString> PrioritizedCultureNames, const ELocalizationLoadFlags LocLoadFlags);
 
    void LoadLocalizationTargetsForPrioritizedCultures_Sync(TArrayView<const TSharedPtr<ILocalizedTextSource>> AvailableTextSources, TArrayView<const FString> LocalizationTargetPaths, TArrayView<const FString> PrioritizedCultureNames, const ELocalizationLoadFlags LocLoadFlags);
    void LoadLocalizationTargetsForPrioritizedCultures_Async(TArrayView<const FString> LocalizationTargetPaths, TArrayView<const FString> PrioritizedCultureNames, const ELocalizationLoadFlags LocLoadFlags, TUniqueFunction<void()>&& Notification);
 
    void LoadChunkedLocalizationResources_Sync(TArrayView<const TSharedPtr<ILocalizedTextSource>> AvailableTextSources, const int32 ChunkId, const FString& PakFilename);
    void LoadChunkedLocalizationResources_Async(const int32 ChunkId, const FString& PakFilename);
 
    void QueueAsyncTask(TUniqueFunction<void()>&& Task);
 
    struct FUpdateLiveTableOptions
    {
        FUpdateLiveTableOptions()
        {
        }
 
        bool bDirtyTextRevision = true;
        bool bReplaceExisting = true;
    };
 
    void UpdateLiveTable(FTextLocalizationResource&& TextLocalizationResource, const FUpdateLiveTableOptions& UpdateOptions = FUpdateLiveTableOptions());
 
    void DirtyLocalRevisionForTextId(const FTextId& InTextId);
 
    FTextConstDisplayStringPtr FindDisplayString_Internal(const FTextId& TextId, const FString& SourceString) const;
 
    void DirtyTextRevision();
 
    TArray<TSharedPtr<ILocalizedTextSource>> LocalizedTextSources;
 
    TSharedPtr<class FLocalizationResourceTextSource> LocResTextSource;
 
    TSharedPtr<class FPolyglotTextSource> PolyglotTextSource;
 
    FGraphEventRef AsyncLocalizationTask;
};