LegacyGipGameControllerProvider Clase

Referencia

Definición

Espacio de nombres:: Windows.Gaming.Input.Preview

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Editar

Expone un conjunto de propiedades y funcionalidades para administrar accesorios de juego, como controladores para juegos y auriculares, que usan el protocolo GIP (Protocolo de entrada de juegos).

Importante

El acceso a esta clase requiere declarar la funcionalidad xboxAccessoryManagement

Precaución

Estas API afectan a todos los juegos de un sistema y pueden causar problemas en un accesorio si se usa incorrectamente. Microsoft solo recomienda usar estas API para administrar hardware que ha desarrollado.

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

Herencia: Object Platform::Object IInspectable LegacyGipGameControllerProvider

Atributos: ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Requisitos de Windows

Familia de dispositivos	Windows Desktop Extension SDK (se introdujo en la versión 10.0.23665.0)
API contract	Windows.Gaming.Input.GamingInputPreviewContract (se introdujo en la versión v2.0)

Ejemplos

Lectura de las propiedades de un 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);
    }
}

Botones de reasignación

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);
}

Configuración de 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);
}

Administración de auriculares

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);
}

Propiedades

AppCompatVersion	Obtiene la versión de compatibilidad de la aplicación notificada por el controlador GIP (Protocolo de entrada de juegos).
BatteryChargingState	Obtiene el estado de carga de la batería del controlador.
BatteryKind	Obtiene el tipo de batería del controlador.
BatteryLevel	Obtiene el nivel de carga de la batería del controlador.
IsFirmwareCorrupted	Devuelve si el firmware del controlador está dañado.
IsSyntheticDevice	Devuelve si el controlador es un dispositivo sintético o físico.
PreferredTypes	Obtiene el conjunto de tipos GIP (Protocolo de entrada de juegos) notificados por el controlador.

Métodos

ClearPairing(User, String)	Quita los emparejamientos de copilot para controllerId para el usuario especificado.
ExecuteCommand(DeviceCommand)	Ejecuta un comando en un casco GIP (Protocolo de entrada de juegos) heredado.
FromGameController(IGameController)	Construye un LegacyGipGameControllerProvider para el controlador especificado.
FromGameControllerProvider(IGameControllerProvider)	Construye un legacyGipGameControllerProvider para el proveedor de controlador especificado.
GetDeviceFirmwareCorruptionState()	Recupera el estado de si el firmware del dispositivo está dañado y, si es así, de qué manera.
GetExtendedDeviceInfo()	Recupera la información de identificación del dispositivo.
GetHeadsetOperation(HeadsetOperation)	Recupera una configuración de auriculares basada en `operation`.
GetStandardControllerButtonRemapping(User, Boolean)	Recupera el botón y la asignación de ejes de un controlador para juegos estándar para un usuario.
IsCopilot(User, String)	Recupera el identificador del controlador piloto si este controlador es un copiloto.
IsInterfaceSupported(Guid)	Consulta si el controlador admite el guid de interfaz GIP (Protocolo de entrada de juegos) especificado.
IsPilot(User, String)	Recupera el identificador del controlador copiloto si este controlador es un piloto.
PairPilotToCopilot(User, String, String)	Empareja los controladores piloto y copilotos especificados para el usuario determinado.
SetHeadsetOperation(HeadsetOperation, Byte[])	Establece una operación de auriculares.
SetHomeLedIntensity(Byte)	Establece el brillo del LED en el botón inicio del controlador.
SetStandardControllerButtonRemapping(User, Boolean, IMapView<RemappingButtonCategory,Object>)	Cambia el botón y la asignación de ejes de un controlador para juegos estándar para un usuario.

Se aplica a

Consulte también

IGameControllerProvider

Compartir a través de