Descobrir dispositivos remotos

  • Artigo

O aplicativo pode usar a rede sem fio, Bluetooth e uma conexão na nuvem para descobrir dispositivos Windows conectados com a mesma conta da Microsoft que o dispositivo de descoberta. Os dispositivos remotos não precisam ter nenhum software especial instalado para ser descoberto.

Observação

Este guia considera que você já tenha obtido acesso ao recurso Sistemas Remotos seguindo as etapas em Iniciar um aplicativo remoto.

Filtrar o conjunto de dispositivos detectáveis

Você pode reduzir o conjunto de dispositivos detectáveis usando um RemoteSystemWatcher com filtros. Os filtros podem detectar o tipo de detecção (proximal, rede local e conexão de nuvem), o tipo de dispositivo (desktop, dispositivo móvel, Xbox, Hub e holográfico) e o status de disponibilidade (o status de disponibilidade do dispositivo para usar recursos de Sistema remoto).

Os objetos de filtro devem ser construídos antes ou enquanto o objeto RemoteSystemWatcher é inicializado, pois são transmitidos como um parâmetro no construtor. O código a seguir cria um filtro de cada tipo disponível e, em seguida, os adiciona a uma lista.

Observação

O código nestes exemplos exige que você tenha uma instrução using Windows.System.RemoteSystems no seu arquivo.

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

Observação

O valor de filtro "proximal" não garante o grau de proximidade física. Para cenários que exigem uma proximidade física confiável, use o valor RemoteSystemDiscoveryType.SpatiallyProximal no filtro. No momento, esse filtro permite somente dispositivos descobertos por Bluetooth. Como novos mecanismos de descoberta e protocolos que garantem a proximidade física são compatíveis, eles serão incluídos aqui também.
Há também uma propriedade na classe RemoteSystemque indica se um dispositivo descoberto está na verdade na proximidade física: RemoteSystem.IsAvailableBySpatialProximity.

Observação

Se você pretende descobrir dispositivos em uma rede local (determinada pela seleção do filtro de tipo de descoberta), a rede precisa usar um perfil "privado" ou de "domínio". O dispositivo não vai descobrir outros dispositivos em uma rede "pública".

Depois que uma lista de objetos IRemoteSystemFilter é criada, ela pode ser transmitida para o construtor de um RemoteSystemWatcher.

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

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

Quando o método Start desse inspetor for chamado, ele acionará o evento RemoteSystemAdded somente se for detectado um dispositivo que atenda a todos os seguintes critérios:

  • Ele é detectável por conexão proximal
  • É um desktop ou um telefone
  • Ele é classificado como disponível

A partir daí, o procedimento para tratar eventos, recuperar objetos RemoteSystem e se conectar a dispositivos remotos é exatamente o mesmo descrito em Iniciar um aplicativo remoto. Ou seja, os objetos RemoteSystem são armazenados como propriedades dos objetos RemoteSystemAddedEventArgs, que são passados em cada evento RemoteSystemAdded.

Descobrir dispositivos por entrada de endereço

Alguns dispositivos podem não estar associados um usuário nem ser detectáveis com uma verificação, mas eles ainda poderão ser acessados se o aplicativo descoberto usar um endereço direto. A classe HostName é usada para representar o endereço de um dispositivo remoto. Isso geralmente é armazenado na forma de um endereço IP, mas vários outros formatos são permitidos (consulte o Construtor HostName para obter detalhes).

Um objeto RemoteSystem será recuperado se o objeto HostName válido for fornecido. Se os dados de endereço forem inválidos, uma referência ao objeto null será retornada.

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

Consultando uma funcionalidade em um sistema remoto

Embora separada da filtragem de descoberta, consultar os recursos do dispositivo pode ser uma parte importante do processo de detecção. Com o método RemoteSystem.GetCapabilitySupportedAsync, você pode consultar sistemas remotos descobertos para oferecer suporte a determinados recursos, como conectividade de sessão remota ou compartilhamento de entidade espacial (holográfica). Consulte a classe KnownRemoteSystemCapabilities para obter a lista dos recursos que podem ser consultados.

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

Descoberta entre usuários

Os desenvolvedores podem especificar a detecção de todos os dispositivos próximos ao dispositivo cliente, não apenas dispositivos registrados para o mesmo usuário. Isso é implementado por meio um IRemoteSystemFilter, RemoteSystemAuthorizationKindFilter especial. Ele é implementado como os outros tipos de filtro:

// Construct a user type filter that includes anonymous devices
RemoteSystemAuthorizationKindFilter authorizationKindFilter = new RemoteSystemAuthorizationKindFilter(RemoteSystemAuthorizationKind.Anonymous);
// then add this filter to the RemoteSystemWatcher
  • A valor RemoteSystemAuthorizationKind de Anônimo permite a detecção de todos os dispositivos proximais, mesmo aqueles de usuários não confiáveis.
  • Um valor SameUser filtra a descoberta somente para dispositivos registrados do mesmo usuário como o dispositivo cliente. Esse é o comportamento padrão.

Verificar as configurações de Compartilhamento entre usuários

Além do filtro acima especificado no seu aplicativo de descoberta, o próprio dispositivo cliente também deve ser configurado para permitir experiências compartilhadas de dispositivos registrados com outros usuários. Essa é uma configuração de sistema que pode ser consultada com um método estático na 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".
}

Para alterar essa configuração, o usuário deve abrir o aplicativo de Configurações. No menu Compartilharexperiências>compartilhadas do sistema > entre dispositivos, há uma caixa suspensa na qual o usuário pode especificar com quais dispositivos seu sistema pode compartilhar.

página de configuração de experiências compartilhadas