Simulieren der Benutzereingabe über die Eingabeeinfügung

Simulieren und Automatisieren von Benutzereingaben von Geräten wie Tastatur, Maus, Toucheingabe, Stift und Gamepad in Ihren Windows-Anwendungen.

Wichtige APIs: Windows.UI.Input.Preview.Injection

Übersicht

Die Eingabeeinfügung ermöglicht Es Ihrer Windows-Anwendung, Eingaben von einer Vielzahl von Eingabegeräten zu simulieren und diese Eingabe an beliebiger Stelle zu leiten, einschließlich außerhalb des Clientbereichs Ihrer App (auch für Apps, die mit Administratorrechten ausgeführt werden, z. B. den Registrierungs-Editor).

Die Eingabeeinfügung ist nützlich für Windows-Apps und -Tools, die Funktionen bereitstellen müssen, die Barrierefreiheit, Tests (Ad-hoc, automatisiert) und Remotezugriffs- und Supportfeatures umfassen.

Setup

Um die Eingabeeinfügungs-APIs in Ihrer Windows-App zu verwenden, müssen Sie dem App-Manifest Folgendes hinzufügen:

1. Klicken Sie mit der rechten Maustaste auf die Datei "Package.appxmanifest ", und wählen Sie "Code anzeigen" aus.
2. Fügen Sie Folgendes in den Package Knoten ein:
   • xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
   • IgnorableNamespaces="rescap"
3. Fügen Sie Folgendes in den Capabilities Knoten ein:
   • <rescap:Capability Name="inputInjectionBrokered" />

Doppelte Benutzereingabe

Beispiel für die Eingabeeinfügung per Toucheingabe

In diesem Beispiel wird veranschaulicht, wie Sie die Eingabeeinfügungs-APIs (Windows.UI.Input.Preview.Injection) verwenden, um Mauseingabeereignisse in einem Bereich einer App zu überwachen und entsprechende Toucheingabeereignisse in einem anderen Bereich zu simulieren.

Laden Sie dieses Beispiel aus dem Eingabeeinfügungsbeispiel herunter (Maus zur Toucheingabe)

1. Zunächst richten wir die Benutzeroberfläche (MainPage.xaml) ein.

   Wir haben zwei Rasterbereiche (eine für die Mauseingabe und eine für die eingefügte Toucheingabe), jeweils mit vier Schaltflächen.

   Hinweis

   Dem Rasterhintergrund muss ein Wert zugewiesen werden (Transparentin diesem Fall), andernfalls werden Zeigerereignisse nicht erkannt.

   Wenn mausklicks im Eingabebereich erkannt werden, wird ein entsprechendes Touchereignis in den Eingabeeinfügungsbereich eingefügt. Schaltflächenklicks aus injizierten Eingaben werden im Titelbereich gemeldet.

   <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
       <Grid.RowDefinitions>
           <RowDefinition Height="Auto"/>
           <RowDefinition Height="Auto"/>
           <RowDefinition Height="*"/>
       </Grid.RowDefinitions>
       <StackPanel Grid.Row="0"
                   Margin="10">
           <TextBlock Style="{ThemeResource TitleTextBlockStyle}" 
                      Name="titleText"
                      Text="Touch input injection"
                      HorizontalTextAlignment="Center" />
           <TextBlock Style="{ThemeResource BodyTextBlockStyle}"
                      Name="statusText"
                      HorizontalTextAlignment="Center" />
       </StackPanel>
       <Grid HorizontalAlignment="Center"
                       Grid.Row="1">
           <Grid.RowDefinitions>
               <RowDefinition Height="Auto"/>
               <RowDefinition Height="*"/>
           </Grid.RowDefinitions>
           <Grid.ColumnDefinitions>
               <ColumnDefinition/>
               <ColumnDefinition/>
           </Grid.ColumnDefinitions>
           <TextBlock Grid.Column="0" 
                      Grid.Row="0" 
                      Style="{ThemeResource CaptionTextBlockStyle}"
                      Text="User mouse input area"/>
           <!-- Background must be set to something, otherwise pointer events are not detected. -->
           <Grid Name="ContainerInput" 
                 Grid.Column="0" 
                 Grid.Row="1"
                 HorizontalAlignment="Stretch" 
                 Background="Transparent" 
                 BorderBrush="Green" 
                 BorderThickness="2" 
                 MinHeight="100" MinWidth="300" 
                 Margin="10">
               <Grid.ColumnDefinitions>
                   <ColumnDefinition/>
                   <ColumnDefinition/>
                   <ColumnDefinition/>
                   <ColumnDefinition/>
               </Grid.ColumnDefinitions>
               <Button Name="B1" 
                       Grid.Column="0" 
                       HorizontalAlignment="Center" 
                       Width="50" Height="50"
                       Content="B1" />
               <Button Name="B2" 
                       Grid.Column="1" 
                       HorizontalAlignment="Center" 
                       Width="50" Height="50"
                       Content="B2" />
               <Button Name="B3" 
                       Grid.Column="2" 
                       HorizontalAlignment="Center" 
                       Width="50" Height="50"
                       Content="B3" />
               <Button Name="B4" 
                       Grid.Column="3" 
                       HorizontalAlignment="Center" 
                       Width="50" Height="50"
                       Content="B4" />
           </Grid>
           <TextBlock Grid.Column="1" 
                      Grid.Row="0"                         
                      Style="{ThemeResource CaptionTextBlockStyle}"
                      Text="Injected touch input area"/>
           <Grid Name="ContainerInject"
                 Grid.Column="1"  
                 Grid.Row="1"
                 HorizontalAlignment="Stretch"
                 BorderBrush="Red" 
                 BorderThickness="2" 
                 MinHeight="100" MinWidth="300" 
                 Margin="10">
               <Grid.ColumnDefinitions>
                   <ColumnDefinition/>
                   <ColumnDefinition/>
                   <ColumnDefinition/>
                   <ColumnDefinition/>
               </Grid.ColumnDefinitions>
               <Button Name="B1i" Click="Button_Click_Injected"
                       Content="B1i"
                       Grid.Column="0" 
                       HorizontalAlignment="Center" 
                       Width="50" Height="50" />
               <Button Name="B2i" Click="Button_Click_Injected"
                       Content="B2i"
                       Grid.Column="1" 
                       HorizontalAlignment="Center" 
                       Width="50" Height="50" />
               <Button Name="B3i" Click="Button_Click_Injected"
                       Content="B3i"
                       Grid.Column="2" 
                       HorizontalAlignment="Center" 
                       Width="50" Height="50" />
               <Button Name="B4i" Click="Button_Click_Injected"
                       Content="B4i"
                       Grid.Column="3" 
                       HorizontalAlignment="Center" 
                       Width="50" Height="50" />
           </Grid>
       </Grid>
   </Grid>
   

