Villui
/
VRTowerDef
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
VRTowerDef/Plugins/MetaXR/Source/OculusXREditor/Private/OculusXRPlatformToolWidget.cpp

1651 lines
60 KiB
C++
Raw Blame History

// @lint-ignore-every LICENSELINT
// Copyright Epic Games, Inc. All Rights Reserved.
#include "OculusXRPlatformToolWidget.h"
#include "Widgets/Text/SRichTextBlock.h"
#include "DesktopPlatformModule.h"
#include "Editor.h"
#include "Styling/AppStyle.h"
#include "Misc/FileHelper.h"
#include "Internationalization/Regex.h"
#include "Misc/MessageDialog.h"
#include "Widgets/Layout/SExpandableArea.h"
#include "Widgets/Images/SImage.h"
#include "HAL/FileManagerGeneric.h"
#include "DOM/JsonObject.h"
#include "Serialization/JsonSerializer.h"
#include "OculusXRHMDModule.h"
#include "GenericPlatform/GenericPlatformMisc.h"
#include "Interfaces/IPluginManager.h"
#include "SHyperlinkLaunchURL.h"
#include "Misc/EngineVersionComparison.h"
#define LOCTEXT_NAMESPACE "OculusPlatformToolWidget"
#define TEXT_INDENT_OFFSET 20.0f
const FString UrlPlatformUtil = "https://www.oculus.com/download_app/?id=1076686279105243";
const FString ProjectPlatformUtilPath = "Oculus/Tools/ovr-platform-util.exe";
FText OculusPlatformDialogTitle = LOCTEXT("DownloadOculusPlatformUtility", "Download Oculus Platform Utility");
FText OculusPlatformDialogMessage = LOCTEXT("DownloadOculusPlatformUtilityMessage",
"Oculus Platform Window would like to download the latest version of the Oculus Platform Utility."
" Oculus Platform Utility is a command-line tool that enables the uploading of builds to your release channels on the Oculus Developer Dashboard."
"\n\nYou can learn more about the Oculus Platform Utility at https://developer.oculus.com/distribute/publish-reference-platform-command-line-utility/"
"\n\nCanceling will prevent the download and the UPLOAD button will be unfunctional. Would you like the tool to download the Oculus Platform Utility to your project?");
static bool bShowUploadDebugSymbols = false;
FString SOculusPlatformToolWidget::LogText;
SOculusPlatformToolWidget::SOculusPlatformToolWidget()
{
LogTextUpdated = false;
ActiveUploadButton = true;
Options2DCollapsed = true;
RequestUploadButtonActive = true;
OptionsRedistPackagesCollapsed = true;
EnableUploadButtonDel.BindRaw(this, &SOculusPlatformToolWidget::EnableUploadButton);
UpdateLogTextDel.BindRaw(this, &SOculusPlatformToolWidget::UpdateLogText);
SetProcessDel.BindRaw(this, &SOculusPlatformToolWidget::SetPlatformProcess);
LoadConfigSettings();
FOculusXRHMDModule::GetPluginWrapper().SendEvent2("oculus_platform_tool", "show_window", "integration");
}
void SOculusPlatformToolWidget::Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime)
{
// Update log text if it changes, otherwise constant updating will yeild the field unselectable.
if (LogTextUpdated)
{
ToolConsoleLog->SetText(FText::FromString(LogText));
LogTextUpdated = false;
}
if (RequestUploadButtonActive != ActiveUploadButton)
{
ActiveUploadButton = RequestUploadButtonActive;
BuildButtonToolbar(ButtonToolbar);
}
}
void SOculusPlatformToolWidget::Construct(const FArguments& InArgs)
{
auto logTextBox = SNew(SMultiLineEditableTextBox).IsReadOnly(true);
ToolConsoleLog = logTextBox;
auto mainVerticalBox = SNew(SVerticalBox);
GeneralSettingsBox = mainVerticalBox;
auto buttonToolbarBox = SNew(SHorizontalBox);
ButtonToolbar = buttonToolbarBox;
auto optionalSettings = SNew(SVerticalBox);
OptionalSettings = optionalSettings;
auto expansionFilesSettings = SNew(SVerticalBox);
ExpansionFilesSettings = expansionFilesSettings;
BuildGeneralSettingsBox(GeneralSettingsBox);
BuildButtonToolbar(ButtonToolbar);
BuildExpansionFileBox(ExpansionFilesSettings);
if (PlatformSettings != nullptr)
{
if (PlatformSettings->GetTargetPlatform() == (uint8)EOculusXRPlatformTarget::Rift)
{
BuildRiftOptionalFields(OptionalSettings);
}
else
{
OptionalSettings.Get()->ClearChildren();
}
}
FString ODHIconPath = IPluginManager::Get().FindPlugin(TEXT("OculusXR"))->GetBaseDir() / TEXT("Resources/Icon128.png");
const FName BrushName(*ODHIconPath);
FSlateApplication::Get().GetRenderer()->GenerateDynamicImageResource(BrushName);
ODHIconDynamicImageBrush = MakeShareable(new FSlateDynamicImageBrush(BrushName, FVector2D(60.0f, 60.0f)));
#if PLATFORM_MAC
FString odhLink = "https://developer.oculus.com/downloads/package/oculus-developer-hub-mac/?source=unreal";
#else
FString odhLink = "https://developer.oculus.com/downloads/package/oculus-developer-hub-win/?source=unreal";
#endif
ChildSlot
[SNew(SBorder)
.BorderImage(FAppStyle::GetBrush("ToolPanel.LightGroupBorder"))
.Padding(2)
[SNew(SVerticalBox)
+ SVerticalBox::Slot().Padding(0, 0).FillHeight(1.f)
[SNew(SScrollBox)
+ SScrollBox::Slot()
[SNew(SExpandableArea)
.HeaderPadding(5)
.Padding(5)
.BorderBackgroundColor(FLinearColor(0.4f, 0.4f, 0.4f, 1.0f))
.BodyBorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
.BodyBorderBackgroundColor(FLinearColor::White)
.InitiallyCollapsed(false)
.HeaderContent()
[SNew(SRichTextBlock)
.TextStyle(FAppStyle::Get(), "ToolBar.Heading")
.DecoratorStyleSet(&FAppStyle::Get())
.AutoWrapText(true)
.Text(LOCTEXT("GeneralSettings", "<RichTextBlock.Bold>General Settings</>"))]
.BodyContent()
[mainVerticalBox]]
+ SScrollBox::Slot()
[SNew(SExpandableArea)
.HeaderPadding(5)
.Padding(5)
.BorderBackgroundColor(FLinearColor(0.4f, 0.4f, 0.4f, 1.0f))
.BodyBorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
.BodyBorderBackgroundColor(FLinearColor::White)
.InitiallyCollapsed(true)
.HeaderContent()
[SNew(SRichTextBlock)
.TextStyle(FAppStyle::Get(), "ToolBar.Heading")
.DecoratorStyleSet(&FAppStyle::Get())
.AutoWrapText(true)
.Text(LOCTEXT("OptionalSettings", "<RichTextBlock.Bold>Optional Settings</>"))]
.BodyContent()
[SNew(SVerticalBox)
+ SVerticalBox::Slot().AutoHeight()
[optionalSettings]]]
+ SScrollBox::Slot()
[SNew(SExpandableArea)
.HeaderPadding(5)
.Padding(5)
.BorderBackgroundColor(FLinearColor(0.4f, 0.4f, 0.4f, 1.0f))
.BodyBorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
.BodyBorderBackgroundColor(FLinearColor::White)
.InitiallyCollapsed(true)
.HeaderContent()
[SNew(SRichTextBlock)
.TextStyle(FAppStyle::Get(), "ToolBar.Heading")
.DecoratorStyleSet(&FAppStyle::Get())
.AutoWrapText(true)
.Text(LOCTEXT("ExpansionFileSettings", "<RichTextBlock.Bold>Expansion Files</>"))]
.BodyContent()
[SNew(SVerticalBox)
+ SVerticalBox::Slot().AutoHeight()
[expansionFilesSettings]]]]
+ SVerticalBox::Slot().AutoHeight()
[buttonToolbarBox]
+ SVerticalBox::Slot().FillHeight(1.f)
[SNew(SBorder)
.BorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
[logTextBox]]
+ SVerticalBox::Slot().AutoHeight().Padding(2.0f)
[SNew(SBorder)
.BorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
[SNew(SHorizontalBox)
+ SHorizontalBox::Slot().AutoWidth()
[SNew(SBox)
.WidthOverride(60.0f)
.HeightOverride(60.0f)
[SNew(SImage)
.Image(ODHIconDynamicImageBrush.IsValid() ? ODHIconDynamicImageBrush.Get() : nullptr)]]
+ SHorizontalBox::Slot().FillWidth(1.0f)
[SNew(SVerticalBox)
+ SVerticalBox::Slot().AutoHeight().Padding(2.0f)
[SNew(SRichTextBlock)
.Text(LOCTEXT("ODHCallout",
"<RichTextBlock.Bold>Oculus Developer Hub</> is a desktop companion tool that can upload builds, manage apps and reduce friction in daily Quest development."))
.DecoratorStyleSet(&FAppStyle::Get())
.AutoWrapText(true)]
+ SVerticalBox::Slot().AutoHeight()
[SNew(SBox)
.HAlign(HAlign_Left)
[SNew(SHyperlinkLaunchURL, odhLink)
.Text(LOCTEXT("ODHDownloadPage", "Download Oculus Developer Hub"))
.ToolTipText(LOCTEXT("ODHDownloadPageTooltip", "Opens a page that provides the download link for Oculus Developer Hub"))]]]]]]];
}
void SOculusPlatformToolWidget::BuildGeneralSettingsBox(TSharedPtr<SVerticalBox> box)
{
if (PlatformSettings == nullptr)
{
return;
}
box.Get()->ClearChildren();
BuildTextComboBoxField(GeneralSettingsBox, LOCTEXT("TargetPlatform", "Target Platform"),
&OculusPlatforms, OculusPlatforms[PlatformSettings->GetTargetPlatform()],
&SOculusPlatformToolWidget::OnPlatformSettingChanged);
// Build field for Oculus Application ID.
BuildTextField(box, LOCTEXT("AppID", "Oculus Application ID"), FText::FromString(PlatformSettings->GetApplicationID()),
LOCTEXT("AppIDTT", "Specifies the ID of your app. Obtained from the API tab of your app in the Oculus Dashboard."),
&SOculusPlatformToolWidget::OnApplicationIDChanged);
// Build field for Oculus Application Token.
BuildTextField(box, LOCTEXT("AppToken", "Oculus Application Token"), FText::FromString(PlatformSettings->GetApplicationToken()),
LOCTEXT("AppTokenTT", "Specifies the app secret token. Obtained from the API tab of your app in the Oculus Dashboard."),
&SOculusPlatformToolWidget::OnApplicationTokenChanged, true);
// Build field for Release Channel.
BuildTextField(box, LOCTEXT("ReleaseChannel", "Release Channel"), FText::FromString(PlatformSettings->GetReleaseChannel()),
LOCTEXT("ReleaseChannelTT", "Specifies the release channel for uploading the build. Release channel names are not case-sensitive."),
&SOculusPlatformToolWidget::OnReleaseChannelChanged);
// Build field for Release Notes.
BuildTextField(box, LOCTEXT("ReleaseNote", "Release Note"), FText::FromString(PlatformSettings->GetReleaseNote()),
LOCTEXT("ReleaseNoteTT", "Specifies the release note text shown to users."),
&SOculusPlatformToolWidget::OnReleaseNoteChanged);
// Platform specific fields.
if (PlatformSettings->GetTargetPlatform() == (uint8)EOculusXRPlatformTarget::Rift)
{
// Build field for Rift Build Directory.
BuildFileDirectoryField(box, LOCTEXT("BuildPath", "Rift Build Directory"), FText::FromString(PlatformSettings->OculusRiftBuildDirectory),
LOCTEXT("BuildPathTT", "Specifies the full path to the directory containing your build files."),
&SOculusPlatformToolWidget::OnSelectRiftBuildDirectory, &SOculusPlatformToolWidget::OnClearRiftBuildDirectory);
// Build field for Build Version.
BuildTextField(box, LOCTEXT("BuildVersion", "Build Version"), FText::FromString(PlatformSettings->OculusRiftBuildVersion),
LOCTEXT("BuildVersionTT", "Specifies the version number shown to users."),
&SOculusPlatformToolWidget::OnRiftBuildVersionChanged);
// Build field for Launch File Path.
BuildFileDirectoryField(box, LOCTEXT("LaunchPath", "Launch File Path"), FText::FromString(PlatformSettings->GetLaunchFilePath()),
LOCTEXT("LaunchPathTT", " Specifies the path to the executable that launches your app."),
&SOculusPlatformToolWidget::OnSelectLaunchFilePath, &SOculusPlatformToolWidget::OnClearLaunchFilePath);
}
else
{
// Build field for APK File Path.
BuildFileDirectoryField(box, LOCTEXT("APKLaunchPath", "APK File Path"), FText::FromString(PlatformSettings->GetLaunchFilePath()),
LOCTEXT("APKLaunchPathTT", " Specifies the path to the APK that launches your app."),
&SOculusPlatformToolWidget::OnSelectLaunchFilePath, &SOculusPlatformToolWidget::OnClearLaunchFilePath);
BuildCheckBoxField(box, LOCTEXT("UploadDebugSymbols", "Upload Debug Symbols"), PlatformSettings->UploadDebugSymbols,
LOCTEXT("UploadDebugSymbolsTT", "If checked, debug symbols will be uploaded along with the application."),
&SOculusPlatformToolWidget::OnUploadDebugSymbolsChanged);
if (PlatformSettings->UploadDebugSymbols)
{
if (bShowUploadDebugSymbols != PlatformSettings->UploadDebugSymbols)
{
if (PlatformSettings->GetSymbolDirPath().IsEmpty())
{
FString defaultPath = GenerateSymbolPath();
PlatformSettings->SetSymbolDirPath(FPaths::ConvertRelativePathToFull(defaultPath));
PlatformSettings->SaveConfig();
}
}
// Build field for Debug symbol directory path.
BuildFileDirectoryField(box, LOCTEXT("SymbolPath", "Symbol Directory Path"), FText::FromString(PlatformSettings->GetSymbolDirPath()),
LOCTEXT("SymbolPathTT", "Specifies the path to the directory containing the app symbols (libUE4.so)."),
&SOculusPlatformToolWidget::OnSelectSymbolDirPath, &SOculusPlatformToolWidget::OnClearSymbolDirPath, 1);
BuildCheckBoxField(box, LOCTEXT("DebugSymbolsOnly", "Upload Debug Symbols Only"), PlatformSettings->DebugSymbolsOnly,
LOCTEXT("DebugSymbolsOnlyTT", "If checked, the tool will upload onyl debug symbols to an existing build. Requires Build ID, App ID, App Token, and Debug Symbols Directory."),
&SOculusPlatformToolWidget::OnDebugSymbolsOnlyChanged, 1);
if (PlatformSettings->DebugSymbolsOnly)
{
BuildTextField(box, LOCTEXT("BuildID", "Build ID"), FText::FromString(PlatformSettings->BuildID),
LOCTEXT("BuildIDTT", "Specifies the Build ID to upload debug symbols to."),
&SOculusPlatformToolWidget::OnBuildIDChanged, false, 1);
}
}
bShowUploadDebugSymbols = PlatformSettings->UploadDebugSymbols;
}
}
void SOculusPlatformToolWidget::BuildTextField(TSharedPtr<SVerticalBox> box, FText name, FText text, FText tooltip,
PTextComittedDel deleg, bool isPassword, int32 indentAmount)
{
FMargin textMargin = FMargin(TEXT_INDENT_OFFSET * indentAmount, 1.0f, 1.0f, 1.0f);
box.Get()->AddSlot().Padding(1).AutoHeight()
[SNew(SHorizontalBox)
+ SHorizontalBox::Slot().Padding(1).AutoWidth()
[SNew(SBox)
.WidthOverride(250.f)
.Padding(textMargin)
[SNew(STextBlock)
.Text(name)
.ToolTipText(tooltip)]]
+ SHorizontalBox::Slot().Padding(1).FillWidth(1.f)
[SNew(SEditableTextBox)
.Text(text)
.IsPassword(isPassword)
.OnTextCommitted(this, deleg)]];
}
void SOculusPlatformToolWidget::BuildTextComboBoxField(TSharedPtr<SVerticalBox> box, FText name,
TArray<TSharedPtr<FString>>* options, TSharedPtr<FString> current, PTextComboBoxDel deleg, int32 indentAmount)
{
FMargin textMargin = FMargin(TEXT_INDENT_OFFSET * indentAmount, 1.0f, 1.0f, 1.0f);
box.Get()->AddSlot().Padding(1).AutoHeight()
[SNew(SHorizontalBox)
+ SHorizontalBox::Slot().Padding(1).AutoWidth()
[SNew(SBox)
.WidthOverride(250.f)
.Padding(textMargin)
[SNew(SRichTextBlock)
.DecoratorStyleSet(&FAppStyle::Get())
.Text(name)]]
+ SHorizontalBox::Slot().Padding(1).FillWidth(1.f)
[SNew(STextComboBox)
.OptionsSource(options)
.InitiallySelectedItem(current)
.OnSelectionChanged(this, deleg)]];
}
void SOculusPlatformToolWidget::BuildCheckBoxField(TSharedPtr<SVerticalBox> box, FText name, bool check,
FText tooltip, PCheckBoxChangedDel deleg, int32 indentAmount)
{
FMargin textMargin = FMargin(TEXT_INDENT_OFFSET * indentAmount, 1.0f, 1.0f, 1.0f);
box.Get()->AddSlot().Padding(1).AutoHeight()
[SNew(SHorizontalBox)
+ SHorizontalBox::Slot().Padding(1).AutoWidth()
[SNew(SBox)
.WidthOverride(250.f)
.Padding(textMargin)
[SNew(SRichTextBlock)
.DecoratorStyleSet(&FAppStyle::Get())
.Text(name)]]
+ SHorizontalBox::Slot().Padding(1).FillWidth(1.f)
[SNew(SCheckBox)
.OnCheckStateChanged(this, deleg)
.IsChecked(check ? ECheckBoxState::Checked : ECheckBoxState::Unchecked)]];
}
void SOculusPlatformToolWidget::BuildFileDirectoryField(TSharedPtr<SVerticalBox> box, FText name, FText path, FText tooltip,
PButtonClickedDel deleg, PButtonClickedDel clearDeleg, int32 indentAmount)
{
EVisibility cancelButtonVisibility = path.IsEmpty() ? EVisibility::Hidden : EVisibility::Visible;
FMargin textMargin = FMargin(TEXT_INDENT_OFFSET * indentAmount, 1.0f, 1.0f, 1.0f);
box.Get()->AddSlot().Padding(1).AutoHeight()
[SNew(SHorizontalBox)
+ SHorizontalBox::Slot().Padding(1).AutoWidth()
[SNew(SBox)
.WidthOverride(250.f)
.Padding(textMargin)
[SNew(STextBlock)
.Text(name)
.ToolTipText(tooltip)]]
+ SHorizontalBox::Slot().Padding(1).FillWidth(1.f)
[SNew(SEditableText)
.Text(path)
.IsReadOnly(true)
.Justification(ETextJustify::Left)]
+ SHorizontalBox::Slot().Padding(1).AutoWidth().HAlign(EHorizontalAlignment::HAlign_Right)
[SNew(SButton)
.Text(FText::FromString("X"))
.Visibility(cancelButtonVisibility)
.OnClicked(this, clearDeleg)
.ButtonColorAndOpacity(FLinearColor(0.36f, 0.1f, 0.05f))]
+ SHorizontalBox::Slot().Padding(1).AutoWidth().HAlign(EHorizontalAlignment::HAlign_Right)
[SNew(SButton)
.Text((LOCTEXT("Choose", "Choose...")))
.OnClicked(this, deleg)]];
}
void SOculusPlatformToolWidget::BuildButtonToolbar(TSharedPtr<SHorizontalBox> box)
{
box.Get()->ClearChildren();
box.Get()->AddSlot().FillWidth(1.f);
box.Get()->AddSlot().AutoWidth().Padding(2.f)
[SNew(SButton)
.Text((LOCTEXT("Upload", "Upload")))
.OnClicked(this, &SOculusPlatformToolWidget::OnStartPlatformUpload)
.IsEnabled(ActiveUploadButton)];
box.Get()->AddSlot().AutoWidth().Padding(2.f)
[SNew(SButton)
.Text((LOCTEXT("Cancel", "Cancel")))
.OnClicked(this, &SOculusPlatformToolWidget::OnCancelUpload)
.IsEnabled(!ActiveUploadButton)];
box.Get()->AddSlot().FillWidth(1.f);
}
void SOculusPlatformToolWidget::BuildRiftOptionalFields(TSharedPtr<SVerticalBox> box)
{
if (PlatformSettings == nullptr)
{
return;
}
box.Get()->ClearChildren();
// Add Launch Parameter Field
BuildTextField(box, LOCTEXT("LaunchParams", "Launch Parameters"), FText::FromString(PlatformSettings->OculusRiftLaunchParams),
LOCTEXT("LaunchParamsTT", ""),
&SOculusPlatformToolWidget::OnRiftLaunchParamsChanged);
// Add Firewall Exception Toggle
BuildCheckBoxField(box, LOCTEXT("Firewall", "Firewall Exception"), PlatformSettings->OculusRiftFireWallException,
LOCTEXT("FirewallTT", ""),
&SOculusPlatformToolWidget::OnRiftFirewallChanged);
// Add Gamepad Emulation Dropdown
BuildTextComboBoxField(box, LOCTEXT("GamepadEmu", "Gamepad Emulation"),
&RiftGamepadEmulation, RiftGamepadEmulation[(uint8)PlatformSettings->GetRiftGamepadEmulation()],
&SOculusPlatformToolWidget::OnRiftGamepadEmulationChanged);
// Generate 2D Settings Expandable Area
TSharedRef<SVerticalBox> settings2DBox = SNew(SVerticalBox);
// Add 2D Launch File Field
BuildFileDirectoryField(settings2DBox, LOCTEXT("2DLaunch", "2D Launch File"), FText::FromString(PlatformSettings->OculusRift2DLaunchPath),
LOCTEXT("2DLaunchPathTT", ""),
&SOculusPlatformToolWidget::OnSelect2DLaunchPath, &SOculusPlatformToolWidget::OnClear2DLaunchPath);
// Add 2D Launch Parameter Field
BuildTextField(settings2DBox, LOCTEXT("2DLaunchParams", "2D Launch Parameters"), FText::FromString(PlatformSettings->OculusRift2DLaunchParams),
LOCTEXT("2DLaunchParamsTT", ""),
&SOculusPlatformToolWidget::On2DLaunchParamsChanged);
box.Get()->AddSlot().AutoHeight().Padding(1)
[SNew(SExpandableArea)
.HeaderPadding(5)
.Padding(5)
.BorderBackgroundColor(FLinearColor(0.4f, 0.4f, 0.4f, 1.0f))
.BodyBorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
.BodyBorderBackgroundColor(FLinearColor::White)
.InitiallyCollapsed(Options2DCollapsed)
.OnAreaExpansionChanged(this, &SOculusPlatformToolWidget::On2DOptionsExpanded)
.HeaderContent()
[SNew(SRichTextBlock)
.TextStyle(FAppStyle::Get(), "ToolBar.Heading")
.DecoratorStyleSet(&FAppStyle::Get())
.AutoWrapText(true)
.Text(LOCTEXT("2DSettings", "<RichTextBlock.Bold>2D Settings</>"))]
.BodyContent()
[settings2DBox]];
BuildRedistPackagesBox(box);
}
void SOculusPlatformToolWidget::BuildRedistPackagesBox(TSharedPtr<SVerticalBox> box)
{
// Create check box toggle for each redistributable package we loaded
TSharedRef<SVerticalBox> redistBox = SNew(SVerticalBox);
for (int i = 0; i < PlatformSettings->OculusRedistPackages.Num(); i++)
{
FOculusXRRedistPackage* Package = &PlatformSettings->OculusRedistPackages[i];
redistBox->AddSlot()
.Padding(1)
.AutoHeight()
[SNew(SHorizontalBox)
+ SHorizontalBox::Slot().Padding(1).AutoWidth()
[SNew(SBox)
.WidthOverride(250.f)
[SNew(SRichTextBlock)
.DecoratorStyleSet(&FAppStyle::Get())
.Text(FText::FromString(Package->Name))]]
+ SHorizontalBox::Slot().Padding(1).FillWidth(1.f)
[SNew(SCheckBox)
.OnCheckStateChanged(this, &SOculusPlatformToolWidget::OnRedistPackageStateChanged, Package)
.IsChecked(Package->Included ? ECheckBoxState::Checked : ECheckBoxState::Unchecked)]];
}
box.Get()->AddSlot().AutoHeight().Padding(1)
[SNew(SExpandableArea)
.HeaderPadding(5)
.Padding(5)
.BorderBackgroundColor(FLinearColor(0.4f, 0.4f, 0.4f, 1.0f))
.BodyBorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
.BodyBorderBackgroundColor(FLinearColor::White)
.InitiallyCollapsed(OptionsRedistPackagesCollapsed)
.OnAreaExpansionChanged(this, &SOculusPlatformToolWidget::OnRedistPackagesExpanded)
.HeaderContent()
[SNew(SRichTextBlock)
.TextStyle(FAppStyle::Get(), "ToolBar.Heading")
.DecoratorStyleSet(&FAppStyle::Get())
.AutoWrapText(true)
.Text(LOCTEXT("RedistPack", "<RichTextBlock.Bold>Redistributable Packages</>"))]
.BodyContent()
[redistBox]];
}
void SOculusPlatformToolWidget::BuildExpansionFileBox(TSharedPtr<SVerticalBox> box)
{
if (PlatformSettings == nullptr)
{
return;
}
ExpansionFilesSettings.Get()->ClearChildren();
if (PlatformSettings->GetTargetPlatform() == (uint8)EOculusXRPlatformTarget::Rift)
{
BuildFileDirectoryField(box, LOCTEXT("LanguagePacks", "Language Packs Directory"), FText::FromString(PlatformSettings->GetLanguagePacksPath()),
LOCTEXT("LanguagePacksTT", ""), &SOculusPlatformToolWidget::OnSelectLanguagePacksPath, &SOculusPlatformToolWidget::OnClearLanguagePacksPath);
}
BuildFileDirectoryField(box, LOCTEXT("ExpansionFilesDirectory", "Expansion Files Directory"), FText::FromString(PlatformSettings->GetExpansionFilesPath()),
LOCTEXT("ExpansionFilesTT", ""), &SOculusPlatformToolWidget::OnSelectExpansionFilesPath, &SOculusPlatformToolWidget::OnClearExpansionFilesPath);
TArray<FOculusXRAssetConfig>* AssetConfigs = PlatformSettings->GetAssetConfigs();
if (AssetConfigs)
{
for (int i = 0; i < AssetConfigs->Num(); i++)
{
auto AssetConfigBox = SNew(SVerticalBox);
BuildAssetConfigBox(AssetConfigBox, (*AssetConfigs)[i], i);
box.Get()->AddSlot().AutoHeight().Padding(1)
[SNew(SExpandableArea)
.HeaderPadding(5)
.Padding(5)
.BorderBackgroundColor(FLinearColor(0.4f, 0.4f, 0.4f, 1.0f))
.BodyBorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
.BodyBorderBackgroundColor(FLinearColor::White)
.HeaderContent()
[SNew(SRichTextBlock)
.TextStyle(FAppStyle::Get(), "ToolBar.Heading")
.DecoratorStyleSet(&FAppStyle::Get())
.AutoWrapText(true)
.Text(FText::FromString((*AssetConfigs)[i].Name))]
.BodyContent()
[AssetConfigBox]];
}
}
}
void SOculusPlatformToolWidget::BuildAssetConfigBox(TSharedPtr<SVerticalBox> box, FOculusXRAssetConfig config, int index)
{
box.Get()->AddSlot().Padding(1).AutoHeight()
[SNew(SHorizontalBox)
+ SHorizontalBox::Slot().Padding(1).AutoWidth()
[SNew(SBox)
.WidthOverride(250.f)
[SNew(SRichTextBlock)
.DecoratorStyleSet(&FAppStyle::Get())
.Text(LOCTEXT("AssetType", "Asset Type"))]]
+ SHorizontalBox::Slot().Padding(1).FillWidth(1.f)
[SNew(STextComboBox)
.OptionsSource(&AssetType)
.InitiallySelectedItem(AssetType[(uint8)config.AssetType])
.OnSelectionChanged(this, &SOculusPlatformToolWidget::OnAssetConfigTypeChanged, index)]];
box.Get()->AddSlot().Padding(1).AutoHeight()
[SNew(SHorizontalBox)
+ SHorizontalBox::Slot().Padding(1).AutoWidth()
[SNew(SBox)
.WidthOverride(250.f)
[SNew(SRichTextBlock)
.DecoratorStyleSet(&FAppStyle::Get())
.Text(LOCTEXT("AssetRequired", "Required"))]]
+ SHorizontalBox::Slot().Padding(1).FillWidth(1.f)
[SNew(SCheckBox)
.OnCheckStateChanged(this, &SOculusPlatformToolWidget::OnAssetConfigRequiredChanged, index)
.IsChecked(config.Required ? ECheckBoxState::Checked : ECheckBoxState::Unchecked)]];
box.Get()->AddSlot().Padding(1).AutoHeight()
[SNew(SHorizontalBox)
+ SHorizontalBox::Slot().Padding(1).AutoWidth()
[SNew(SBox)
.WidthOverride(250.f)
[SNew(STextBlock)
.Text(LOCTEXT("SKU", "SKU"))]]
+ SHorizontalBox::Slot().Padding(1).FillWidth(1.f)
[SNew(SEditableTextBox)
.Text(FText::FromString(config.Sku))
.OnTextCommitted(this, &SOculusPlatformToolWidget::OnAssetConfigSKUChanged, index)]];
}
bool SOculusPlatformToolWidget::ConstructArguments(FString& args)
{
if (PlatformSettings == nullptr)
{
return false;
}
if (PlatformSettings->UploadDebugSymbols && PlatformSettings->DebugSymbolsOnly)
{
return ConstructDebugSymbolArguments(args);
}
// Build the args string that will be passed to the CLI. Print all errors that occur to the log.
bool success = true;
switch (PlatformSettings->GetTargetPlatform())
{
case (uint8)EOculusXRPlatformTarget::Rift:
args = "upload-rift-build";
break;
case (uint8)EOculusXRPlatformTarget::Quest:
args = "upload-quest-build";
break;
default:
UpdateLogText(LogText + "ERROR: Invalid target platform selected");
success = false;
break;
}
// Oculus Application ID check and command.
ValidateTextField(&SOculusPlatformToolWidget::IDFieldValidator, PlatformSettings->GetApplicationID(),
LOCTEXT("ApplicationID", "Application ID").ToString(), success);
args += " --app_id \"" + PlatformSettings->GetApplicationID() + "\"";
// Oculus Application Token check and command.
ValidateTextField(&SOculusPlatformToolWidget::GenericFieldValidator, PlatformSettings->GetApplicationToken(),
LOCTEXT("ApplicationToken", "Application Token").ToString(), success);
args += " --app_secret \"" + PlatformSettings->GetApplicationToken() + "\"";
// Release Channel check and command.
ValidateTextField(&SOculusPlatformToolWidget::GenericFieldValidator, PlatformSettings->GetReleaseChannel(),
LOCTEXT("ReleaseChannel", "Release Channel").ToString(), success);
args += " --channel \"" + PlatformSettings->GetReleaseChannel() + "\"";
// Release Note check and command. Not a required command.
if (!PlatformSettings->GetReleaseNote().IsEmpty())
{
FString SanatizedReleaseNote = PlatformSettings->GetReleaseNote();
SanatizedReleaseNote = SanatizedReleaseNote.Replace(TEXT("\""), TEXT("\"\""));
args += " --notes \"" + SanatizedReleaseNote + "\"";
}
// Platform specific commands
if (PlatformSettings->GetTargetPlatform() == (uint8)EOculusXRPlatformTarget::Rift)
{
// Launch File Path check and command.
ValidateTextField(&SOculusPlatformToolWidget::FileFieldValidator, PlatformSettings->GetLaunchFilePath(),
LOCTEXT("LaunchFile", "Launch File Path").ToString(), success);
args += " --launch-file \"" + PlatformSettings->GetLaunchFilePath() + "\"";
// Rift Build Directory check and command.
ValidateTextField(&SOculusPlatformToolWidget::DirectoryFieldValidator, PlatformSettings->OculusRiftBuildDirectory,
LOCTEXT("RiftBuildDir", "Rift Build Directory").ToString(), success);
args += " --build_dir \"" + PlatformSettings->OculusRiftBuildDirectory + "\"";
// Rift Build Version check and command.
ValidateTextField(&SOculusPlatformToolWidget::GenericFieldValidator, PlatformSettings->OculusRiftBuildVersion,
LOCTEXT("BuildVersion", "Build Version").ToString(), success);
args += " --version \"" + PlatformSettings->OculusRiftBuildVersion + "\"";
// Rift Launch Parameters check and command
if (!PlatformSettings->OculusRiftLaunchParams.IsEmpty())
{
ValidateTextField(&SOculusPlatformToolWidget::LaunchParamValidator, PlatformSettings->OculusRiftLaunchParams,
LOCTEXT("LaunchParam", "Launch Parameters").ToString(), success);
args += " --launch_params \"" + PlatformSettings->OculusRiftLaunchParams + "\"";
}
// Rift 2D Options checks and commands
if (!PlatformSettings->OculusRift2DLaunchPath.IsEmpty())
{
ValidateTextField(&SOculusPlatformToolWidget::FileFieldValidator, PlatformSettings->OculusRift2DLaunchPath,
LOCTEXT("2DLaunchFile", "2D Launch File Path").ToString(), success);
args += " --launch_file_2d \"" + PlatformSettings->OculusRift2DLaunchPath + "\"";
if (!PlatformSettings->OculusRift2DLaunchParams.IsEmpty())
{
ValidateTextField(&SOculusPlatformToolWidget::LaunchParamValidator, PlatformSettings->OculusRift2DLaunchParams,
LOCTEXT("2DLaunchParams", "2D Launch Parameters").ToString(), success);
args += " --launch_params_2d \"" + PlatformSettings->OculusRift2DLaunchParams + "\"";
}
}
// Rift Firewall Exception command
if (PlatformSettings->OculusRiftFireWallException)
{
args += " --firewall_exceptions true";
}
// Rift Gamepad Emulation command
if (PlatformSettings->GetRiftGamepadEmulation() > EOculusXRGamepadEmulation::Off && PlatformSettings->GetRiftGamepadEmulation() < EOculusXRGamepadEmulation::Length)
{
args += " --gamepad-emulation ";
switch (PlatformSettings->GetRiftGamepadEmulation())
{
case EOculusXRGamepadEmulation::Twinstick:
args += "TWINSTICK";
break;
case EOculusXRGamepadEmulation::RightDPad:
args += "RIGHT_D_PAD";
break;
case EOculusXRGamepadEmulation::LeftDPad:
args += "LEFT_D_PAD";
break;
default:
args += "OFF";
break;
}
}
// Rift Redistributable Packages commands
TArray<FString> IncludedPackages;
for (int i = 0; i < PlatformSettings->OculusRedistPackages.Num(); i++)
{
FOculusXRRedistPackage Package = PlatformSettings->OculusRedistPackages[i];
if (Package.Included)
{
IncludedPackages.Add(Package.Id);
}
}
if (IncludedPackages.Num() > 0)
{
args += " --redistributables \"" + FString::Join(IncludedPackages, TEXT(",")) + "\"";
}
}
else
{
// APK File Path check and command.
ValidateTextField(&SOculusPlatformToolWidget::FileFieldValidator, PlatformSettings->GetLaunchFilePath(),
LOCTEXT("APKLaunchFile", "APK File Path").ToString(), success);
args += " --apk \"" + PlatformSettings->GetLaunchFilePath() + "\"";
if (PlatformSettings->UploadDebugSymbols)
{
ValidateTextField(&SOculusPlatformToolWidget::DirectoryFieldValidator, PlatformSettings->GetSymbolDirPath(),
LOCTEXT("SymbolDirPath", "Symbol Directory Path").ToString(), success);
if (success)
{
args += " --debug-symbols-dir \"" + PlatformSettings->GetSymbolDirPath() + "\"";
}
}
}
if (!PlatformSettings->GetExpansionFilesPath().IsEmpty())
{
ValidateTextField(&SOculusPlatformToolWidget::DirectoryFieldValidator, PlatformSettings->GetExpansionFilesPath(),
LOCTEXT("ExpansionFilesPath", "Expansion Files Path").ToString(), success);
args += " --assets-dir \"" + PlatformSettings->GetExpansionFilesPath() + "\"";
TArray<FOculusXRAssetConfig>* AssetConfigs = PlatformSettings->GetAssetConfigs();
if (AssetConfigs->Num() > 0)
{
TArray<FString> AssetConfig;
for (int i = 0; i < AssetConfigs->Num(); i++)
{
TArray<FString> ConfigParams;
FOculusXRAssetConfig Config = (*AssetConfigs)[i];
if (Config.Required)
{
ConfigParams.Add("\\\"required\\\":true");
}
if (Config.AssetType > EOculusXRAssetType::Default && Config.AssetType < EOculusXRAssetType::Length)
{
FString command = "\\\"type\\\":";
switch (Config.AssetType)
{
case EOculusXRAssetType::Store:
ConfigParams.Add(command + "\\\"STORE\\\"");
break;
case EOculusXRAssetType::Language_Pack:
ConfigParams.Add(command + "\\\"LANGUAGE_PACK\\\"");
break;
default:
ConfigParams.Add(command + "\\\"DEFAULT\\\"");
break;
}
}
if (!Config.Sku.IsEmpty())
{
ConfigParams.Add("\\\"sku\\\":\\\"" + Config.Sku + "\\\"");
}
if (ConfigParams.Num() > 0)
{
FString ConfigCommand = "\\\"" + Config.Name + "\\\":{" + FString::Join(ConfigParams, TEXT(",")) + "}";
AssetConfig.Add(ConfigCommand);
}
}
if (AssetConfig.Num())
{
args += " --asset_files_config {" + FString::Join(AssetConfig, TEXT(",")) + "}";
}
}
}
args += " --upload-from-engine UNREAL";
UE_LOG(LogTemp, Warning, TEXT("%s"), *args);
return success;
}
bool SOculusPlatformToolWidget::ConstructDebugSymbolArguments(FString& args)
{
bool success = true;
args = "upload-debug-symbols";
ValidateTextField(&SOculusPlatformToolWidget::IDFieldValidator, PlatformSettings->BuildID,
LOCTEXT("BuildID", "Build ID").ToString(), success);
args += " --parent \"" + PlatformSettings->BuildID + "\"";
// Oculus Application ID check and command.
ValidateTextField(&SOculusPlatformToolWidget::IDFieldValidator, PlatformSettings->GetApplicationID(),
LOCTEXT("ApplicationID", "Application ID").ToString(), success);
args += " --app_id \"" + PlatformSettings->GetApplicationID() + "\"";
// Oculus Application Token check and command.
ValidateTextField(&SOculusPlatformToolWidget::GenericFieldValidator, PlatformSettings->GetApplicationToken(),
LOCTEXT("ApplicationToken", "Application Token").ToString(), success);
args += " --app_secret \"" + PlatformSettings->GetApplicationToken() + "\"";
ValidateTextField(&SOculusPlatformToolWidget::DirectoryFieldValidator, PlatformSettings->GetSymbolDirPath(),
LOCTEXT("SymbolDirPath", "Symbol Directory Path").ToString(), success);
args += " --debug-symbols-dir \"" + PlatformSettings->GetSymbolDirPath() + "\"";
args += " --debug-symbols-pattern \"*.so\"";
return success;
}
void SOculusPlatformToolWidget::EnableUploadButton(bool enabled)
{
RequestUploadButtonActive = enabled;
}
void SOculusPlatformToolWidget::LoadConfigSettings()
{
PlatformSettings = GetMutableDefault<UOculusXRPlatformToolSettings>();
PlatformEnum = StaticEnum<EOculusXRPlatformTarget>();
GamepadEmulationEnum = StaticEnum<EOculusXRGamepadEmulation>();
AssetTypeEnum = StaticEnum<EOculusXRAssetType>();
RiftGamepadEmulation.Empty();
OculusPlatforms.Empty();
for (uint8 i = 0; i < (uint8)EOculusXRPlatformTarget::Length; i++)
{
OculusPlatforms.Add(MakeShareable(new FString(PlatformEnum->GetDisplayNameTextByIndex((int64)i).ToString())));
}
for (uint8 i = 0; i < (uint8)EOculusXRGamepadEmulation::Length; i++)
{
RiftGamepadEmulation.Add(MakeShareable(new FString(GamepadEmulationEnum->GetDisplayNameTextByIndex((int64)i).ToString())));
}
for (uint8 i = 0; i < (uint8)EOculusXRAssetType::Length; i++)
{
AssetType.Add(MakeShareable(new FString(AssetTypeEnum->GetDisplayNameTextByIndex((int64)i).ToString())));
}
LoadRedistPackages();
}
void SOculusPlatformToolWidget::LoadRedistPackages()
{
(new FAsyncTask<FPlatformLoadRedistPackagesTask>(UpdateLogTextDel))->StartBackgroundTask();
}
FReply SOculusPlatformToolWidget::OnStartPlatformUpload()
{
FString launchArgs;
UpdateLogText("");
FOculusXRHMDModule::GetPluginWrapper().SendEvent2("oculus_platform_tool", "upload", "integration");
if (ConstructArguments(launchArgs))
{
UpdateLogText(LogText + LOCTEXT("StartUpload", "Starting Platform Tool Upload Process . . .\n").ToString());
(new FAsyncTask<FPlatformUploadTask>(launchArgs, EnableUploadButtonDel, UpdateLogTextDel, SetProcessDel))->StartBackgroundTask();
}
return FReply::Handled();
}
void SOculusPlatformToolWidget::OnPlatformSettingChanged(TSharedPtr<FString> ItemSelected, ESelectInfo::Type SelectInfo)
{
if (!ItemSelected.IsValid())
{
return;
}
for (uint8 i = 0; i < (uint8)EOculusXRPlatformTarget::Length; i++)
{
if (PlatformEnum->GetDisplayNameTextByIndex(i).EqualTo(FText::FromString(*ItemSelected)))
{
if (PlatformSettings != nullptr)
{
PlatformSettings->SetTargetPlatform(i);
PlatformSettings->SaveConfig();
LoadConfigSettings();
BuildGeneralSettingsBox(GeneralSettingsBox);
BuildExpansionFileBox(ExpansionFilesSettings);
OptionalSettings.Get()->ClearChildren();
if (i == (uint8)EOculusXRPlatformTarget::Rift)
{
BuildRiftOptionalFields(OptionalSettings);
}
break;
}
}
}
}
void SOculusPlatformToolWidget::OnApplicationIDChanged(const FText& InText, ETextCommit::Type InCommitType)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->SetApplicationID(InText.ToString());
PlatformSettings->SaveConfig();
}
}
void SOculusPlatformToolWidget::OnApplicationTokenChanged(const FText& InText, ETextCommit::Type InCommitType)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->SetApplicationToken(InText.ToString());
PlatformSettings->SaveConfig();
}
}
void SOculusPlatformToolWidget::OnReleaseChannelChanged(const FText& InText, ETextCommit::Type InCommitType)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->SetReleaseChannel(InText.ToString());
PlatformSettings->SaveConfig();
}
}
void SOculusPlatformToolWidget::OnReleaseNoteChanged(const FText& InText, ETextCommit::Type InCommitType)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->SetReleaseNote(InText.ToString());
PlatformSettings->SaveConfig();
}
}
void SOculusPlatformToolWidget::OnRiftBuildVersionChanged(const FText& InText, ETextCommit::Type InCommitType)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->OculusRiftBuildVersion = InText.ToString();
PlatformSettings->SaveConfig();
}
}
void SOculusPlatformToolWidget::OnRiftLaunchParamsChanged(const FText& InText, ETextCommit::Type InCommitType)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->OculusRiftLaunchParams = InText.ToString();
PlatformSettings->SaveConfig();
}
}
void SOculusPlatformToolWidget::On2DLaunchParamsChanged(const FText& InText, ETextCommit::Type InCommitType)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->OculusRift2DLaunchParams = InText.ToString();
PlatformSettings->SaveConfig();
}
}
void SOculusPlatformToolWidget::OnRiftFirewallChanged(ECheckBoxState CheckState)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->OculusRiftFireWallException = CheckState == ECheckBoxState::Checked ? true : false;
PlatformSettings->SaveConfig();
}
}
void SOculusPlatformToolWidget::OnRedistPackageStateChanged(ECheckBoxState CheckState, FOculusXRRedistPackage* Package)
{
if (PlatformSettings != nullptr)
{
Package->Included = CheckState == ECheckBoxState::Checked;
PlatformSettings->SaveConfig();
BuildRiftOptionalFields(OptionalSettings);
}
}
void SOculusPlatformToolWidget::OnAssetConfigTypeChanged(TSharedPtr<FString> ItemSelected, ESelectInfo::Type SelectInfo, int i)
{
if (PlatformSettings != nullptr)
{
TArray<FOculusXRAssetConfig>* AssetConfigs = PlatformSettings->GetAssetConfigs();
for (int e = 0; e < (uint8)EOculusXRAssetType::Length; e++)
{
if (AssetTypeEnum->GetDisplayNameTextByIndex(e).ToString().Equals(*ItemSelected.Get()))
{
(*AssetConfigs)[i].AssetType = (EOculusXRAssetType)e;
break;
}
}
PlatformSettings->SaveConfig();
BuildExpansionFileBox(ExpansionFilesSettings);
}
}
void SOculusPlatformToolWidget::OnAssetConfigRequiredChanged(ECheckBoxState CheckState, int i)
{
if (PlatformSettings != nullptr)
{
TArray<FOculusXRAssetConfig>* AssetConfigs = PlatformSettings->GetAssetConfigs();
(*AssetConfigs)[i].Required = CheckState == ECheckBoxState::Checked;
PlatformSettings->SaveConfig();
BuildExpansionFileBox(ExpansionFilesSettings);
}
}
void SOculusPlatformToolWidget::OnAssetConfigSKUChanged(const FText& InText, ETextCommit::Type InCommitType, int i)
{
if (PlatformSettings != nullptr)
{
TArray<FOculusXRAssetConfig>* AssetConfigs = PlatformSettings->GetAssetConfigs();
(*AssetConfigs)[i].Sku = InText.ToString();
PlatformSettings->SaveConfig();
BuildExpansionFileBox(ExpansionFilesSettings);
}
}
void SOculusPlatformToolWidget::OnUploadDebugSymbolsChanged(ECheckBoxState CheckState)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->UploadDebugSymbols = CheckState == ECheckBoxState::Checked ? true : false;
PlatformSettings->SaveConfig();
BuildGeneralSettingsBox(GeneralSettingsBox);
}
}
void SOculusPlatformToolWidget::OnDebugSymbolsOnlyChanged(ECheckBoxState CheckState)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->DebugSymbolsOnly = CheckState == ECheckBoxState::Checked ? true : false;
PlatformSettings->SaveConfig();
BuildGeneralSettingsBox(GeneralSettingsBox);
}
}
void SOculusPlatformToolWidget::OnBuildIDChanged(const FText& InText, ETextCommit::Type InCommitType)
{
if (PlatformSettings != nullptr)
{
PlatformSettings->BuildID = InText.ToString();
PlatformSettings->SaveConfig();
}
}
void SOculusPlatformToolWidget::OnRiftGamepadEmulationChanged(TSharedPtr<FString> ItemSelected, ESelectInfo::Type SelectInfo)
{
if (!ItemSelected.IsValid())
{
return;
}
for (uint8 i = 0; i < (uint8)EOculusXRGamepadEmulation::Length; i++)
{
if (GamepadEmulationEnum->GetDisplayNameTextByIndex(i).EqualTo(FText::FromString(*ItemSelected)))
{
if (PlatformSettings != nullptr)
{
PlatformSettings->SetRiftGamepadEmulation(i);
PlatformSettings->SaveConfig();
break;
}
}
}
}
FReply SOculusPlatformToolWidget::OnSelectRiftBuildDirectory()
{
TSharedPtr<SWindow> parentWindow = FSlateApplication::Get().FindWidgetWindow(AsShared());
const void* parentWindowHandle = (parentWindow.IsValid() && parentWindow->GetNativeWindow().IsValid()) ? parentWindow->GetNativeWindow()->GetOSWindowHandle() : nullptr;
if (PlatformSettings != nullptr)
{
FString path;
FString defaultPath = PlatformSettings->OculusRiftBuildDirectory.IsEmpty() ? FPaths::ProjectContentDir() : PlatformSettings->OculusRiftBuildDirectory;
if (FDesktopPlatformModule::Get()->OpenDirectoryDialog(parentWindowHandle, "Choose Rift Build Directory", defaultPath, path))
{
PlatformSettings->OculusRiftBuildDirectory = path;
PlatformSettings->SaveConfig();
BuildGeneralSettingsBox(GeneralSettingsBox);
}
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnClearRiftBuildDirectory()
{
if (PlatformSettings != nullptr)
{
PlatformSettings->OculusRiftBuildDirectory.Empty();
PlatformSettings->SaveConfig();
BuildGeneralSettingsBox(GeneralSettingsBox);
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnSelectLaunchFilePath()
{
TSharedPtr<SWindow> parentWindow = FSlateApplication::Get().FindWidgetWindow(AsShared());
const void* parentWindowHandle = (parentWindow.IsValid() && parentWindow->GetNativeWindow().IsValid()) ? parentWindow->GetNativeWindow()->GetOSWindowHandle() : nullptr;
if (PlatformSettings != nullptr)
{
TArray<FString> path;
FString defaultPath = PlatformSettings->GetLaunchFilePath().IsEmpty() ? FPaths::ProjectContentDir() : PlatformSettings->GetLaunchFilePath();
FString fileType = PlatformSettings->GetTargetPlatform() == (uint8)EOculusXRPlatformTarget::Rift ? "Executables (*.exe)|*.exe" : "APKs (*.apk)|*.apk";
if (FDesktopPlatformModule::Get()->OpenFileDialog(parentWindowHandle, "Choose Launch File", defaultPath, defaultPath, fileType, EFileDialogFlags::None, path))
{
if (path.Num() > 0)
{
PlatformSettings->SetLaunchFilePath(FPaths::ConvertRelativePathToFull(path[0]));
}
PlatformSettings->SaveConfig();
BuildGeneralSettingsBox(GeneralSettingsBox);
}
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnClearLaunchFilePath()
{
if (PlatformSettings != nullptr)
{
PlatformSettings->SetLaunchFilePath("");
PlatformSettings->SaveConfig();
BuildGeneralSettingsBox(GeneralSettingsBox);
}
return FReply::Handled();
}
FString SOculusPlatformToolWidget::GenerateSymbolPath()
{
return FPaths::ProjectDir() + TEXT("Binaries/Android/") + FApp::GetProjectName() + TEXT("_Symbols_v1/") + FApp::GetProjectName() + TEXT("-arm64");
}
FReply SOculusPlatformToolWidget::OnSelectSymbolDirPath()
{
TSharedPtr<SWindow> parentWindow = FSlateApplication::Get().FindWidgetWindow(AsShared());
const void* parentWindowHandle = (parentWindow.IsValid() && parentWindow->GetNativeWindow().IsValid()) ? parentWindow->GetNativeWindow()->GetOSWindowHandle() : nullptr;
if (PlatformSettings != nullptr)
{
FString dirPath;
FString defaultPath = PlatformSettings->GetSymbolDirPath().IsEmpty() ? GenerateSymbolPath() : PlatformSettings->GetSymbolDirPath();
if (FDesktopPlatformModule::Get()->OpenDirectoryDialog(parentWindowHandle, "Choose Launch File", defaultPath, dirPath))
{
PlatformSettings->SetSymbolDirPath(FPaths::ConvertRelativePathToFull(dirPath));
PlatformSettings->SaveConfig();
BuildGeneralSettingsBox(GeneralSettingsBox);
}
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnClearSymbolDirPath()
{
if (PlatformSettings != nullptr)
{
PlatformSettings->SetSymbolDirPath("");
PlatformSettings->SaveConfig();
BuildGeneralSettingsBox(GeneralSettingsBox);
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnSelect2DLaunchPath()
{
if (PlatformSettings != nullptr)
{
TSharedPtr<SWindow> parentWindow = FSlateApplication::Get().FindWidgetWindow(AsShared());
const void* parentWindowHandle = (parentWindow.IsValid() && parentWindow->GetNativeWindow().IsValid()) ? parentWindow->GetNativeWindow()->GetOSWindowHandle() : nullptr;
TArray<FString> path;
FString defaultPath = PlatformSettings->OculusRift2DLaunchPath.IsEmpty() ? FPaths::ProjectContentDir() : PlatformSettings->OculusRift2DLaunchPath;
if (FDesktopPlatformModule::Get()->OpenFileDialog(parentWindowHandle, "Choose 2D Launch File", defaultPath, defaultPath, "Executables (*.exe)|*.exe", EFileDialogFlags::None, path))
{
if (path.Num() > 0)
{
PlatformSettings->OculusRift2DLaunchPath = FPaths::ConvertRelativePathToFull(path[0]);
}
PlatformSettings->SaveConfig();
BuildRiftOptionalFields(OptionalSettings);
}
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnClear2DLaunchPath()
{
if (PlatformSettings != nullptr)
{
PlatformSettings->OculusRift2DLaunchPath.Empty();
PlatformSettings->SaveConfig();
BuildRiftOptionalFields(OptionalSettings);
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnCancelUpload()
{
if (FMessageDialog::Open(EAppMsgType::OkCancel, LOCTEXT("CancelUploadWarning", "Are you sure you want to cancel the upload process?")) == EAppReturnType::Ok)
{
if (PlatformProcess.IsValid())
{
FPlatformProcess::TerminateProc(PlatformProcess);
UpdateLogText(LogText + LOCTEXT("UploadCancel", "Upload process was canceled.").ToString());
}
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnSelectLanguagePacksPath()
{
if (PlatformSettings != nullptr)
{
TSharedPtr<SWindow> parentWindow = FSlateApplication::Get().FindWidgetWindow(AsShared());
const void* parentWindowHandle = (parentWindow.IsValid() && parentWindow->GetNativeWindow().IsValid()) ? parentWindow->GetNativeWindow()->GetOSWindowHandle() : nullptr;
FString path;
FString defaultPath = PlatformSettings->GetLanguagePacksPath().IsEmpty() ? FPaths::ProjectContentDir() : PlatformSettings->GetLanguagePacksPath();
if (FDesktopPlatformModule::Get()->OpenDirectoryDialog(parentWindowHandle, "Choose Language Packs Directory", defaultPath, path))
{
PlatformSettings->SetLanguagePacksPath(path);
PlatformSettings->SaveConfig();
BuildExpansionFileBox(ExpansionFilesSettings);
}
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnClearLanguagePacksPath()
{
if (PlatformSettings != nullptr)
{
PlatformSettings->SetLanguagePacksPath("");
PlatformSettings->SaveConfig();
BuildExpansionFileBox(ExpansionFilesSettings);
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnSelectExpansionFilesPath()
{
if (PlatformSettings != nullptr)
{
TSharedPtr<SWindow> parentWindow = FSlateApplication::Get().FindWidgetWindow(AsShared());
const void* parentWindowHandle = (parentWindow.IsValid() && parentWindow->GetNativeWindow().IsValid()) ? parentWindow->GetNativeWindow()->GetOSWindowHandle() : nullptr;
FString path;
FString defaultPath = PlatformSettings->GetExpansionFilesPath().IsEmpty() ? FPaths::ProjectContentDir() : PlatformSettings->GetExpansionFilesPath();
if (FDesktopPlatformModule::Get()->OpenDirectoryDialog(parentWindowHandle, "Choose Expansion Files Directory", defaultPath, path))
{
if (!path.Equals(PlatformSettings->GetExpansionFilesPath()))
{
if (!path.IsEmpty() && FPaths::DirectoryExists(path))
{
TArray<FString> Files;
//FFileManagerGeneric::Get().FindFilesRecursive(Files, *path, TEXT("*.*"), true, false, false);
IFileManager::Get().FindFiles(Files, *path);
TArray<FOculusXRAssetConfig>* AssetConfigs = PlatformSettings->GetAssetConfigs();
for (int i = 0; i < Files.Num(); i++)
{
FOculusXRAssetConfig AssetConfig;
AssetConfig.Name = Files[i];
AssetConfigs->Push(AssetConfig);
}
PlatformSettings->SetExpansionFilesPath(path);
PlatformSettings->SaveConfig();
BuildExpansionFileBox(ExpansionFilesSettings);
}
}
}
}
return FReply::Handled();
}
FReply SOculusPlatformToolWidget::OnClearExpansionFilesPath()
{
if (PlatformSettings != nullptr)
{
PlatformSettings->SetExpansionFilesPath("");
PlatformSettings->GetAssetConfigs()->Empty();
PlatformSettings->SaveConfig();
BuildExpansionFileBox(ExpansionFilesSettings);
}
return FReply::Handled();
}
void SOculusPlatformToolWidget::ValidateTextField(PFieldValidatorDel del, FString text, FString name, bool& success)
{
FString error = "";
FFieldValidatorDel fieldValidator;
// Check the given field with the given field validator and print the error if it fails.
fieldValidator.BindSP(this, del);
if (!fieldValidator.Execute(text, error))
{
FString errorMessage = LOCTEXT("Error", "ERROR: Please verify that the {0} is correct. ").ToString();
errorMessage = FString::Format(*errorMessage, { name });
UpdateLogText(LogText + errorMessage + (error.IsEmpty() ? "\n" : error + "\n"));
success = false;
}
}
bool SOculusPlatformToolWidget::GenericFieldValidator(FString text, FString& error)
{
if (text.IsEmpty())
{
error = LOCTEXT("FieldEmpty", "The field is empty.").ToString();
return false;
}
return true;
}
bool SOculusPlatformToolWidget::IDFieldValidator(FString text, FString& error)
{
const FRegexPattern RegExPat(TEXT("^[0-9]+$"));
FRegexMatcher RegMatcher(RegExPat, text);
if (!GenericFieldValidator(text, error))
{
return false;
}
else if (!RegMatcher.FindNext())
{
error = LOCTEXT("InvalidChar", "The field contains invalid characters.").ToString();
return false;
}
return true;
}
bool SOculusPlatformToolWidget::DirectoryFieldValidator(FString text, FString& error)
{
if (!GenericFieldValidator(text, error))
{
return false;
}
if (!FPaths::DirectoryExists(text))
{
error = LOCTEXT("DirectoryNull", "The directory does not exist.").ToString();
return false;
}
return true;
}
bool SOculusPlatformToolWidget::FileFieldValidator(FString text, FString& error)
{
if (!GenericFieldValidator(text, error))
{
return false;
}
if (!FPaths::FileExists(text))
{
error = LOCTEXT("FileNull", "The file does not exist.").ToString();
return false;
}
return true;
}
bool SOculusPlatformToolWidget::LaunchParamValidator(FString text, FString& error)
{
if (text.Contains("\""))
{
error = LOCTEXT("LaunchParamError", "The field contains illegal characters.").ToString();
return false;
}
return true;
}
void SOculusPlatformToolWidget::On2DOptionsExpanded(bool bExpanded)
{
Options2DCollapsed = !bExpanded;
}
void SOculusPlatformToolWidget::OnRedistPackagesExpanded(bool bExpanded)
{
OptionsRedistPackagesCollapsed = !bExpanded;
}
void SOculusPlatformToolWidget::UpdateLogText(FString text)
{
// Make sure that log text updating happens on the right thread.
LogText = text;
LogTextUpdated = true;
}
void SOculusPlatformToolWidget::SetPlatformProcess(FProcHandle proc)
{
PlatformProcess = proc;
}
//=======================================================================================
//FPlatformDownloadTask
FPlatformDownloadTask::FPlatformDownloadTask(FUpdateLogTextDel textDel, FEvent* saveEvent)
{
UpdateLogText = textDel;
SaveCompleteEvent = saveEvent;
FOculusXRHMDModule::GetPluginWrapper().SendEvent2("oculus_platform_tool", "provision_util", "integration");
}
void FPlatformDownloadTask::DoWork()
{
// Create HTTP request for downloading oculus platform tool
downloadCompleteEvent = FGenericPlatformProcess::GetSynchEventFromPool(false);
TSharedRef<IHttpRequest, ESPMode::ThreadSafe> httpRequest = FHttpModule::Get().CreateRequest();
httpRequest->OnProcessRequestComplete().BindRaw(this, &FPlatformDownloadTask::OnDownloadRequestComplete);
httpRequest->OnRequestProgress().BindRaw(this, &FPlatformDownloadTask::OnRequestDownloadProgress);
httpRequest->SetURL(UrlPlatformUtil);
httpRequest->SetVerb("GET");
httpRequest->ProcessRequest();
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + LOCTEXT("DownloadProgress", "Downloading Platform Tool: {0}%\n").ToString());
ToolConsoleLog = SOculusPlatformToolWidget::LogText;
UpdateProgressLog(0);
// Wait for download to complete
downloadCompleteEvent->Wait();
// Save HTTP data
FString fullPath = FPaths::ConvertRelativePathToFull(FPaths::ProjectContentDir()) + ProjectPlatformUtilPath;
if (FFileHelper::SaveArrayToFile(httpData, *fullPath))
{
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + LOCTEXT("DownloadSuccess", "Platform tool successfully downloaded.\n").ToString());
}
else
{
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + LOCTEXT("DownloadError", "An error has occured with downloading the platform tool.\n").ToString());
}
if (SaveCompleteEvent != nullptr)
{
SaveCompleteEvent->Trigger();
}
}
void FPlatformDownloadTask::UpdateProgressLog(int progress)
{
UpdateLogText.Execute(FString::Format(*ToolConsoleLog, { progress }));
}
void FPlatformDownloadTask::OnRequestDownloadProgress(FHttpRequestPtr HttpRequest, int32 BytesSend, int32 InBytesReceived)
{
// Update progress on download in tool console log
FHttpResponsePtr httpResponse = HttpRequest->GetResponse();
if (httpResponse.IsValid())
{
int progress = ((float)InBytesReceived / (float)httpResponse->GetContentLength()) * 100;
UpdateProgressLog(progress);
}
}
void FPlatformDownloadTask::OnDownloadRequestComplete(FHttpRequestPtr HttpRequest, FHttpResponsePtr HttpResponse, bool bSucceeded)
{
// Extract data from HTTP response and trigger download complete event
if (bSucceeded && HttpResponse.IsValid())
{
httpData = HttpResponse->GetContent();
downloadCompleteEvent->Trigger();
}
}
//=======================================================================================
//FPlatformUploadTask
FPlatformUploadTask::FPlatformUploadTask(FString args, FEnableUploadButtonDel del, FUpdateLogTextDel textDel, FSetProcessDel procDel)
{
LaunchArgs = args;
EnableUploadButton = del;
UpdateLogText = textDel;
SetProcess = procDel;
EnableUploadButton.Execute(false);
}
void FPlatformUploadTask::DoWork()
{
// Check if the platform tool exists in the project directory. If not, start process to download it.
if (!FPaths::FileExists(FPaths::ProjectContentDir() + ProjectPlatformUtilPath))
{
FEvent* PlatformToolCreatedEvent = FGenericPlatformProcess::GetSynchEventFromPool(false);
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + LOCTEXT("NoCLI", "Unable to find Oculus Platform Utility.\n").ToString());
#if UE_VERSION_OLDER_THAN(5, 3, 0)
EAppReturnType::Type dialogChoice = FMessageDialog::Open(EAppMsgType::OkCancel, OculusPlatformDialogMessage, &OculusPlatformDialogTitle);
#else
EAppReturnType::Type dialogChoice = FMessageDialog::Open(EAppMsgType::OkCancel, OculusPlatformDialogMessage, OculusPlatformDialogTitle);
#endif
if (dialogChoice == EAppReturnType::Ok)
{
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + LOCTEXT("DownloadCLI", "Downloading Oculus Platform Utility . . .\n").ToString());
(new FAsyncTask<FPlatformDownloadTask>(UpdateLogText, PlatformToolCreatedEvent))->StartBackgroundTask();
PlatformToolCreatedEvent->Wait();
}
else
{
return;
}
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + LOCTEXT("StartUploadAfterDownload", "Starting upload . . .\n").ToString());
}
// Start up the CLI and pass in arguments.
FPlatformProcess::CreatePipe(ReadPipe, WritePipe);
FProcHandle PlatformProcess = FPlatformProcess::CreateProc(*(FPaths::ProjectContentDir() + ProjectPlatformUtilPath), *LaunchArgs, false, true, true, nullptr, 0, nullptr, WritePipe, ReadPipe);
SetProcess.Execute(PlatformProcess);
// Redirect CLI output to the tool's log.
while (FPlatformProcess::IsProcRunning(PlatformProcess))
{
FString log = FPlatformProcess::ReadPipe(ReadPipe);
if (!log.IsEmpty())
{
// Remove parts of the log that contain escape character codes
int32 escapeIndex = log.Find("\u001b");
while (escapeIndex >= 0)
{
int32 lineEndIndex = log.Find("\n", ESearchCase::IgnoreCase, ESearchDir::FromStart, escapeIndex);
if (lineEndIndex < 0) // If an escape character code exists without a new line end, just remove the escape character
{
lineEndIndex = escapeIndex + 1;
}
log.RemoveAt(escapeIndex, lineEndIndex - escapeIndex);
escapeIndex = log.Find("\u001b");
}
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + log);
}
}
EnableUploadButton.Execute(true);
}
//=======================================================================================
//FPlatformLoadRedistPackagesTask
FPlatformLoadRedistPackagesTask::FPlatformLoadRedistPackagesTask(FUpdateLogTextDel textDel)
{
UpdateLogText = textDel;
}
void FPlatformLoadRedistPackagesTask::DoWork()
{
UOculusXRPlatformToolSettings* PlatformSettings = GetMutableDefault<UOculusXRPlatformToolSettings>();
// Check to see if the CLI exists, we need this to load avalible redist packages
if (!FPaths::FileExists(FPaths::ProjectContentDir() + ProjectPlatformUtilPath))
{
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + LOCTEXT("LoadRedist", "Loading redistributable packages . . .\n").ToString());
FEvent* PlatformToolCreatedEvent = FGenericPlatformProcess::GetSynchEventFromPool(false);
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + LOCTEXT("NoCLI", "Unable to find Oculus Platform Utility.\n").ToString());
#if UE_VERSION_OLDER_THAN(5, 3, 0)
EAppReturnType::Type dialogChoice = FMessageDialog::Open(EAppMsgType::OkCancel, OculusPlatformDialogMessage, &OculusPlatformDialogTitle);
#else
EAppReturnType::Type dialogChoice = FMessageDialog::Open(EAppMsgType::OkCancel, OculusPlatformDialogMessage, OculusPlatformDialogTitle);
#endif
if (dialogChoice == EAppReturnType::Ok)
{
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + LOCTEXT("DownloadCLI", "Downloading Oculus Platform Utility . . .\n").ToString());
(new FAsyncTask<FPlatformDownloadTask>(UpdateLogText, PlatformToolCreatedEvent))->StartBackgroundTask();
PlatformToolCreatedEvent->Wait();
}
else
{
return;
}
}
// Launch CLI and pass command to list out redist packages currently avalible
TArray<FOculusXRRedistPackage> LoadedPackages;
FString Args = "list-redists";
FPlatformProcess::CreatePipe(ReadPipe, WritePipe);
FProcHandle PlatformProcess = FPlatformProcess::CreateProc(*(FPaths::ProjectContentDir() + ProjectPlatformUtilPath), *Args, false, true, true, nullptr, 0, nullptr, WritePipe, ReadPipe);
// Load redist packages
while (FPlatformProcess::IsProcRunning(PlatformProcess))
{
FString log = FPlatformProcess::ReadPipe(ReadPipe);
if (!log.IsEmpty() && !log.Contains("\u001b") && !log.Contains("ID"))
{
TArray<FString> Packages;
log.ParseIntoArrayLines(Packages);
if (Packages.Num() > 0)
{
for (int i = 0; i < Packages.Num(); i++)
{
FString id, name;
Packages[i].Split("|", &id, &name);
if (!id.IsEmpty() && !name.IsEmpty())
{
FOculusXRRedistPackage newPackage;
newPackage.Name = name;
newPackage.Id = id;
LoadedPackages.Add(newPackage);
}
}
}
}
}
// Check to see if our stored copy of redist packages is outdated
if (PlatformSettings != nullptr)
{
if (LoadedPackages.Num() > PlatformSettings->OculusRedistPackages.Num())
{
PlatformSettings->OculusRedistPackages = LoadedPackages;
PlatformSettings->SaveConfig();
UpdateLogText.Execute(SOculusPlatformToolWidget::LogText + LOCTEXT("FinishRedistLoad", "Finished updating redistributable packages.\n").ToString());
}
}
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink