Condividi tramite

Avviare un'app su un dispositivo remoto

  • Articolo

Questo articolo illustra come avviare un'app di Windows in un dispositivo remoto.

A partire da Windows 10 versione 1607, un'app UWP può avviare un'app UWP o un'applicazione desktop di Windows in remoto in un altro dispositivo che esegue anche Windows 10 versione 1607 o successiva, purché entrambi i dispositivi siano connessi con lo stesso account Microsoft (MSA). Questo è il caso d'uso più semplice di Project Rome.

La funzionalità di avvio remoto consente esperienze utente orientate alle attività; un utente può avviare un'attività in un dispositivo e completarla in un'altra. Ad esempio, se l'utente sta ascoltando musica sul telefono nella propria auto, potrebbe quindi consegnare la funzionalità di riproduzione a Xbox One quando arrivano a casa. L'avvio remoto consente alle app di passare dati contestuali all'app remota avviata, per riprendere la posizione in cui è stata interrotta l'attività.

Impostazioni preliminari

Aggiungere la funzionalità remoteSystem

Per consentire all'app di avviare un'app in un dispositivo remoto, è necessario aggiungere la funzionalità remoteSystem al manifesto del pacchetto dell'app. È possibile usare la finestra di progettazione del manifesto del pacchetto per aggiungerla selezionando Sistema remoto nella scheda Capacità, oppure aggiungere manualmente la riga seguente al file Package.appxmanifest del progetto.

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

Abilitare la condivisione tra dispositivi

Inoltre, il dispositivo client deve essere impostato per consentire la condivisione tra dispositivi. Questa impostazione, accessibile in Impostazioni: Sistema>Esperienze condivise>Condivisione tra dispositivi, è abilitata per impostazione predefinita.

pagina delle impostazioni delle esperienze condivise

Trovare un dispositivo remoto

Si deve prima trovare il dispositivo con cui ci si vuole connettere. Individuare i dispositivi remoti illustra in dettaglio come eseguire questa operazione. In questo caso si userà un approccio semplice che consente di filtrare in base al tipo di dispositivo o di connettività. Verrà creato un watcher di sistema remoto che cerca i dispositivi remoti e scriverà i gestori per gli eventi generati quando i dispositivi vengono individuati o rimossi. Questo ci fornirà una raccolta di dispositivi remoti.

Il codice in questi esempi richiede che nel file sia presente un'istruzione using Windows.System.RemoteSystems nella classe di file.

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 da fare prima di effettuare un avvio remoto è chiamare RemoteSystem.RequestAccessAsync(). Controllare il valore restituito per assicurarsi che l'app sia autorizzata ad accedere ai dispositivi remoti. Un motivo per cui questo controllo potrebbe non riuscire è che non sia stata aggiunta la funzionalità remoteSystem all'app.

I gestori eventi di System Watcher vengono chiamati quando un dispositivo con cui è possibile connettersi viene individuato o non è più disponibile. Questi gestori eventi verranno usati per mantenere un elenco aggiornato dei dispositivi a cui è possibile connettersi.

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

I dispositivi verranno monitorati in base all'ID sistema remoto usando un Dizionario. Un ObservableCollection viene usato per contenere l'elenco dei dispositivi che è possibile enumerare. ObservableCollection semplifica anche l'associazione dell'elenco di dispositivi all'interfaccia utente, anche se non verrà eseguita in questo esempio.

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

Aggiungere una chiamata a BuildDeviceList() nel codice di avvio dell'app prima di tentare di avviare un'app remota.

Avviare un'app su un dispositivo remoto

Avviare un'app in modalità remota passando il dispositivo a cui ci si vuole connettere all'API RemoteLauncher.LaunchUriAsync. Esistono tre overload per questo metodo. Il più semplice, illustrato in questo esempio, specifica l'URI che attiverà l'app nel dispositivo remoto. In questo esempio l'URI apre l'app Mappe nel computer remoto con una visualizzazione 3D dello Space Needle.

Altri overload RemoteLauncher.LaunchUriAsync consentono di specificare opzioni quali l'URI del sito Web da visualizzare se non è possibile avviare un'app appropriata nel dispositivo remoto e un elenco facoltativo di nomi di famiglia di pacchetti che potrebbero essere usati per avviare l'URI nel dispositivo remoto. È anche possibile fornire dati sotto forma di coppie chiave/valore. Puoi passare i dati all'app che stai attivando per fornire contesto all'app remota, ad esempio il nome del brano da riprodurre e la posizione di riproduzione corrente quando passi la riproduzione da un dispositivo a un altro.

In scenari pratici, è possibile fornire l'interfaccia utente per selezionare il dispositivo di destinazione. Tuttavia, per semplificare questo esempio, si userà solo il primo dispositivo remoto nell'elenco.

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 sull'esito positivo dell'avvio remoto e, in caso contrario, sul motivo.

Riferimento alle API di Sistemi remoti
Panoramica app e dispositivi connessi (progetto Rome)
Individuare i dispositivi remoti
L'esempio di Sistemi remoti dimostra come individuare il sistema remoto, avviare un'app in un sistema remoto e usare i servizi app per inviare messaggi tra app in esecuzione in due sistemi.