2. Als Nächstes initialisieren wir unsere App.

   In diesem Codeausschnitt deklarieren wir unsere globalen Objekte und deklarieren Listener für Zeigerereignisse (AddHandler) im Mauseingabebereich, die möglicherweise als behandelt in den Schaltflächenklickereignissen markiert werden.

   Das InputInjector -Objekt stellt das virtuelle Eingabegerät zum Senden der Eingabedaten dar.

   ContainerInput_PointerPressed Im Handler rufen wir die Toucheinfügungsfunktion auf.

   ContainerInput_PointerReleased Im Handler rufen wir UninitializeTouchInjection auf, um das InputInjector-Objekt zu beenden.

   public sealed partial class MainPage : Page
   {
       /// <summary>
       /// The virtual input device.
       /// </summary>
       InputInjector _inputInjector;
   
       /// <summary>
       /// Initialize the app, set the window size, 
       /// and add pointer input handlers for the container.
       /// </summary>
       public MainPage()
       {
           this.InitializeComponent();
   
           ApplicationView.PreferredLaunchViewSize =
               new Size(600, 200);
           ApplicationView.PreferredLaunchWindowingMode =
               ApplicationViewWindowingMode.PreferredLaunchViewSize;
   
           // Button handles PointerPressed/PointerReleased in 
           // the Tapped routed event, but we need the container Grid 
           // to handle them also. Add a handler for both 
           // PointerPressedEvent and PointerReleasedEvent on the input Grid 
           // and set handledEventsToo to true.
           ContainerInput.AddHandler(PointerPressedEvent,
               new PointerEventHandler(ContainerInput_PointerPressed), true);
           ContainerInput.AddHandler(PointerReleasedEvent,
               new PointerEventHandler(ContainerInput_PointerReleased), true);
       }
   
       /// <summary>
       /// PointerReleased handler for all pointer conclusion events.
       /// PointerPressed and PointerReleased events do not always occur 
       /// in pairs, so your app should listen for and handle any event that 
       /// might conclude a pointer down (such as PointerExited, PointerCanceled, 
       /// and PointerCaptureLost).  
       /// </summary>
       /// <param name="sender">Source of the click event</param>
       /// <param name="e">Event args for the button click routed event</param>
       private void ContainerInput_PointerReleased(
           object sender, PointerRoutedEventArgs e)
       {
           // Prevent most handlers along the event route from handling event again.
           e.Handled = true;
   
           // Shut down the virtual input device.
           _inputInjector.UninitializeTouchInjection();
       }
   
       /// <summary>
       /// PointerPressed handler.
       /// PointerPressed and PointerReleased events do not always occur 
       /// in pairs. Your app should listen for and handle any event that 
       /// might conclude a pointer down (such as PointerExited, 
       /// PointerCanceled, and PointerCaptureLost).  
       /// </summary>
       /// <param name="sender">Source of the click event</param>
       /// <param name="e">Event args for the button click routed event</param>
       private void ContainerInput_PointerPressed(
           object sender, PointerRoutedEventArgs e)
       {
           // Prevent most handlers along the event route from 
           // handling the same event again.
           e.Handled = true;
   
           InjectTouchForMouse(e.GetCurrentPoint(ContainerInput));
   
       }
       ...
   }
   

