Avviare un'app su un dispositivo remotoLaunch an app on a remote device

Questo articolo descrive come avviare un'app di Windows su un dispositivo remoto.This article explains how to launch a Windows app on a remote device.

A partire da Windows 10 versione 1607, un'app UWP può avviare un'app UWP o un'applicazione desktop di Windows in remoto su un altro dispositivo che esegue sempre Windows 10 versione 1607 o successiva, purché sia stato usato lo stesso account Microsoft per accedere a entrambi i dispositivi.Starting in Windows 10, version 1607, a UWP app can launch a UWP app or Windows desktop application remotely on another device that is also running Windows 10, version 1607 or later, provided that both devices are signed on with the same Microsoft Account (MSA). Questo è il caso d'uso più semplice di Project Rome.This is the simplest use case of Project Rome.

La funzionalità avvio remoto consente esperienze utente orientate alle attività; un utente può avviare un'attività in un dispositivo e terminarla in un'altra.The remote launch feature enables task-oriented user experiences; a user can start a task on one device and finish it on another. Se, ad esempio, l'utente è in ascolto di musica sul proprio telefono nell'auto, potrebbe quindi consegnare la funzionalità di riproduzione alla propria Xbox quando arrivano a casa.For example, if the user is listening to music on their phone in their car, they could then hand playback functionality over to their Xbox One when they arrive at home. L'avvio remoto consente alle app di passare i dati contestuali all'app remota avviata, in modo da prelevare il punto in cui l'attività è stata abbandonata.Remote launch allows apps to pass contextual data to the remote app being launched, in order to pick up where the task was left off.

Installazione preliminarePreliminary setup

Aggiungere la funzionalità RemoteSystemAdd the remoteSystem capability

Se vuoi che la tua app avvii un'app su un dispositivo remoto, devi aggiungere la funzionalità remoteSystem al manifesto del pacchetto dell'app.In order for your app to launch an app on a remote device, you must add the remoteSystem capability to your app package manifest. È possibile usare la finestra di progettazione del manifesto del pacchetto per aggiungerla selezionando sistema remoto nella scheda funzionalità oppure è possibile aggiungere manualmente la riga seguente al file Package. appxmanifest del progetto.You can use the package manifest designer to add it by selecting Remote System on the Capabilities tab, or you can manually add the following line to your project's Package.appxmanifest file.

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

Abilita condivisione tra dispositiviEnable cross-device sharing

Inoltre, il dispositivo client deve essere impostato in modo da consentire la condivisione tra dispositivi.Additionally, the client device must be set to allow cross-device sharing. Questa impostazione, a cui è possibile accedere in Impostazioni: Condividi le esperienze di sistema > condivise > tra i dispositivi, è abilitata per impostazione predefinita.This setting, which is accessed in Settings: System > Shared experiences > Share across devices, is enabled by default.

pagina Impostazioni esperienze condivise

Trovare un dispositivo remotoFind a remote device

Per prima cosa devi trovare il dispositivo con cui vuoi connetterti.You must first find the device that you want to connect with. Individuare i dispositivi remoti ti spiega dettagliatamente come farlo.Discover remote devices discusses how to do this in detail. Useremo qui un semplice approccio che non include il filtro per tipo di dispositivo o connettività.We'll use a simple approach here that forgoes filtering by device or connectivity type. Creeremo un watcher di sistema remoto che cercherà i dispositivi remoti e scriverà i gestori per gli eventi generati quando vengono individuati o rimossi dispositivi.We will create a remote system watcher that looks for remote devices, and write handlers for the events that are raised when devices are discovered or removed. Questo ci fornirà una raccolta di dispositivi remoti.This will provide us with a collection of remote devices.

Per il codice in questi esempi è necessario disporre using Windows.System.RemoteSystems di un'istruzione nei file di classe.The code in these examples requires that you have a using Windows.System.RemoteSystems statement in your class file(s).

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 prima cosa che devi fare prima di eseguire un avvio remoto è chiamare RemoteSystem.RequestAccessAsync().The first thing you must do before making a remote launch is call RemoteSystem.RequestAccessAsync(). Controlla il valore restituito per verificare che l'app possa accedere ai dispositivi remoti.Check the return value to make sure your app is allowed to access remote devices. Uno dei motivi per cui questo controllo potrebbe non riuscire è che tu non abbia aggiunto la funzionalità remoteSystem all'app.One reason this check could fail is if you haven't added the remoteSystem capability to your app.

