ConnectionType

ConnectionType

#Overview

name: ConnectionType

The value of this variable can be defined or overridden in .ini config files. 1 .ini config file referencing this setting variable.

It is referenced in 37 C++ source files. Also referenced in 1 C# build file meaning it may affect the build system logic.

#Summary

#Usage in the C++ source code

The purpose of ConnectionType is to represent different types of connections or interfaces in various Unreal Engine subsystems and modules. It is used in different contexts throughout the engine, including:

  1. Network connectivity: To represent different types of network connections (e.g., WiFi, WiMAX, None) in the Android platform code.

  2. Material graph connections: To define the type of connection between nodes in the material editor graph.

  3. Device connections: To specify the type of connection for target devices in the device services system.

  4. Online subsystem: To represent the connection status in the Common User subsystem.

  5. Data flow and geometry processing: To define connection types in geometry scripting and data flow systems.

The ConnectionType variable is used in various Unreal Engine subsystems, plugins, and modules, including:

The value of ConnectionType is typically set based on the context in which it’s used. For example:

ConnectionType often interacts with other variables and systems to determine behavior or capabilities. For example:

Developers should be aware that:

  1. The meaning of ConnectionType can vary depending on the context in which it’s used.
  2. It may affect system behavior, performance, or available features.
  3. Some connection types may have specific requirements or limitations.

Best practices when using ConnectionType include:

  1. Always check the documentation for the specific system you’re working with to understand the meaning and implications of different connection types.
  2. Handle all possible connection types in your code to ensure robustness.
  3. Consider connection type when designing systems that may need to work across different platforms or network conditions.
  4. Use appropriate error handling and fallback mechanisms for unsupported or unexpected connection types.

#Setting Variables

#References In INI files

Location: <Workspace>/Projects/Lyra/Config/DefaultEngine.ini:376, section: [/Script/AndroidFileServerEditor.AndroidFileServerRuntimeSettings]

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Plugins/Animation/LiveLink/Source/LiveLinkGraphNode/Private/K2Node_EvaluateLiveLinkFrame.cpp:156

Scope (from outer to inner):

file
function     bool UK2Node_EvaluateLiveLinkFrame::IsConnectionDisallowed

Source code excerpt:

		{
			bDisallowed = false;
			if (UScriptStruct* ConnectionType = Cast<UScriptStruct>(OtherPin->PinType.PinSubCategoryObject.Get()))
			{
				bDisallowed = GetLiveLinkRoleOutputStructType() != ConnectionType;
			}
		}
		else if (OtherPin->PinType.PinCategory == UEdGraphSchema_K2::PC_Wildcard)
		{
			bDisallowed = false;
		}

#Loc: <Workspace>/Engine/Plugins/ChaosClothAssetEditor/Source/ChaosClothAssetEditor/Private/ChaosClothAsset/ClothEditorMode.cpp:227

Scope (from outer to inner):

file
function     void UChaosClothAssetEditorMode::RegisterAddNodeCommand
lambda-function

Source code excerpt:

	auto AddNode = [this](const FName& NewNodeType)
	{
		const FName ConnectionType = FManagedArrayCollection::StaticType();
		const FName ConnectionName("Collection");

		UEdGraphNode* const CurrentlySelectedNode = GetSingleSelectedNodeWithOutputType(ConnectionType);
		checkf(CurrentlySelectedNode, TEXT("No node with FManagedArrayCollection output is currently selected in the Dataflow graph"));

		const UEdGraphNode* const NewNode = CreateAndConnectNewNode(NewNodeType, *CurrentlySelectedNode, ConnectionType, ConnectionName);
		verifyf(NewNode, TEXT("Failed to create a new node: %s"), *NewNodeType.ToString());

		StartToolForSelectedNode(NewNode);
	};

	auto CanAddNode = [this](const FName& NewNodeType) -> bool

#Loc: <Workspace>/Engine/Plugins/Enterprise/MDLImporter/Source/MDLImporter/Private/generator/MaterialExpressionConnection.h:109

Scope (from outer to inner):

file
namespace    Generator
function     EConnectionType GetConnectionType

