Partager via

Lancer une application sur un appareil distant

  • Article

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

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

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

Paramétrage préliminaire

Ajouter la fonctionnalité remoteSystem

Pour que votre application lance une application sur un appareil distant, vous devez ajouter la remoteSystem fonctionnalité au 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ées système>entre appareils, est activé par défaut.

page des paramètres d’expériences partagées

Rechercher un appareil distant

Vous devez d’abord trouver l’appareil avec lequel vous souhaitez vous connecter. Découvrir les appareils distants explique comment procéder en détail. Nous allons utiliser ici une approche simple qui filtre par appareil ou type de connectivité. Nous allons créer un observateur de système distant qui recherche des appareils distants et écrit des gestionnaires pour les événements déclenchés lorsque les appareils sont découverts ou supprimés. Cela nous fournira une collection d’appareils distants.

Le code de ces exemples nécessite que vous ayez une using Windows.System.RemoteSystems instruction dans votre ou 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 que vous devez faire avant d’effectuer un lancement distant est l’appel RemoteSystem.RequestAccessAsync(). Vérifiez la valeur de retour pour vous assurer que votre application est autorisée à accéder aux appareils distants. Une raison pour laquelle cette vérification peut échouer est si vous n’avez pas ajouté la remoteSystem fonctionnalité à votre application.

Les gestionnaires d’événements de l’observateur système sont appelés lorsqu’un appareil avec lequel nous pouvons nous connecter est découvert ou n’est plus disponible. Nous allons utiliser ces gestionnaires d’événements pour conserver une liste mise à jour des 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 allons suivre les appareils par ID système distant à l’aide d’un dictionnaire. Un ObservableCollection est utilisé pour contenir la liste des appareils que nous pouvons énumérer. Un ObservableCollection facilite également la liaison de la liste des appareils à l’interface utilisateur, mais nous ne le ferons pas 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 au BuildDeviceList() code de démarrage de votre application avant de tenter de lancer une application distante.

Lancer une application sur un appareil distant

Lancez une application à distance en transmettant l’appareil avec lequel vous souhaitez vous connecter à l’API RemoteLauncher.LaunchUriAsync . Il existe trois surcharges pour cette méthode. Le plus simple, que cet exemple illustre, 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 de l’aiguille spatiale.

D’autres surcharges RemoteLauncher.LaunchUriAsync vous permettent de spécifier des options telles que l’URI du site web à afficher si aucune application appropriée ne peut être lancée sur l’appareil distant et une liste facultative de noms de famille de packages qui peuvent être utilisés pour 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, par exemple le nom de la chanson à lire et l’emplacement de lecture actuel lorsque vous transférez la lecture d’un appareil à un autre.

Dans des scénarios pratiques, vous pouvez fournir une interface utilisateur pour sélectionner l’appareil que vous souhaitez cibler. Mais pour simplifier cet exemple, nous allons simplement utiliser le premier appareil distant dans 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 retourné à partir de RemoteLauncher.LaunchUriAsync() fournit des informations sur la réussite du lancement distant et, si ce n’est pas le cas, la raison pour laquelle.

Informations de 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 De systèmes distants montre comment découvrir un système distant, lancer une application sur un système distant et utiliser les services d’application pour envoyer des messages entre les applications s’exécutant sur deux systèmes.