Lancer une application sur un appareil distant

Cet article explique comment lancer une application Windows sur un appareil distant.

Depuis Windows 10 version 1607, une application UWP peut lancer une application UWP ou une application de bureau Windows à distance sur un autre appareil qui exécute également Windows 10 version 1607 ou ultérieure, pourvu que les deux appareils soient signés avec le même compte Microsoft (MSA). Il s’agit du cas d’usage le plus simple du projet Rome.

La fonctionnalité de lancement à distance permet des expériences utilisateur orientées tâches ; un utilisateur peut démarrer une tâche sur un appareil et la terminer sur un autre. Par exemple, si l’utilisateur écoute de la musique sur son téléphone dans sa voiture, il peut alors transmettre la fonctionnalité de lecture à sa Xbox One lorsqu’il arrive à la maison. Le lancement à distance permet aux applications de transmettre des données contextuelles à l’application distante en cours de lancement, afin de reprendre là où la tâche a été laissée.

Configuration préliminaire

Ajouter la fonctionnalité remoteSystem

Pour que votre application puisse lancer une application sur un appareil distant, vous devez ajouter la fonctionnalité remoteSystem dans le manifeste de votre package d’application. Vous pouvez utiliser le concepteur de manifeste de package pour l’ajouter en sélectionnant Système distant sous l’onglet Fonctionnalités , ou vous pouvez ajouter manuellement la ligne suivante au fichier Package.appxmanifest de votre projet.

<Capabilities>
   <uap3:Capability Name="remoteSystem"/>
</Capabilities>

Activer le partage entre appareils

En outre, l’appareil client doit être défini pour autoriser le partage entre appareils. Ce paramètre, accessible dans Paramètres : Partage d’expériences>>partagéesentreles appareils, est activé par défaut.

Trouver un appareil distant

Vous devez tout d’abord trouver l’appareil auquel vous souhaitez vous connecter. La section Détecter les périphériques distants explique en détail comment faire. Nous allons utiliser une approche simple, qui permet un filtrage par type d’appareil ou de connectivité. Nous allons créer un observateur qui recherche des appareils distants et écrire des gestionnaires d’événement qui surviennent lorsque des appareils sont détectés ou supprimés. Ce qui nous fournira un ensemble d’appareils distants.

Le code de ces exemples nécessite que vous disposiez d’une using Windows.System.RemoteSystems instruction dans vos fichiers de classe.

private async Task BuildDeviceList()
{
    RemoteSystemAccessStatus accessStatus = await RemoteSystem.RequestAccessAsync();

    if (accessStatus == RemoteSystemAccessStatus.Allowed)
    {
        m_remoteSystemWatcher = RemoteSystem.CreateWatcher();

        // Subscribing to the event raised when a new remote system is found by the watcher.
        m_remoteSystemWatcher.RemoteSystemAdded += RemoteSystemWatcher_RemoteSystemAdded;

        // Subscribing to the event raised when a previously found remote system is no longer available.
        m_remoteSystemWatcher.RemoteSystemRemoved += RemoteSystemWatcher_RemoteSystemRemoved;

        m_remoteSystemWatcher.Start();
    }
}

La première chose à faire avant d’effectuer lancement à distance est d’appeler RemoteSystem.RequestAccessAsync(). Vérifiez la valeur de retour pour vous assurer que votre application est autorisée à accéder à des appareils distants. Cette vérification peut échouer si vous n’avez ajouté la fonctionnalité remoteSystem à votre application.

Les gestionnaires d’événements de l’Observateur du système sont appelés lorsqu’un appareil auquel nous pouvons nous connecter est détecté ou n’est plus disponible. Nous allons utiliser ces gestionnaires d’événements pour conserver une liste mise à jour d’appareils auxquels nous pouvons nous connecter.

private void RemoteSystemWatcher_RemoteSystemRemoved(
    RemoteSystemWatcher sender, RemoteSystemRemovedEventArgs args)
{
    if ( m_deviceMap.ContainsKey(args.RemoteSystemId))
    {
        m_deviceList.Remove(m_deviceMap[args.RemoteSystemId]);
        m_deviceMap.Remove(args.RemoteSystemId);
    }
}

private void RemoteSystemWatcher_RemoteSystemAdded(
    RemoteSystemWatcher sender, RemoteSystemAddedEventArgs args)
{
    m_deviceList.Add(args.RemoteSystem);
    m_deviceMap.Add(args.RemoteSystem.Id, args.RemoteSystem);
}

Nous assurons le suivi des appareils par ID de système distant, à l’aide d’un dictionnaire. Un objet ObservableCollection est utilisé pour stocker la liste des appareils que nous pouvons énumérer. Un objet ObservableCollection facilite aussi la liaison de la liste des appareils à l’interface utilisateur, mais nous nous en dispenserons dans cet exemple.

private RemoteSystemWatcher m_remoteSystemWatcher;
private ObservableCollection<RemoteSystem> m_deviceList = new ObservableCollection<RemoteSystem>();
private Dictionary<string, RemoteSystem> m_deviceMap = new Dictionary<string, RemoteSystem>();

Ajoutez un appel à BuildDeviceList() dans le code de démarrage de l’application avant d’essayer de lancer une application à distance.

Lancer une application sur un appareil distant

Lancez une application à distance en passant l’appareil avec lequel vous souhaitez vous connecter à l’API RemoteLauncher.LaunchUriAsync . Il existe trois surcharges pour cette méthode. La plus simple, reprise dans cet exemple, spécifie l’URI qui active l’application sur l’appareil distant. Dans cet exemple, l’URI ouvre l’application Cartes sur l’ordinateur distant avec une vue 3D sur l’Aiguille de l’espace de Seattle.

Les autres surcharges de RemoteLauncher.LaunchUriAsync vous permettent de spécifier des options telles que l’URI du site web à afficher si aucune application capable de gérer l’URI ne peut être lancée sur l’appareil distant, et une liste facultative de noms de famille de package pouvant servir à lancer l’URI sur l’appareil distant. Vous pouvez également fournir des données sous la forme de paires clé/valeur. Vous pouvez transmettre des données à l’application que vous activez pour fournir un contexte à l’application distante, comme le nom de la chanson à lire et le lieu de lecture en cours lorsque vous basculez la lecture d’un appareil à un autre.

Concrètement, vous pouvez fournir l’interface utilisateur pour sélectionner l’appareil que vous souhaitez cibler. Mais pour simplifier cet exemple, nous allons utiliser le premier appareil distant sur la liste.

if ( m_deviceList.Count > 0)
{
    RemoteSystem SelectedDevice = m_deviceList[0];
    RemoteLaunchUriStatus launchUriStatus = 
        await RemoteLauncher.LaunchUriAsync(
            new RemoteSystemConnectionRequest(SelectedDevice), 
            new Uri("bingmaps:?cp=47.6204~-122.3491&sty=3d&rad=200&pit=75&hdg=165"));
}

L’objet RemoteLaunchUriStatus renvoyé par RemoteLauncher.LaunchUriAsync() permet de savoir si le lancement à distance a abouti ou non (et dans ce cas, la raison de l’échec).

Rubriques connexes

Référence sur l’API Systèmes distants
Vue d’ensemble des applications et appareils connectés (Project Rome)
Détecter des appareils distants
L’exemple Systèmes distants montre comment détecter un système distant, lancer une application sur un système distant et utiliser des services d’application pour échanger des messages avec des applications qui s’exécutent sur deux systèmes.