LegacyGipGameControllerProvider Classe

Referência

Definição

Namespace:: Windows.Gaming.Input.Preview

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Editar

Expõe um conjunto de propriedades e funcionalidades para administrar acessórios de jogos, como gamepads e headsets, que usam o protocolo GIP (Protocolo de Entrada de Jogos).

Importante

O acesso a essa classe requer declarar a funcionalidade xboxAccessoryManagement

Cuidado

Essas APIs afetam todos os jogos em um sistema e podem causar problemas em um acessório se forem mal utilizadas. A Microsoft recomenda usar apenas essas APIs para administrar o hardware que você desenvolveu.

public ref class LegacyGipGameControllerProvider sealed

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Gaming.Input.GamingInputPreviewContract, 131072)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class LegacyGipGameControllerProvider final

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Gaming.Input.GamingInputPreviewContract), 131072)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class LegacyGipGameControllerProvider

Public NotInheritable Class LegacyGipGameControllerProvider

Herança: Object Platform::Object IInspectable LegacyGipGameControllerProvider

Atributos: ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisitos do Windows

Família de dispositivos	Windows Desktop Extension SDK (introduzida na 10.0.23665.0)
API contract	Windows.Gaming.Input.GamingInputPreviewContract (introduzida na v2.0)

Exemplos

Lendo as propriedades de um controlador

public void EnumerateControllerProperties()
{
    foreach (Gamepad gamepad in Gamepad.Gamepads)
    {
        // Create the provider
        LegacyGipGameControllerProvider legacyGipGameControllerProvider =
            LegacyGipGameControllerProvider.FromGameController(gamepad);
        if (legacyGipGameControllerProvider == null)
        {
            // Not every gamepad is a legacy GIP game controller, continue enumerating
            continue;
        }

        // Check properties
        GameControllerBatteryChargingState chargeState =
            legacyGipGameControllerProvider.BatteryChargingState;
        GameControllerBatteryKind batteryKind =
            legacyGipGameControllerProvider.BatteryKind;
        GameControllerBatteryLevel batteryLevel =
            legacyGipGameControllerProvider.BatteryLevel;
        bool isOldFirmwareCorrupted =
            legacyGipGameControllerProvider.IsFirmwareCorrupted;
        bool isNewFirmwareCorrupted =
            legacyGipGameControllerProvider.GetDeviceFirmwareCorruptionState()
            != GameControllerFirmwareCorruptReason.NotCorrupt;
        bool isSynthetic = legacyGipGameControllerProvider.IsSyntheticDevice;
        byte[] extendedDeviceInfo = legacyGipGameControllerProvider.GetExtendedDeviceInfo();

        // Check for a particular GIP interface
        bool supportsSomeCustomInterface =
            legacyGipGameControllerProvider.IsInterfaceSupported(
                new Guid(
                    0xaaaaaaaa, 0xbbbb, 0xcccc, 0xe, 0xf, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6));

        IReadOnlyList<string> preferredTypes =
            legacyGipGameControllerProvider.PreferredTypes;
        bool isGamepad = preferredTypes.Contains("Windows.Xbox.Input.Gamepad");
        bool isHeadset = preferredTypes.Contains("Windows.Xbox.Input.Headset");

        // Change the LED to half brightness
        legacyGipGameControllerProvider.SetHomeLedIntensity(50);
    }
}

Remapear botões

void RemapButtons(IGameController controller, IGameControllerProvider controllerProvider)
{
    LegacyGipGameControllerProvider legacyGipGameControllerProvider =
        LegacyGipGameControllerProvider.FromGameControllerProvider(controllerProvider);

    // Retrieve all current remappings set for standard controllers
    IReadOnlyDictionary<RemappingButtonCategory, object> currentMappings =
        legacyGipGameControllerProvider.GetStandardControllerButtonRemapping(
            controller.User, false);

    // Swap two of the buttons
    Dictionary<RemappingButtonCategory, object> remaps =
        new Dictionary<RemappingButtonCategory, object>();

    // Duplicates are not allowed. Swap two of the buttons
    UInt64 currentButtonMappings =
       (UInt64)currentMappings[RemappingButtonCategory.ButtonSettings];

    // Isolate the buttons we want to remap
    UInt64 lastButton = (currentButtonMappings & 0xf000000000000000);
    UInt64 secondLastButton = currentButtonMappings & 0x0f00000000000000;

    // Swap their positions
    UInt64 newMapping = (lastButton >> 4) | (secondLastButton << 4);

    // Recombine with the original mappings
    UInt64 newButtonMappings = (currentButtonMappings & 0x00ffffffffffffff) | newMapping;

    // Add the new button remappings to the mapping dictionary
    remaps.Add(RemappingButtonCategory.ButtonSettings, newButtonMappings);

    // Update controller mapping
    legacyGipGameControllerProvider.SetStandardControllerButtonRemapping(
        controller.User, false, newButtonMappings);
}