Source code excerpt:

		EConnectionType GetConnectionType() const
		{
			return ConnectionType;
		}

		// Get expression without incrementing usage count
		UMaterialExpression* GetMaterialExpression() const
		{
			return ExpressionData.GetMaterialExpression();

#Loc: <Workspace>/Engine/Plugins/Enterprise/MDLImporter/Source/MDLImporter/Private/generator/MaterialExpressionConnection.h:120

Scope (from outer to inner):

file
namespace    Generator
function     bool HasExpression

Source code excerpt:

		bool HasExpression() const
		{
			return (ConnectionType == Expression) && GetMaterialExpression();
		}

		bool IsExpressionWithoutExpression() const
		{
			return (ConnectionType == Expression) && !GetMaterialExpression();
		}

		template<typename ExpressionType>
		bool IsExpressionA() const
		{
			return GetMaterialExpression()->IsA<ExpressionType>();

#Loc: <Workspace>/Engine/Plugins/Enterprise/MDLImporter/Source/MDLImporter/Private/generator/MaterialExpressionConnection.h:213

Scope (from outer to inner):

file
namespace    Generator

Source code excerpt:


	private:
		EConnectionType ConnectionType;

		FData     ExpressionData;
		FData     TextureSelectionData[3];
		union
		{
			bool      bValue;

#Loc: <Workspace>/Engine/Plugins/Enterprise/MDLImporter/Source/MDLImporter/Private/generator/MaterialExpressionConnection.h:338

Scope (from outer to inner):

file
namespace    Generator
function     inline FMaterialExpressionConnection::FMaterialExpressionConnection

Source code excerpt:


	inline FMaterialExpressionConnection::FMaterialExpressionConnection()
	    : ConnectionType(EConnectionType::Expression)
	    , ExpressionData(nullptr, 0, true)
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(UMaterialExpression* Expression)
		: ConnectionType(EConnectionType::Expression)
		, ExpressionData(Expression, 0, false)
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(FMaterialExpressionHandle ExpressionHandle,
	                                                                    int32                OutputIndex /*= 0*/,
	                                                                    bool                 bIsDefault /*= false*/)
	    : ConnectionType(EConnectionType::Expression)
	    , ExpressionData(ExpressionHandle, OutputIndex, bIsDefault)
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(bool bValue)
	    : ConnectionType(EConnectionType::Boolean)
	    , bValue(bValue)
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(int Value)
	    : ConnectionType(EConnectionType::Float)
	    , Values {static_cast<float>(Value), 0.0f, 0.0f, 0.0f}
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(float Value)
	    : ConnectionType(EConnectionType::Float)
	    , Values {Value, 0.0f, 0.0f, 0.0f}
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(float Value0, float Value1)
	    : ConnectionType(EConnectionType::Float2)
	    , Values {Value0, Value1, 0.0f, 0.0f}
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(float Value0, float Value1, float Value2)
	    : ConnectionType(EConnectionType::Float3)
	    , Values {Value0, Value1, Value2, 0.0f}
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(float Value0, float Value1, float Value2, float Value3)
	    : ConnectionType(EConnectionType::Float4)
	    , Values {Value0, Value1, Value2, Value3}
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(double Value)
	    : ConnectionType(EConnectionType::Float)
	    , Values {static_cast<float>(Value), 0.0f, 0.0f, 0.0f}
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(UTexture* Texture)
	    : ConnectionType(EConnectionType::Texture)
	    , Texture(Texture)
	{
	}

	inline FMaterialExpressionConnection::FMaterialExpressionConnection(const FData& Value, const FData& True, const FData& False)
	    : ConnectionType(EConnectionType::TextureSelection)
	{
		TextureSelectionData[0] = Value;
		TextureSelectionData[1] = True;
		TextureSelectionData[2] = False;
	}

	inline bool FMaterialExpressionConnection::operator!=(const FMaterialExpressionConnection& rhs)
	{
		return (ConnectionType != rhs.ConnectionType) ||
		       ((ConnectionType == EConnectionType::Expression) && (ExpressionData != rhs.ExpressionData)) ||
		       ((ConnectionType == EConnectionType::Boolean) && (bValue != rhs.bValue)) ||
		       ((ConnectionType == EConnectionType::Float) && (Values[0] != rhs.Values[0])) ||
		       ((ConnectionType == EConnectionType::Float2) && ((Values[0] != rhs.Values[0]) || (Values[1] != rhs.Values[1]))) ||
		       ((ConnectionType == EConnectionType::Float3) &&
		        ((Values[0] != rhs.Values[0]) || (Values[1] != rhs.Values[1]) || (Values[2] != rhs.Values[2]))) ||
		       ((ConnectionType == EConnectionType::Float4) &&
		        ((Values[0] != rhs.Values[0]) || (Values[1] != rhs.Values[1]) || (Values[2] != rhs.Values[2]) || (Values[3] != rhs.Values[3]))) ||
		       ((ConnectionType == EConnectionType::Texture) && (Texture != rhs.Texture)) ||
		       ((ConnectionType == EConnectionType::TextureSelection) &&
		        ((TextureSelectionData[0] != rhs.TextureSelectionData[0]) || (TextureSelectionData[1] != rhs.TextureSelectionData[1]) ||
		         (TextureSelectionData[2] != rhs.TextureSelectionData[2])));
	}

	inline FMaterialExpressionConnection::FData::FData()
		: Index(0)

#Loc: <Workspace>/Engine/Plugins/Experimental/Dataflow/Source/DataflowEditor/Private/Dataflow/DataflowEditorMode.cpp:160

Scope (from outer to inner):

file
function     void UDataflowEditorMode::RegisterAddNodeCommand
lambda-function

Source code excerpt:

	auto AddNode = [this](const FName& NewNodeType)
	{
		const FName ConnectionType = FManagedArrayCollection::StaticType();
		const FName ConnectionName("Collection");

		UEdGraphNode* const CurrentlySelectedNode = GetSingleSelectedNodeWithOutputType(ConnectionType);
		checkf(CurrentlySelectedNode, TEXT("No node with FManagedArrayCollection output is currently selected in the Dataflow graph"));

		const UEdGraphNode* const NewNode = CreateAndConnectNewNode(NewNodeType, *CurrentlySelectedNode, ConnectionType, ConnectionName);
		verifyf(NewNode, TEXT("Failed to create a new node: %s"), *NewNodeType.ToString());

		StartToolForSelectedNode(NewNode);
	};

	auto CanAddNode = [this](const FName& NewNodeType) -> bool

#Loc: <Workspace>/Engine/Plugins/Online/Android/AndroidFetchBackgroundDownload/Source/AndroidFetchBackgroundDownload/Private/AndroidPlatformBackgroundHttpManager.cpp:1172

Scope (from outer to inner):

file
function     void FAndroidPlatformBackgroundHttpManager::OnNetworkConnectionChanged

Source code excerpt:

}

void FAndroidPlatformBackgroundHttpManager::OnNetworkConnectionChanged(ENetworkConnectionType ConnectionType)
{
	bool bNewNetworkConnected = GetNetworkConnected();

	if (bNewNetworkConnected != bNetworkConnected)
	{
		bNetworkConnected = bNewNetworkConnected;

#Loc: <Workspace>/Engine/Plugins/Online/Android/AndroidFetchBackgroundDownload/Source/AndroidFetchBackgroundDownload/Private/AndroidPlatformBackgroundHttpManager.cpp:1183

Scope (from outer to inner):

file
function     void FAndroidPlatformBackgroundHttpManager::OnNetworkConnectionChanged

Source code excerpt:

		//On reconnecting to the network flag our worker to force requeue to make sure our work is continued
		//Don't requeue the worker if there is no Internet.
		if (ConnectionType != ENetworkConnectionType::None)
		{
			FPlatformAtomics::InterlockedExchange(&bShouldForceWorkerRequeue, true);
		}
	}
}

#Loc: <Workspace>/Engine/Plugins/Online/Android/AndroidFetchBackgroundDownload/Source/AndroidFetchBackgroundDownload/Public/AndroidPlatformBackgroundHttpManager.h:124

Scope (from outer to inner):

file
class        class FAndroidPlatformBackgroundHttpManager : public FBackgroundHttpManagerImpl

Source code excerpt:

	void HandleRequestsWaitingOnJavaThreadsafety();

	void OnNetworkConnectionChanged(ENetworkConnectionType ConnectionType);
	FDelegateHandle OnNetworkConnectionChangedDelegateHandle;

protected:
	//Used to determine the state of AndroidBackgroundHTTP in our configrules
	enum class EAndroidBackgroundDownloadConfigRulesSetting : uint8
	{

#Loc: <Workspace>/Engine/Plugins/Runtime/AndroidFileServer/Source/AndroidFileServerEditor/Private/AndroidFileServerRuntimeSettings.cpp:18

Scope (from outer to inner):

file
function     UAndroidFileServerRuntimeSettings::UAndroidFileServerRuntimeSettings

Source code excerpt:

		, bLogFiles(false)
		, bReportStats(false)
		, ConnectionType(EAFSConnectionType::USBOnly)
		, bUseManualIPAddress(false)
		, ManualIPAddress(TEXT(""))
{
}

void UAndroidFileServerRuntimeSettings::PostInitProperties()

#Loc: <Workspace>/Engine/Plugins/Runtime/AndroidFileServer/Source/AndroidFileServerEditor/Public/AndroidFileServerRuntimeSettings.h:63

Scope (from outer to inner):

file
class        class UAndroidFileServerRuntimeSettings : public UObject

Source code excerpt:

	// How to connect to file server (USB cable, Network, or combined)
	UPROPERTY(EditAnywhere, config, Category = Connection, Meta=(EditCondition = "bEnablePlugin"))
	TEnumAsByte<EAFSConnectionType::Type> ConnectionType;

	// Use manual IP address instead of automatic query from device (only for single device deploys!)
	UPROPERTY(EditAnywhere, config, Category = Connection, Meta=(EditCondition = "ConnectionType == EAFSConnectionType::NetworkOnly || ConnectionType == EAFSConnectionType::Combined"), Meta=(DisplayName = "Use Manual IP Address?"))
	bool bUseManualIPAddress;

	// IP address of device to use

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryScripting/Source/GeometryScriptingCore/Private/MeshSelectionFunctions.cpp:752

Scope (from outer to inner):

file
function     UDynamicMesh* UGeometryScriptLibrary_MeshSelectionFunctions::ExpandMeshSelectionToConnected

Source code excerpt:

	FGeometryScriptMeshSelection Selection,
	FGeometryScriptMeshSelection& NewSelection,
	EGeometryScriptTopologyConnectionType ConnectionType)
{
	if (TargetMesh == nullptr)
	{
		UE_LOG(LogGeometry, Warning, TEXT("ExpandMeshSelectionToConnected: TargetMesh is Null"));
		return TargetMesh;
	}

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryScripting/Source/GeometryScriptingCore/Private/MeshSelectionFunctions.cpp:773

Scope (from outer to inner):

file
function     UDynamicMesh* UGeometryScriptLibrary_MeshSelectionFunctions::ExpandMeshSelectionToConnected

Source code excerpt:


	if (Selection.GetSelectionType() == EGeometryScriptMeshSelectionType::Polygroups &&
		ConnectionType == EGeometryScriptTopologyConnectionType::Polygroup)
	{
		UE_LOG(LogGeometry, Warning, TEXT("ExpandMeshSelectionToConnected: Expanding Polygroup Selection to Connected Polygroups will not change selection"));
		NewSelection.SetSelection(Selection);	// this setup makes no sense
		return TargetMesh;
	}

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryScripting/Source/GeometryScriptingCore/Private/MeshSelectionFunctions.cpp:788

Scope (from outer to inner):

file
function     UDynamicMesh* UGeometryScriptLibrary_MeshSelectionFunctions::ExpandMeshSelectionToConnected

Source code excerpt:


	TSet<int32> ResultTriangles;
	if (ConnectionType == EGeometryScriptTopologyConnectionType::Geometric)
	{
		TargetMesh->ProcessMesh([&](const FDynamicMesh3& ReadMesh)
		{
			FMeshConnectedComponents::GrowToConnectedTriangles(&ReadMesh, CurTriangles, ResultTriangles, nullptr, [](int32, int32) { return true; });
		});
	}
	else if (ConnectionType == EGeometryScriptTopologyConnectionType::Polygroup)
	{
		TargetMesh->ProcessMesh([&](const FDynamicMesh3& ReadMesh)
		{
			FMeshConnectedComponents::GrowToConnectedTriangles(&ReadMesh, CurTriangles, ResultTriangles, nullptr,
				[&](int32 FromTriID, int32 ToTriID) {
					return ReadMesh.GetTriangleGroup(FromTriID) == ReadMesh.GetTriangleGroup(ToTriID);

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryScripting/Source/GeometryScriptingCore/Private/MeshSelectionFunctions.cpp:805

Scope (from outer to inner):

file
function     UDynamicMesh* UGeometryScriptLibrary_MeshSelectionFunctions::ExpandMeshSelectionToConnected

Source code excerpt:

		});
	}
	else if (ConnectionType == EGeometryScriptTopologyConnectionType::MaterialID)
	{
		TargetMesh->ProcessMesh([&](const FDynamicMesh3& ReadMesh)
		{
			if (ReadMesh.HasAttributes() && ReadMesh.Attributes()->GetMaterialID() != nullptr)
			{
				const FDynamicMeshMaterialAttribute* MaterialID = ReadMesh.Attributes()->GetMaterialID();

#Loc: <Workspace>/Engine/Plugins/Runtime/GeometryScripting/Source/GeometryScriptingCore/Public/GeometryScript/MeshSelectionFunctions.h:265

Scope (from outer to inner):

file
function     class GEOMETRYSCRIPTINGCORE_API UGeometryScriptLibrary_MeshSelectionFunctions : public UBlueprintFunctionLibrary { GENERATED_BODY

Source code excerpt:

	/**
	 * Expand the Selection on the TargetMesh to connected regions and return the NewSelection
	 * @param ConnectionType defines what "connected" means, ie purely geometric connection, or some additional constraint like same MaterialIDs/etc 
	 */
	UFUNCTION(BlueprintCallable, Category = "GeometryScript|MeshSelection", meta=(ScriptMethod))
	static UPARAM(DisplayName = "Target Mesh") UDynamicMesh* 
	ExpandMeshSelectionToConnected(
		UDynamicMesh* TargetMesh,
		FGeometryScriptMeshSelection Selection, 
		FGeometryScriptMeshSelection& NewSelection,
		EGeometryScriptTopologyConnectionType ConnectionType = EGeometryScriptTopologyConnectionType::Geometric );


	/**
	 * Grow or Shrink the Selection on the TargetMesh to connected neighbours.
	 * For Vertex selections, Expand includes vertices in one-ring of selected vertices, and Contract removes any vertices with a one-ring neighbour that is not selected
	 * For Triangle selections, Add/Remove Triangles connected to selected Triangles

#Loc: <Workspace>/Engine/Plugins/Runtime/MassGameplay/Source/MassReplication/Private/MassReplicationSubsystem.cpp:97

Scope (from outer to inner):

file
namespace    UE
namespace    Mass
namespace    Replication
function     ENetConnectionType HasParentOrChildWithValidParentNetConnection

Source code excerpt:

ENetConnectionType HasParentOrChildWithValidParentNetConnection(const APlayerController* Controller)
{
	ENetConnectionType ConnectionType = ENetConnectionType::None;

	if (Controller && Controller->NetConnection)
	{
		UChildConnection* ChildConnection = Cast<UChildConnection>(Controller->NetConnection);

		// if the NetConnection is either a parent connection or a child connection with APlayerController owning actor its valid 
		if (ChildConnection == nullptr)
		{
			ConnectionType = ENetConnectionType::Parent;
		}
		else
		{
			ConnectionType = (GetValidParentNetConnection(*ChildConnection) != nullptr) ? ENetConnectionType::Child : ENetConnectionType::None;
		}		
	}

	return ConnectionType;
}
}}};

bool UMassReplicationSubsystem::SynchronizeClients(const TArray<FViewerInfo>& Viewers)
{
	typedef TMap<FMassViewerHandle, FMassClientHandle> FControllerMap;

#Loc: <Workspace>/Engine/Plugins/Runtime/MassGameplay/Source/MassReplication/Private/MassReplicationSubsystem.cpp:280

Scope (from outer to inner):

file
function     void UMassReplicationSubsystem::SynchronizeClientViewers

Source code excerpt:

					APlayerController* Controller = MassLODSubsystem->GetPlayerControllerFromViewerHandle(ClientViewer);

					const UE::Mass::Replication::ENetConnectionType ConnectionType = UE::Mass::Replication::HasParentOrChildWithValidParentNetConnection(Controller);

					if (ConnectionType != UE::Mass::Replication::ENetConnectionType::None)
					{
						++ViewerIdx;

						// we don't verify or remove Parent Connections here as that was done when we synchronized the client bubbles
						if (ConnectionType == UE::Mass::Replication::ENetConnectionType::Child)
						{
							ClientViewerMap.Add(Controller, FMassClientViewerHandle(ClientHandle, ClientViewer));
						}
					}
					else //remove invalid ClientViewer, but dont increment the ViewerIdx
					{

#Loc: <Workspace>/Engine/Source/Developer/IOS/IOSTargetPlatform/Private/IOSDeviceHelper.cpp:272

Scope (from outer to inner):

file
class        class FIOSDevice
function     FIOSDevice

Source code excerpt:

	: UDID(InID)
	, Name(InName)
	, ConnectionType(InConnectionType)
	{
	}
	
	~FIOSDevice()
	{
	}

#Loc: <Workspace>/Engine/Source/Developer/IOS/IOSTargetPlatform/Private/IOSDeviceHelper.cpp:287

Scope (from outer to inner):

file
class        class FIOSDevice
function     DeviceConnectionInterface ConnectionInterface

Source code excerpt:

	DeviceConnectionInterface ConnectionInterface() const
	{
		return ConnectionType;
	}
	
private:
	FString UDID;
	FString Name;
	DeviceConnectionInterface ConnectionType;
};

/**
 * Delegate type for devices being connected or disconnected from the machine
 *
 * The first parameter is newly added or removed device

#Loc: <Workspace>/Engine/Source/Developer/TargetDeviceServices/Private/Proxies/TargetDeviceProxy.cpp:65

Scope (from outer to inner):

file
function     void FTargetDeviceProxy::UpdateFromMessage

Source code excerpt:

	DeviceUserPassword = Message.DeviceUserPassword;
	OSVersion = Message.OSVersion;
	ConnectionType = Message.ConnectionType;
	Shared = Message.Shared;
	SupportsMultiLaunch = Message.SupportsMultiLaunch;
	SupportsPowerOff = Message.SupportsPowerOff;
	SupportsPowerOn = Message.SupportsPowerOn;
	SupportsReboot = Message.SupportsReboot;
	SupportsVariants = Message.SupportsVariants;

#Loc: <Workspace>/Engine/Source/Developer/TargetDeviceServices/Private/Proxies/TargetDeviceProxy.h:163

Scope (from outer to inner):

file
class        class FTargetDeviceProxy : public ITargetDeviceProxy
function     virtual const FString& GetConnectionType

Source code excerpt:

	virtual const FString& GetConnectionType() const override
	{
		return ConnectionType;
	}

	virtual bool HasDeviceId(const FString& InDeviceId) const override;
	virtual bool HasVariant(FName InVariant) const override;
	virtual bool HasTargetPlatform(FName InTargetPlatformId) const override;

#Loc: <Workspace>/Engine/Source/Developer/TargetDeviceServices/Private/Proxies/TargetDeviceProxy.h:187

Scope (from outer to inner):

file
class        class FTargetDeviceProxy : public ITargetDeviceProxy
function     virtual bool IsSimulated

Source code excerpt:

	virtual bool IsSimulated() const override
	{
		return (ConnectionType == TEXT("Simulator"));
	}
	
	virtual bool TerminateLaunchedProcess(FName InVariant, const FString& ProcessIdentifier) override;

	virtual void PowerOff(bool Force) override;
	virtual void PowerOn() override;

#Loc: <Workspace>/Engine/Source/Developer/TargetDeviceServices/Private/Proxies/TargetDeviceProxy.h:270

Scope (from outer to inner):

file
class        class FTargetDeviceProxy : public ITargetDeviceProxy

Source code excerpt:


	/** Holds the type of connection. */
	FString ConnectionType;

	/** Holds default variant name. */
	FName DefaultVariant;


	/** Holds a flag indicating whether the proxy is of type "All Devices". */

#Loc: <Workspace>/Engine/Source/Developer/TargetDeviceServices/Private/Services/TargetDeviceService.cpp:426

Scope (from outer to inner):

file
function     void FTargetDeviceService::HandlePingMessage

Source code excerpt:

		Message->HostUser = FPlatformProcess::UserName(false);
		Message->Connected = DefaultDevice->IsConnected();
		Message->ConnectionType = TargetDeviceConnectionTypes::ToString(DefaultDevice->GetDeviceConnectionType());
		Message->Authorized = DefaultDevice->IsAuthorized();
		Message->Make = TEXT("@todo");
		Message->Model = DefaultDevice->GetModelId();
		Message->OSVersion = DefaultDevice->GetOSVersion();
		DefaultDevice->GetUserCredentials(Message->DeviceUser, Message->DeviceUserPassword);
		Message->Shared = Shared;

#Loc: <Workspace>/Engine/Source/Developer/TargetDeviceServices/Public/TargetDeviceServiceMessages.h:294

Scope: file

Source code excerpt:

	/** Holds the connection type. */
	UPROPERTY(EditAnywhere, Category="Message")
	FString ConnectionType;

	/** Holds the variant name of the default device. */
	UPROPERTY(EditAnywhere, Category="Message")
	FName DefaultVariant;

	/** List of the Flavors this service supports */

#Loc: <Workspace>/Engine/Source/Developer/TraceInsights/Private/Insights/Tests/InsightsTestUtils.cpp:137

Scope (from outer to inner):

file
function     bool FInsightsTestUtils::StartTracing

Source code excerpt:

////////////////////////////////////////////////////////////////////////////////////////////////////

bool FInsightsTestUtils::StartTracing(FTraceAuxiliary::EConnectionType ConnectionType, double Timeout) const
{
	bool bStarted = false;

	double TraceVerifyStartTime = FPlatformTime::Seconds();
	while(FPlatformTime::Seconds() - TraceVerifyStartTime < Timeout)
	{
		if (ConnectionType == FTraceAuxiliary::EConnectionType::Network)
		{
			bStarted = FTraceAuxiliary::Start(FTraceAuxiliary::EConnectionType::Network, TEXT("localhost"), nullptr);
		}
		else if (ConnectionType == FTraceAuxiliary::EConnectionType::File)
		{
			bStarted = FTraceAuxiliary::Start(FTraceAuxiliary::EConnectionType::File, nullptr, nullptr);
		}

		if (FTraceAuxiliary::IsConnected())
		{

#Loc: <Workspace>/Engine/Source/Developer/TraceInsights/Public/Insights/Tests/InsightsTestUtils.h:16

Scope (from outer to inner):

file
class        class FInsightsTestUtils

Source code excerpt:

	bool SetupUTS(double Timeout = 30.0, bool bUseFork = false) const;
	bool KillUTS(double Timeout = 30.0) const;
	bool StartTracing(FTraceAuxiliary::EConnectionType ConnectionType, double Timeout = 10.0) const;
	bool IsUnrealTraceServerReady(const TCHAR* Host = TEXT("localhost"), int32 Port = 0U) const;
	bool IsTraceHasLiveStatus(const FString& TraceName, const TCHAR* Host = TEXT("localhost"), int32 Port = 0U) const;
	void ResetSession() const;
	FString GetLiveTrace(const TCHAR* Host = TEXT("localhost"), int32 Port = 0U) const;

private:

#Loc: <Workspace>/Engine/Source/Editor/BlueprintGraph/Private/K2Node_GetDataTableRow.cpp:238

Scope (from outer to inner):

file
function     bool UK2Node_GetDataTableRow::IsConnectionDisallowed

Source code excerpt:

		if (OtherPin->PinType.PinCategory == UEdGraphSchema_K2::PC_Struct)
		{
			if (UScriptStruct* ConnectionType = Cast<UScriptStruct>(OtherPin->PinType.PinSubCategoryObject.Get()))
			{
				bDisallowed = !FDataTableEditorUtils::IsValidTableStruct(ConnectionType);
			}
		}
		else if (OtherPin->PinType.PinCategory == UEdGraphSchema_K2::PC_Wildcard)
		{
			bDisallowed = false;
		}

#Loc: <Workspace>/Engine/Source/Editor/UnrealEd/Private/MaterialGraphSchema.cpp:651

Scope (from outer to inner):

file
namespace    Private
function     FLinearColor GetColorForConnectionType

Source code excerpt:

namespace Private
{
FLinearColor GetColorForConnectionType(const UGraphEditorSettings* Settings, UE::Shader::EValueType ConnectionType)
{
	using namespace UE::Shader;
	if (ConnectionType == EValueType::Any)
	{
		return Settings->WildcardPinTypeColor;
	}
	else if (ConnectionType == EValueType::Struct)
	{
		return Settings->StructPinTypeColor;
	}
	else if (ConnectionType == EValueType::Object)
	{
		return Settings->ObjectPinTypeColor;
	}
	else
	{
		const FValueTypeDescription TypeDesc = GetValueTypeDescription(ConnectionType);
		if (TypeDesc.ComponentType == EValueComponentType::Float ||
			TypeDesc.ComponentType == EValueComponentType::Numeric)
		{
			if (TypeDesc.NumComponents == 1)
			{
				return Settings->FloatPinTypeColor;

#Loc: <Workspace>/Engine/Source/Runtime/Core/Private/Android/AndroidPlatformMisc.cpp:2833

Scope (from outer to inner):

file
function     bool FAndroidMisc::HasActiveWiFiConnection

Source code excerpt:

bool FAndroidMisc::HasActiveWiFiConnection()
{
	ENetworkConnectionType ConnectionType = GetNetworkConnectionType();
	return (ConnectionType == ENetworkConnectionType::WiFi ||
			ConnectionType == ENetworkConnectionType::WiMAX);
}
#endif

JNI_METHOD void Java_com_epicgames_unreal_GameActivity_nativeNetworkChanged(JNIEnv* jenv, jobject thiz)
{
	LastNetworkConnectionType = PrivateGetNetworkConnectionType();

#Loc: <Workspace>/Engine/Source/Runtime/Core/Public/GenericPlatform/GenericPlatformMisc.h:388

Scope: file

Source code excerpt:

};

typedef TDelegate<void(ENetworkConnectionType ConnectionType), FDefaultDelegateUserPolicy> FOnNetworkConnectionChangedDelegate;

enum class EProcessDiagnosticFlags : uint32
{
	None            = 0,
	MemorySanitizer = 1 << 0,
	AnsiMalloc      = 1 << 1,

#Loc: <Workspace>/Engine/Source/Runtime/Core/Public/Misc/CoreDelegates.h:277

Scope: file

Source code excerpt:

	static CORE_API TMulticastDelegate<void(bool)> OnLowPowerMode;

	DECLARE_MULTICAST_DELEGATE_OneParam(FOnNetworkConnectionChanged, ENetworkConnectionType /*ConnectionType*/);
	static CORE_API FOnNetworkConnectionChanged OnNetworkConnectionChanged;

	static CORE_API TTSMulticastDelegate<void(const TCHAR* IniFilename, int32& ResponderCount)>& TSCountPreLoadConfigFileRespondersDelegate();
	static CORE_API TTSMulticastDelegate<void(const TCHAR* IniFilename, FString& LoadedContents)>& TSPreLoadConfigFileDelegate();
	static CORE_API TTSMulticastDelegate<void(const TCHAR* IniFilename, const FString& ContentsToSave, int32& SavedCount)>& TSPreSaveConfigFileDelegate();
	static CORE_API TTSMulticastDelegate<void(const FConfigFile*)>& TSOnFConfigCreated();

#Loc: <Workspace>/Engine/Source/Runtime/InstallBundleManager/Private/InstallBundleUtils.cpp:28

Scope (from outer to inner):

file
namespace    InstallBundleUtil
function     bool HasInternetConnection

Source code excerpt:

	}

	bool HasInternetConnection(ENetworkConnectionType ConnectionType)
	{
		return ConnectionType != ENetworkConnectionType::AirplaneMode
			&& ConnectionType != ENetworkConnectionType::None;
	}

	const TCHAR* GetInstallBundlePauseReason(EInstallBundlePauseFlags Flags)
	{
		// Return the most appropriate reason given the flags

#Loc: <Workspace>/Engine/Source/Runtime/InstallBundleManager/Public/InstallBundleUtils.h:31

Scope (from outer to inner):

file
namespace    InstallBundleUtil

Source code excerpt:

	INSTALLBUNDLEMANAGER_API FString GetAppVersion();

	INSTALLBUNDLEMANAGER_API bool HasInternetConnection(ENetworkConnectionType ConnectionType);

	INSTALLBUNDLEMANAGER_API const TCHAR* GetInstallBundlePauseReason(EInstallBundlePauseFlags Flags);

	INSTALLBUNDLEMANAGER_API const FString& GetInstallBundleSectionPrefix();

	// returns true if the given BundleName exists in the InstallBundle.ini config

#Loc: <Workspace>/Projects/Lyra/Plugins/CommonUser/Source/CommonUser/Private/CommonUserSubsystem.cpp:831

Scope (from outer to inner):

file
function     bool UCommonUserSubsystem::HasOnlineConnection

Source code excerpt:

{
#if COMMONUSER_OSSV1
	EOnlineServerConnectionStatus::Type ConnectionType = GetConnectionStatus(Context);

	if (ConnectionType == EOnlineServerConnectionStatus::Normal || ConnectionType == EOnlineServerConnectionStatus::Connected)
	{
		return true;
	}

	return false;
#else

#References in C# build files

This variable is referenced in the following C# build files:

Location: <Workspace>/Engine/Source/Programs/AutomationTool/Android/AndroidPlatform.Automation.cs:869


		string ConnectionString = "";
		Ini.GetString("/Script/AndroidFileServerEditor.AndroidFileServerRuntimeSettings", "ConnectionType", out ConnectionString);
		switch (ConnectionString)
		{
			case "USBOnly":
				ConnectionType = EConnectionType.USBOnly;
				break;
			case "NetworkOnly":