Individuare i dispositivi remoti

  • Articolo

L'app può usare la rete wireless, Bluetooth e la connessione cloud per individuare i dispositivi Windows connessi con lo stesso account Microsoft del dispositivo di individuazione. I dispositivi remoti non devono avere alcun software speciale installato per poter essere individuabili.

Nota

Questa guida presuppone che sia già stato concesso l'accesso alla funzionalità Sistemi remoti seguendo i passaggi descritti in Avviare un'app remota.

Filtrare il set di dispositivi individuabili

È possibile restringere il set di dispositivi individuabili usando RemoteSystemWatcher con filtri. I filtri possono rilevare il tipo di individuazione (rete locale e connessione cloud), il tipo di dispositivo (desktop, dispositivo mobile, Xbox, Hub e Holographic) e lo stato di disponibilità (lo stato della disponibilità di un dispositivo per l'uso delle funzionalità di sistema remoto).

Gli oggetti filtro devono essere costruiti prima o mentre l'oggetto RemoteSystemWatcher viene inizializzato, perché vengono passati come parametro nel relativo costruttore. Il codice seguente crea un filtro di ogni tipo disponibile e quindi li aggiunge a un elenco.

Nota

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

private List<IRemoteSystemFilter> makeFilterList()
{
    // construct an empty list
    List<IRemoteSystemFilter> localListOfFilters = new List<IRemoteSystemFilter>();

    // construct a discovery type filter that only allows "proximal" connections:
    RemoteSystemDiscoveryTypeFilter discoveryFilter = new RemoteSystemDiscoveryTypeFilter(RemoteSystemDiscoveryType.Proximal);


    // construct a device type filter that only allows desktop and mobile devices:
    // For this kind of filter, we must first create an IIterable of strings representing the device types to allow.
    // These strings are stored as static read-only properties of the RemoteSystemKinds class.
    List<String> listOfTypes = new List<String>();
    listOfTypes.Add(RemoteSystemKinds.Desktop);
    listOfTypes.Add(RemoteSystemKinds.Phone);

    // Put the list of device types into the constructor of the filter
    RemoteSystemKindFilter kindFilter = new RemoteSystemKindFilter(listOfTypes);


    // construct an availibility status filter that only allows devices marked as available:
    RemoteSystemStatusTypeFilter statusFilter = new RemoteSystemStatusTypeFilter(RemoteSystemStatusType.Available);


    // add the 3 filters to the listL
    localListOfFilters.Add(discoveryFilter);
    localListOfFilters.Add(kindFilter);
    localListOfFilters.Add(statusFilter);

    // return the list
    return localListOfFilters;
}

Nota

Il valore del filtro "proximal" non garantisce il grado di prossimità fisica. Per gli scenari che richiedono una prossimità fisica affidabile, usare il valore RemoteSystemDiscoveryType.SpatiallyProximal nel filtro. Attualmente, questo filtro consente solo i dispositivi individuati da Bluetooth. Poiché sono supportati nuovi meccanismi e protocolli di individuazione che garantiscono la prossimità fisica, verranno inclusi anche qui.
Esiste anche una proprietà in RemoteSystem che indica se un dispositivo individuato è effettivamente in prossimità fisica: RemoteSystem.IsAvailableBySpatialProximity.

Nota

Se si intende individuare i dispositivi in una rete locale (determinata dalla selezione del filtro del tipo di individuazione), la rete deve usare un profilo "privato" o "dominio". Il dispositivo non rileverà altri dispositivi in una rete "pubblica".

Dopo aver creato un elenco di IRemoteSystemFilter può essere passato al costruttore di un RemoteSystemWatcher.

// store filter list
List<IRemoteSystemFilter> listOfFilters = makeFilterList();

// construct watcher with the list
m_remoteSystemWatcher = RemoteSystem.CreateWatcher(listOfFilters);

Quando viene chiamato il metodo Start di questo watcher, genererà l'evento RemoteSystemAdded solo se viene rilevato un dispositivo che soddisfa tutti i seguenti criteri:

  • È individuabile da una connessione prossimale
  • Si tratta di un desktop o di un telefono
  • È classificato come disponibile

Da qui, la procedura per la gestione degli eventi, il recupero di oggetti RemoteSystem e la connessione ai dispositivi remoti è esattamente la stessa di Avvio di un'app remota. In breve, gli oggetti RemoteSystem vengono archiviati come proprietà degli oggetti RemoteSystemAddedEventArgs che vengono passati con ogni evento RemoteSystemAdded.

Individuare i dispositivi in base all'input dell'indirizzo

Alcuni dispositivi potrebbero non essere associati a un utente o individuabili con un'analisi, ma possono comunque essere raggiunti se l'app di individuazione usa un indirizzo diretto. La classe HostName viene usata per rappresentare l'indirizzo di un dispositivo remoto. Questa operazione viene spesso archiviata sotto forma di indirizzo IP, ma sono consentiti diversi altri formati (vedere il costruttore HostName per informazioni dettagliate).

Un oggetto RemoteSystem viene recuperato se viene fornito un oggetto HostName valido. Se i dati dell'indirizzo non sono validi, viene restituito un riferimento null all'oggetto.

private async Task<RemoteSystem> getDeviceByAddressAsync(string IPaddress)
{
    // construct a HostName object
    Windows.Networking.HostName deviceHost = new Windows.Networking.HostName(IPaddress);

    // create a RemoteSystem object with the HostName
    RemoteSystem remotesys = await RemoteSystem.FindByHostNameAsync(deviceHost);

    return remotesys;
}

Esecuzione di query su una funzionalità in un sistema remoto

Anche se separato dal filtro di individuazione, l'esecuzione di query sulle funzionalità del dispositivo può essere una parte importante del processo di individuazione. Usando il metodo RemoteSystem.GetCapabilitySupportedAsync, è possibile eseguire query sui sistemi remoti individuati per supportare determinate funzionalità, ad esempio la connettività della sessione remota o la condivisione dell'entità spaziale (olografica). Per l'elenco delle funzionalità eseguibili da query, vedere la classe KnownRemoteSystemCapabilities.

// Check to see if the given remote system can accept LaunchUri requests
bool isRemoteSystemLaunchUriCapable = remoteSystem.GetCapabilitySupportedAsync(KnownRemoteSystemCapabilities.LaunchUri);

Individuazione tra utenti

Gli sviluppatori possono specificare l'individuazione di tutti i dispositivi in prossimità del dispositivo client, non solo dei dispositivi registrati allo stesso utente. Questa operazione viene implementata tramite uno speciale IRemoteSystemFilter, RemoteSystemAuthorizationKindFilter. Viene implementato come gli altri tipi di filtro:

// Construct a user type filter that includes anonymous devices
RemoteSystemAuthorizationKindFilter authorizationKindFilter = new RemoteSystemAuthorizationKindFilter(RemoteSystemAuthorizationKind.Anonymous);
// then add this filter to the RemoteSystemWatcher
  • Un valore RemoteSystemAuthorizationKind di Anonymous consentirà l'individuazione di tutti i dispositivi prossimi, anche quelli di utenti non attendibili.
  • Un valore di SameUser filtra l'individuazione solo per i dispositivi registrati nello stesso utente del dispositivo client. Si tratta del comportamento predefinito.

Controllo delle impostazioni di condivisione tra utenti

Oltre al filtro precedente specificato nell'app di individuazione, il dispositivo client stesso deve essere configurato anche per consentire esperienze condivise dai dispositivi connessi con altri utenti. Si tratta di un'impostazione di sistema su cui è possibile eseguire query con un metodo statico nella classe RemoteSystem:

if (!RemoteSystem.IsAuthorizationKindEnabled(RemoteSystemAuthorizationKind.Anonymous)) {
	// The system is not authorized to connect to cross-user devices. 
	// Inform the user that they can discover more devices if they
	// update the setting to "Anonymous".
}

Per modificare questa impostazione, l'utente deve aprire l'app Impostazioni. Nel menu Sistema>Esperienze condivise>Condividi tra dispositivi è disponibile una casella a discesa in cui l'utente può specificare i dispositivi con cui il sistema può condividere.

shared experiences settings page