Il gestori eventi del watcher di sistema vengono chiamati quando un dispositivo a cui possiamo connetterci viene individuato o non è più disponibile.The system watcher event handlers are called when a device that we can connect with is discovered or is no longer available. Useremo questi gestori eventi per mantenere un elenco aggiornato di dispositivi a cui possiamo connetterci.We will use these event handlers to keep an updated list of devices that we can connect to.

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

Terremo traccia dei dispositivi con l'ID sistema remoto usando un dizionario.We will track the devices by remote system ID using a Dictionary. Un oggetto ObservableCollection viene usato per contenere l'elenco dei dispositivi che possiamo enumerare.An ObservableCollection is used to hold the list of devices that we can enumerate. Un oggetto ObservableCollection semplifica anche l'associazione dell'elenco di dispositivi all'interfaccia utente, ma in questo esempio non lo useremo.An ObservableCollection also makes it easy to bind the list of devices to UI, though we won't do that in this example.

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

Aggiungi una chiamata a BuildDeviceList() nel codice di avvio dell'app prima di tentare di avviare un'app remota.Add a call to BuildDeviceList() in your app startup code before you attempt to launch a remote app.

Avviare un'app su un dispositivo remotoLaunch an app on a remote device

Avviare un'app in modalità remota passando il dispositivo a cui si vuole connettersi con l'API RemoteLauncher. LaunchUriAsync .Launch an app remotely by passing the device you wish to connect with to the RemoteLauncher.LaunchUriAsync API. Esistono tre overload per questo metodo.There are three overloads for this method. Il più semplice, mostrato in questo esempio, specifica l'URI che attiverà l'app sul dispositivo remoto.The simplest, which this example demonstrates, specifies the URI that will activate the app on the remote device. In questo esempio l'URI apre l'app Mappe nel computer remoto con una visualizzazione 3D dello Space Needle.In this example the URI opens the Maps app on the remote machine with a 3D view of the Space Needle.

Gli altri overload RemoteLauncher.LaunchUriAsync ti permettono di specificare opzioni come l'URI del sito Web per verificare se nessuna app appropriata può essere avviata sul dispositivo remoto e per visualizzare un elenco facoltativo di nomi delle famiglie di pacchetti che possono essere usati per avviare l'URI sul dispositivo remoto.Other RemoteLauncher.LaunchUriAsync overloads allow you to specify options such as the URI of the web site to view if no appropriate app can be launched on the remote device, and an optional list of package family names that could be used to launch the URI on the remote device. Puoi anche fornire dati sotto forma di coppie chiave/valore.You can also provide data in the form of key/value pairs. Puoi passare i dati all'app che stai attivando per fornire il contesto all'app remota, ad esempio il titolo della canzone da riprodurre e la posizione di riproduzione attuale, quando trasferisci la riproduzione da un dispositivo a un altro.You might pass data to the app you are activating to provide context to the remote app, such as the name of the song to play and the current playback location when you hand off playback from one device to another.

In scenari reali potresti fornire un'interfaccia utente per selezionare il dispositivo che vuoi usare.In practical scenarios, you might provide UI to select the device you want to target. Per semplificare questo esempio, tuttavia, useremo solo il primo dispositivo remoto nell'elenco.But to simplify this example, we'll just use the first remote device on the list.

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'oggetto RemoteLaunchUriStatus restituito da RemoteLauncher.LaunchUriAsync() fornisce informazioni che indicano se l'avvio remoto è avvenuto e, in caso contrario, il motivo per cui non è riuscito.The RemoteLaunchUriStatus object that is returned from RemoteLauncher.LaunchUriAsync() provides information about whether the remote launch succeeded, and if not, the reason why.

Informazioni di riferimento sull'API Remote SystemsRemote Systems API reference
App e dispositivi connessi (Project Rome) PanoramicaConnected apps and devices (Project Rome) overview
Individuare i dispositivi remotiDiscover remote devices
L'esempio Remote Systems illustra come individuare un sistema remoto, avviare un'app in un sistema remoto e usare i servizi app per inviare messaggi tra le app in esecuzione su due sistemi.Remote Systems sample demonstrates how to discover a remote system, launch an app on a remote system, and use app services to send messages between apps running on two systems.