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.

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.

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

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.

Tópicos relacionados

• Aplicativos e dispositivos conectados (Project Rome)
• Iniciar um aplicativo remoto
• Referência da API de Sistemas Remotos
• Exemplo de Sistemas Remotos