Descobrir dispositivos remotos
Seu aplicativo pode usar a rede sem fio, o Bluetooth e a conexão de 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 serem detectáveis.
Observação
Este guia pressupõe que você já tenha recebido acesso ao recurso Sistemas remotos seguindo as etapas em Iniciar um aplicativo remoto.
Filtrar o conjunto de dispositivos detectáveis
Você pode restringir o conjunto de dispositivos detectáveis usando um RemoteSystemWatcher com filtros. Os filtros podem detectar o tipo de descoberta (rede proximal versus rede local versus conexão de nuvem), tipo de dispositivo (área de trabalho, dispositivo móvel, Xbox, Hub e Holográfico) e status de disponibilidade (o status da disponibilidade de um dispositivo para usar os recursos do Sistema Remoto).
Os objetos de filtro devem ser construídos antes ou enquanto o objeto RemoteSystemWatcher é inicializado, pois eles são passados como um parâmetro para seu construtor. O código a seguir cria um filtro de cada tipo disponível e os adiciona a uma lista.
Observação
O código nesses exemplos requer que você tenha uma using Windows.System.RemoteSystems instrução em 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 do filtro "proximal" não garante o grau de proximidade física. Para cenários que exigem proximidade física confiável, use o valor RemoteSystemDiscoveryType.SpatiallyProximal em seu filtro. Atualmente, esse filtro permite apenas dispositivos descobertos por Bluetooth. À medida que novos mecanismos e protocolos de descoberta que garantem a proximidade física são suportados, eles também serão incluídos aqui.
Há também uma propriedade na classe RemoteSystem que indica se um dispositivo descoberto está de fato dentro da proximidade física: RemoteSystem.IsAvailableBySpatialProximity.
Observação
Se você pretende descobrir dispositivos em uma rede local (determinado pela seleção do filtro do tipo de descoberta), sua rede precisa estar usando um perfil "privado" ou "domínio". Seu dispositivo não descobrirá outros dispositivos em uma rede "pública".
Depois que uma lista de objetos IRemoteSystemFilter é criada, ela pode ser passada 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 observador for chamado, ele gerará o evento RemoteSystemAdded somente se for detectado um dispositivo que atenda a todos os seguintes critérios:
- É detectável por conexão proximal
- É um desktop ou telefone
- É classificado como disponível
A partir daí, o procedimento para lidar com eventos, recuperar objetos RemoteSystem e conectar-se a dispositivos remotos é exatamente o mesmo que em Iniciar um aplicativo remoto. Em resumo, os objetos RemoteSystem são armazenados como propriedades de objetos RemoteSystemAddedEventArgs, que são passados com cada evento RemoteSystemAdded .
Descobrir dispositivos por entrada de endereço
Alguns dispositivos podem não estar associados a um usuário ou detectáveis a uma verificação, mas ainda podem ser acessados se o aplicativo de descoberta 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 um objeto HostName válido for fornecido. Se os dados de endereço forem inválidos, uma referência de null objeto 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 um recurso em um sistema remoto
Embora separado da filtragem de descoberta, consultar os recursos do dispositivo pode ser uma parte importante do processo de descoberta. Usando o método RemoteSystem.GetCapabilitySupportedAsync , você pode consultar sistemas remotos descobertos para obter 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 de recursos consultáveis.
// 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 descoberta de todos os dispositivos próximos ao dispositivo cliente, não apenas dispositivos registrados para o mesmo usuário. Isso é implementado por meio de um IRemoteSystemFilter especial, RemoteSystemAuthorizationKindFilter. 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
- Um valor RemoteSystemAuthorizationKind de Anonymous permitirá a descoberta de todos os dispositivos proximais, mesmo aqueles de usuários não confiáveis.
- Um valor de SameUser filtra a descoberta apenas para dispositivos registrados para o mesmo usuário que o dispositivo cliente. Esse é o comportamento padrão.
Verificando as configurações de compartilhamento entre usuários
Além do filtro acima ser especificado em seu aplicativo de descoberta, o próprio dispositivo cliente também deve ser configurado para permitir experiências compartilhadas de dispositivos conectados com outros usuários. Esta é uma configuração do 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 Configurações . No menu Experiências>compartilhadas do sistema>Compartilhar entre dispositivos, há uma caixa suspensa em que o usuário pode especificar com quais dispositivos seu sistema pode compartilhar.
