LegacyGipGameControllerProvider Klasse

Referenz

Definition

Namespace:: Windows.Gaming.Input.Preview

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Bearbeiten

Macht eine Reihe von Eigenschaften und Funktionen für die Verwaltung von Gaming-Zubehör verfügbar, z. B. Gamepads und Headsets, die das GIP-Protokoll (Gaming Input Protocol) verwenden.

Wichtig

Für den Zugriff auf diese Klasse muss die Funktion xboxAccessoryManagement deklariert werden.

Achtung

Diese APIs wirken sich auf alle Spiele auf einem System aus und können probleme mit einem Zubehör verursachen, wenn sie missbraucht werden. Microsoft empfiehlt, diese APIs nur für die Verwaltung der von Ihnen entwickelten Hardware zu verwenden.

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

Vererbung: Object Platform::Object IInspectable LegacyGipGameControllerProvider

Attribute: ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Windows-Anforderungen

Gerätefamilie	Windows Desktop Extension SDK (eingeführt in 10.0.23665.0)
API contract	Windows.Gaming.Input.GamingInputPreviewContract (eingeführt in v2.0)

Beispiele

Lesen der Eigenschaften eines Controllers

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

Schaltflächen neu zuordnen

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

Copilot-Einstellungen

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

Headsetverwaltung

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

Eigenschaften

AppCompatVersion	Ruft die vom GIP-Treiber (Gaming Input Protocol) gemeldete App-Compat-Version ab.
BatteryChargingState	Ruft den Akkuladezustand des Controllers ab.
BatteryKind	Ruft den Akkutyp des Controllers ab.
BatteryLevel	Ruft den Akkuladestand des Controllers ab.
IsFirmwareCorrupted	Gibt zurück, ob die Controllerfirmware beschädigt ist.
IsSyntheticDevice	Gibt zurück, ob es sich beim Controller um ein synthetisches oder physisches Gerät handelt.
PreferredTypes	Ruft den Satz von GIP-Typen (Gaming Input Protocol) ab, die vom Controller gemeldet werden.

Methoden

ClearPairing(User, String)	Entfernt alle Copilot-Kopplungen für controllerId für den angegebenen Benutzer.
ExecuteCommand(DeviceCommand)	Führt einen Befehl für ein älteres GIP-Headset (Gaming Input Protocol) aus.
FromGameController(IGameController)	Erstellt einen LegacyGipGameControllerProvider für den angegebenen Controller.
FromGameControllerProvider(IGameControllerProvider)	Erstellt einen LegacyGipGameControllerProvider für den angegebenen Controlleranbieter.
GetDeviceFirmwareCorruptionState()	Ruft den Zustand ab, ob die Firmware des Geräts beschädigt ist und wenn ja, auf welche Weise.
GetExtendedDeviceInfo()	Ruft Identifikationsinformationen für das Gerät ab.
GetHeadsetOperation(HeadsetOperation)	Ruft eine Headseteinstellung basierend auf ab `operation`.
GetStandardControllerButtonRemapping(User, Boolean)	Ruft die Schaltflächen- und Achsenzuordnung eines Standard-Gamepads für einen Benutzer ab.
IsCopilot(User, String)	Ruft die ID des Pilotcontrollers ab, wenn es sich bei diesem Controller um einen Copiloten handelt.
IsInterfaceSupported(Guid)	Fragt ab, ob die angegebene GIP-Schnittstelle (Gaming Input Protocol) vom Controller unterstützt wird.
IsPilot(User, String)	Ruft die ID des Copilot-Controllers ab, wenn dieser Controller ein Pilot ist.
PairPilotToCopilot(User, String, String)	Koppelt die angegebenen Pilot- und Copilot-Controller für den jeweiligen Benutzer.
SetHeadsetOperation(HeadsetOperation, Byte[])	Legt einen Headset-Vorgang fest.
SetHomeLedIntensity(Byte)	Legt die Helligkeit der LED in der Starttaste des Controllers fest.
SetStandardControllerButtonRemapping(User, Boolean, IMapView<RemappingButtonCategory,Object>)	Ändert die Schaltflächen- und Achsenzuordnung eines Standard-Gamepads für einen Benutzer.

Gilt für:

Weitere Informationen

IGameControllerProvider

Freigeben über