Configurações do copilot

public void CopilotSample(GipGameControllerProvider pilotProvider,
                                    GipGameControllerProvider copilotProvider)
{
    // Establish a copilot pairing for the given pilot and copilot providers
    string pilotId = GameControllerProviderInfo.GetProviderId(pilotProvider);
    string copilotId = GameControllerProviderInfo.GetProviderId(copilotProvider);
    User user = User.GetDefault();
    LegacyGipGameControllerProvider.PairPilotToCopilot(user, pilotId,
        copilotId);

    // Read copilot properties
    LegacyGipGameControllerProvider.IsPilot(user, pilotId); // Returns copilotId
    LegacyGipGameControllerProvider.IsPilot(user, copilotId); // Returns null
    LegacyGipGameControllerProvider.IsCopilot(user, pilotId); // Returns null
    LegacyGipGameControllerProvider.IsCopilot(user, copilotId); // Returns pilotId

    // Removes the pairing for both controllers
    LegacyGipGameControllerProvider.ClearPairing(user, pilotId);
    // Also removes the pairing for both controllers (unnecessary since the pairing was already removed)
    LegacyGipGameControllerProvider.ClearPairing(user, copilotId);
}

Gerenciamento de headset

public void SetupHeadset(IGameControllerProvider headsetProvider)
{
    LegacyGipGameControllerProvider legacyGipGameControllerProvider =
        LegacyGipGameControllerProvider.FromGameControllerProvider(headsetProvider);

    // Reset the device
    legacyGipGameControllerProvider.ExecuteCommand(DeviceCommand.Reset);

    // Check the smart mute level
    byte[] smartMuteBuffer =
        legacyGipGameControllerProvider.GetHeadsetOperation(HeadsetOperation.SmartMute);
    HeadsetLevel smartMuteValue = (HeadsetLevel)smartMuteBuffer[0];

    // Set bass boost to 3db
    byte[] bassBuffer = BitConverter.GetBytes((UInt32)3);
    legacyGipGameControllerProvider.SetHeadsetOperation(HeadsetOperation.BassBoostGain,
        bassBuffer);
}

Propriedades

AppCompatVersion	Obtém a versão de compatibilidade do aplicativo relatada pelo driver GIP (Protocolo de Entrada de Jogos).
BatteryChargingState	Obtém o estado de carregamento da bateria do controlador.
BatteryKind	Obtém o tipo de bateria do controlador.
BatteryLevel	Obtém o nível de carga da bateria do controlador.
IsFirmwareCorrupted	Retorna se o firmware do controlador está corrompido.
IsSyntheticDevice	Retorna se o controlador é um dispositivo sintético ou físico.
PreferredTypes	Obtém o conjunto de tipos GIP (Protocolo de Entrada de Jogos) relatados pelo controlador.

Métodos

ClearPairing(User, String)	Remove quaisquer emparelhamentos de copilot para controllerId para o usuário fornecido.
ExecuteCommand(DeviceCommand)	Executa um comando em um headset GIP (Protocolo de Entrada de Jogos) herdado.
FromGameController(IGameController)	Constrói um LegacyGipGameControllerProvider para o controlador especificado.
FromGameControllerProvider(IGameControllerProvider)	Constrói um LegacyGipGameControllerProvider para o provedor de controlador especificado.
GetDeviceFirmwareCorruptionState()	Recupera o estado de se o firmware do dispositivo está corrompido e, em caso afirmativo, de que maneira.
GetExtendedDeviceInfo()	Recupera informações de identificação para o dispositivo.
GetHeadsetOperation(HeadsetOperation)	Recupera uma configuração de headset com base em `operation`.
GetStandardControllerButtonRemapping(User, Boolean)	Recupera o mapeamento de botão e eixo de um gamepad padrão para um usuário.
IsCopilot(User, String)	Recupera a ID do controlador piloto se esse controlador for um copilot.
IsInterfaceSupported(Guid)	Consulta se o guid de interface GIP (Protocolo de Entrada de Jogos) fornecido tem suporte do controlador.
IsPilot(User, String)	Recupera a ID do controlador copilot se esse controlador for um piloto.
PairPilotToCopilot(User, String, String)	Emparelha os controladores piloto e copilot fornecidos para o usuário fornecido.
SetHeadsetOperation(HeadsetOperation, Byte[])	Define uma operação de headset.
SetHomeLedIntensity(Byte)	Define o brilho do LED no botão inicial do controlador.
SetStandardControllerButtonRemapping(User, Boolean, IMapView<RemappingButtonCategory,Object>)	Altera o mapeamento de botão e eixo de um gamepad padrão para um usuário.

Aplica-se a

Confira também

IGameControllerProvider

Compartilhar via