3. Dies ist die Toucheingabeeinfügungsfunktion.

   Zuerst rufen wir TryCreate auf, um das InputInjector-Objekt zu instanziieren.

   Anschließend rufen wir InitializeTouchInjection mit einem InjectedInputVisualizationMode von Default.

   Nach der Berechnung des Einfügepunkts rufen wir "InjectedInputTouchInfo " auf, um die Liste der zu injizierenden Berührungspunkte zu initialisieren (in diesem Beispiel erstellen wir einen Touchpunkt, der dem Mauseingabezeiger entspricht).

   Schließlich wird "InjectTouchInput" zweimal aufgerufen, der erste für einen Zeiger nach unten und die zweite für einen Zeiger nach oben.

   /// <summary>
   /// Inject touch input on injection target corresponding 
   /// to mouse click on input target.
   /// </summary>
   /// <param name="pointerPoint">The mouse click pointer.</param>
   private void InjectTouchForMouse(PointerPoint pointerPoint)
   {
       // Create the touch injection object.
       _inputInjector = InputInjector.TryCreate();
   
       if (_inputInjector != null)
       {
           _inputInjector.InitializeTouchInjection(
               InjectedInputVisualizationMode.Default);
   
           // Create a unique pointer ID for the injected touch pointer.
           // Multiple input pointers would require more robust handling.
           uint pointerId = pointerPoint.PointerId + 1;
   
           // Get the bounding rectangle of the app window.
           Rect appBounds =
               Windows.UI.ViewManagement.ApplicationView.GetForCurrentView().VisibleBounds;
   
           // Get the top left screen coordinates of the app window rect.
           Point appBoundsTopLeft = new Point(appBounds.Left, appBounds.Top);
   
           // Get a reference to the input injection area.
           GeneralTransform injectArea =
               ContainerInject.TransformToVisual(Window.Current.Content);
   
           // Get the top left screen coordinates of the input injection area.
           Point injectAreaTopLeft = injectArea.TransformPoint(new Point(0, 0));
   
           // Get the screen coordinates (relative to the input area) 
           // of the input pointer.
           int pointerPointX = (int)pointerPoint.Position.X;
           int pointerPointY = (int)pointerPoint.Position.Y;
   
           // Create the point for input injection and calculate its screen location.
           Point injectionPoint =
               new Point(
                   appBoundsTopLeft.X + injectAreaTopLeft.X + pointerPointX,
                   appBoundsTopLeft.Y + injectAreaTopLeft.Y + pointerPointY);
   
           // Create a touch data point for pointer down.
           // Each element in the touch data list represents a single touch contact. 
           // For this example, we're mirroring a single mouse pointer.
           List<InjectedInputTouchInfo> touchData =
               new List<InjectedInputTouchInfo>
               {
                   new InjectedInputTouchInfo
                   {
                       Contact = new InjectedInputRectangle
                       {
                           Left = 30, Top = 30, Bottom = 30, Right = 30
                       },
                       PointerInfo = new InjectedInputPointerInfo
                       {
                           PointerId = pointerId,
                           PointerOptions =
                           InjectedInputPointerOptions.PointerDown |
                           InjectedInputPointerOptions.InContact |
                           InjectedInputPointerOptions.New,
                           TimeOffsetInMilliseconds = 0,
                           PixelLocation = new InjectedInputPoint
                           {
                               PositionX = (int)injectionPoint.X ,
                               PositionY = (int)injectionPoint.Y
                           }
                   },
                   Pressure = 1.0,
                   TouchParameters =
                       InjectedInputTouchParameters.Pressure |
                       InjectedInputTouchParameters.Contact
               }
           };
   
           // Inject the touch input. 
           _inputInjector.InjectTouchInput(touchData);
   
           // Create a touch data point for pointer up.
           touchData = new List<InjectedInputTouchInfo>
           {
               new InjectedInputTouchInfo
               {
                   PointerInfo = new InjectedInputPointerInfo
                   {
                       PointerId = pointerId,
                       PointerOptions = InjectedInputPointerOptions.PointerUp
                   }
               }
           };
   
           // Inject the touch input. 
           _inputInjector.InjectTouchInput(touchData);
       }
   }
   

4. Schließlich behandeln wir alle Schaltflächenklick-Routingereignisse im Eingabeeinfügungsbereich und aktualisieren die Benutzeroberfläche mit dem Namen der geklickten Schaltfläche.

Weitere Informationen

Themenbeispiele

• Eingabeeinfügungsbeispiel (Maus zur Toucheingabe)